Mathematical models for cellular interactions in development I. Filaments with one-sided inputs

TL;DR — In 1968 Aristid Lindenmayer proposed treating a growing organism as a parallel string-rewriting machine: every cell is a symbol, every symbol applies a local rule simultaneously, and a few lines of grammar unfold into a large, structured body. This is the cleanest formal statement ever made of the genotype-to-phenotype map — a tiny program that grows a big adaptive structure — and it's the same question that haunts modern AI (why can a ~1 GB genome wire a 10¹⁴-synapse brain?). L-systems conquered computer graphics decades ago; what's newly possible is making developmental encodings trainable — via neural cellular automata, differentiable program relaxation, and LLM-driven program synthesis — and finally testing whether growing a network beats specifying one.

The idea, as Lindenmayer had it

Lindenmayer was a botanist thinking about filamentous organisms — chains of cells like the cyanobacterium Anabaena, where cells divide, differentiate, and occasionally form specialized heterocysts at oddly regular spacings. His move was to strip the biology down to a formal model: a filament is a string of symbols, each symbol is a cell in some state (a finite automaton), and at every time step all cells rewrite at once according to local rules. In this first paper the rules are "one-sided": each cell's next state depends on its own state plus input from one neighbor, modeling polarized signaling along the filament. (Part II, published back-to-back, does two-sided inputs.)

The crucial departure from Chomsky grammars — which were the hot formalism of the day — is parallelism. A Chomsky derivation rewrites one symbol at a time; that's fine for sentences, wrong for organisms, where every cell lives and divides concurrently. That single change makes the generated languages formally different (the "L-systems" family became its own branch of formal language theory in the 1970s) and, more importantly, makes the model developmental: time steps are developmental stages, and the string at step n is the organism at age n.

The canonical toy (a simplification of Lindenmayer's Anabaena model, which also tracked cell polarity) is two symbols with rules a \to ab, b \to a. Start from a and let everything rewrite in lockstep:

Note what's not in the 1968 paper: no bracket notation for branching (Lindenmayer added [ ] for lateral branches in the early 1970s), no turtle graphics, no pictures of plants. Those came with Prusinkiewicz and collaborators in the mid-1980s. The 1968 papers are dense theoretical biology worked out with pencil-and-paper derivations and comparisons to observed cell-division patterns.

Why it could not work then

Three walls, in increasing order of hardness.

Simulation and rendering. In 1968 a departmental machine was something like an IBM 360 doing on the order of 10⁵–10⁶ instructions per second with kilobytes-to-a-few-hundred-kilobytes of core memory. String lengths under exponential growth explode fast; a 20-step derivation of a bushy branching grammar can have 10⁵–10⁶ symbols. Simulating that was marginal; seeing it was impossible — there were no raster displays, no cheap plotters, no way to render a generated tree and judge it against a real one. The geometric interpretation of L-systems (turtle graphics, 3D branching, tropisms) that made them famous required exactly the graphics hardware of the 1980s–90s.

Search over grammars. The interesting scientific move — vary the rules, evolve them, see which developmental programs are reachable — requires evaluating thousands to millions of grammars, each of which requires simulation and (usually) rendering plus a fitness measure. That's a 1990s-scale compute budget at minimum (Karl Sims needed a Connection Machine in 1994 for a conceptually similar search).

The inverse problem. Given an observed form — a real Anabaena filament, a real elm — infer the grammar. This is grammar induction, which is intractable in general (identification-in-the-limit results were just appearing; Gold's theorem is 1967), and for parallel context-sensitive systems it's worse. In 1968 there was no conceivable attack. This remained essentially untouched for fifty years and is only now becoming a plausible ML problem.

What changed

Graphics vindicated the forward direction. Prusinkiewicz's work and The Algorithmic Beauty of Plants (1990) turned L-systems into the standard model for plant form; descendants (SpeedTree and kin) put L-system-style procedural vegetation in essentially every film and game. This proved Lindenmayer's core claim empirically: tiny rule sets really do generate realistic organic architectures. But these grammars are hand-written.

Developmental encodings entered AI — and showed a signal. Hornby and Pollack (~2001) evolved robot morphologies with L-system generative encodings and found they outperformed direct encodings — bigger, more regular, more evolvable designs. CPPNs and HyperNEAT (Stanley, ~2007) pursued the same compression idea for neural network weights. Zador's "genomic bottleneck" argument (2019) reframed it for deep learning: the genome is a compressed prior over wiring, and that compression may be why animals learn so sample-efficiently. Koulakov and colleagues have since shown that compressing network weights through a genomic-bottleneck encoder can preserve much of performance — the same claim in modern dress.

Growth became differentiable. Neural cellular automata (Mordvintsev et al., 2020) are, structurally, Lindenmayer's model with the rule table replaced by a small neural network and the discrete alphabet replaced by continuous state vectors — and they're trained by backpropagation through the growth process. That is the piece 1968 (and 1990, and 2001) lacked: gradients through development.

Program synthesis got strong. LLM-based synthesis and neurosymbolic search can now propose symbolic rewrite rules from examples, making the inverse problem — infer an L-system from images of a plant or a neuron's arbor — attackable for the first time. There is scattered recent work on L-system inference with deep learning; to my knowledge nothing definitive yet.

What a serious 2026 revival looks like

The scientific question Lindenmayer left open, translated into ML terms: does a developmental (grown) parameterization of a large structure generalize and evolve better than a direct parameterization of the same structure? A clean program:

1. A differentiable L-system. Keep the 1968 skeleton: a string (or graph) of cells, synchronous local rewriting, context from one or two neighbors — Lindenmayer's "one-sided input" is exactly a causal, local message pass. Replace the finite alphabet with learned cell-state embeddings and the rule table with a small shared network; make division a relaxed/stochastic operation (Gumbel or straight-through) so growth is trainable end-to-end. This sits between classical L-systems (symbolic, interpretable, but not trainable) and NCA (trainable, but fixed-lattice — NCAs don't naturally add cells, which was Lindenmayer's whole point).

2. Grow things that matter. Two testbeds: (a) grow the wiring of a network that is then trained briefly on tasks — measuring whether the developmental prior buys sample efficiency, the Zador question quantified; (b) grow robot morphologies (voxel soft robots or articulated trees, where the branching-string phenotype is natural) and measure evolvability: how often do rule mutations produce coherent, coordinated phenotypic changes rather than noise?

3. The controls. Match parameter counts against direct encoding and against non-developmental compression (e.g., a hypernetwork). The hypothesis is specifically that iterated local growth — not compression per se — supplies regularity, symmetry, and reuse.

4. The inverse problem. Separately, use an LLM-in-the-loop synthesizer to recover symbolic L-systems from rendered and real plant/neuron imagery, scoring candidates by simulate-and-compare. Success here would give biology something it has never had: automatic developmental-program inference from time-lapse microscopy — closing the loop back to Anabaena.

Keep from 1968: parallelism, locality, context-sensitivity as signaling, the string-as-organism abstraction, and the taste for minimal alphabets. Replace: hand-derivation with gradients, and human rule-writing with synthesis.

Already tried, still open

Vindicated: the forward generative claim (graphics, thoroughly); the evolvability advantage of generative encodings (Hornby & Pollack, Sims, soft-robot work by Cheney et al., though at small scale); the trainable-growth mechanism (NCA, including work on growing and self-repairing structures and NCA-grown network weights). Lindenmayer's model also fed a genuine formal-language subfield (D0L/context-sensitive L-systems, decidability results) that is mostly closed.

Still open, and this is the ripe part: no one has convincingly shown, at modern scale, that a developmental genome improves generalization of large neural networks — the genomic-bottleneck results are suggestive, not decisive, and the developmental-versus-direct question has never been run with today's compute and gradient tools. The inverse problem is barely touched. And there is no accepted theory of why developmental compression should help — whether it's an MDL argument, a symmetry prior, or something about the reachability structure of grammar space under mutation. A 2026 revival could settle the empirical half of that within a year of GPU time.

Where to read it

The paper: doi.org/10.1016/0022-5193(68)90079-9 (bibliographic details verified; read Part II, published alongside, for two-sided inputs). Pair it with Prusinkiewicz & Lindenmayer's The Algorithmic Beauty of Plants (1990, free online) to see the forward problem solved; Hornby & Pollack (2001) for the first evolvability evidence; Zador, "A critique of pure learning" (2019) for the genomic-bottleneck framing; and Mordvintsev et al., "Growing Neural Cellular Automata" (Distill, 2020), which is — whether its authors framed it that way or not — Lindenmayer 1968 made differentiable.