Life on a String

1 · The String

Take the simplest universe you can imagine that still does something: a row of cells, each either on or off, evolving in lockstep by one fixed rule. Each cell looks at itself and its two neighbors — three bits — and the rule says what it becomes next. That's the whole physics. No forces, no fields, no geometry beyond left and right. A universe one cell tall. A string.

Here is one such rule — Rule 110 — started from a single lit cell. Each row of pixels is one instant; time flows downward. Press play.

What you're watching is called a space-time diagram, and it's worth pausing on what it really is: the entire history of a one-dimensional universe, laid out as a two-dimensional picture. Physicists have a name for exactly this object. When a string moves through time, the surface it sweeps out is its worldsheet. Every figure in this essay is a worldsheet — the complete biography of a string.

Start the same rule from random noise instead, and something stranger happens. The chaos curdles. A repeating background texture — call it a vacuum — takes over, and against it, persistent structures survive: little patterns that hold their shape and glide left or right at fixed speeds, colliding, annihilating, passing through one another.

Those gliding structures are not painted on. Nothing in the rule mentions them. They emerge — particles condensing out of a one-dimensional physics three bits wide. In the next chapter we'll meet them properly: a zoo of particle species with fixed sizes, velocities, and collision rules.

This essay follows a recent paper by Jordan Cotler, Clément Hongler, and Barbora Hudcová — Self-replication and Computational Universality — which asks two of the deepest questions you can pose about such a universe, questions von Neumann first asked of richer worlds in the 1940s:

1. Can it compute? Could this string, suitably arranged, run any program — be a universal computer?
2. Can it live? Could a pattern on this string build a working copy of itself, the way a cell does — and keep doing so, copies making copies, indefinitely?

For eighty years the folklore answer has been that these are almost the same question — that universal computation is the hard part, and self-replication comes along for the ride. The paper's surprise is that the folklore is wrong: a universe can be a universal computer and still be sterile. Computation is not life. What separates them is the subject of everything that follows.

2 · Particles from Nothing

Chapter 1 ended on an unresolved image: start Rule 110 from random noise and the noise doesn't stay random. It curdles into a repeating background, and riding on top of that background, a handful of little shapes survive — gliding, colliding, refusing to dissolve. Here it is again.

This chapter gives that picture a vocabulary: a vacuum, and the particles that live in it.

The vacuum

The repeating background is worth taking seriously as an object in its own right, because it's the thing everything else is measured against. Settle a random soup for long enough under Rule 110 and, almost everywhere, it locks into the same 14-cell stretch repeated end to end: 00010011011111. We didn't get this tile from a table in a paper — we found it the way you'd find any periodicity in a signal: run the soup out, then scan the settled row for a block that repeats itself. Call that tile the ether.

The ether isn't static. Step it forward and it drifts 4 cells to the left every step. After 7 steps that drift totals 28 cells — exactly two tiles — so the row lines up with itself again exactly. So this vacuum has a heartbeat (period 7) and a drift (4 cells left per step) that adds up to a whole number of tiles every beat — a rest frame baked into the physics itself, which is not a thing our own vacuum is supposed to have. Every particle we're about to meet is defined relative to this moving background, not to the grid it's drawn on.

The zoo

To find what can live on top of the ether, we hunted for it: take a settled stretch of ether, poke a small hole in it — overwrite a window up to 12 cells wide with every possible pattern — and watch what happens. Overwhelmingly, the disturbance heals: the ether swallows it and nothing survives. Sometimes it doesn't heal — it spreads, unbounded, and the patch never settles down. But for a narrow set of pokes, something else happens: the disturbance settles into a small, self-contained pattern that repeats itself forever while drifting across the ether at a fixed, rational speed. Those survivors are the particles.

Five species turned up in our search, labeled α through ε below. Each card states two numbers this way: a velocity, and a recurrence — the number of steps before the particle's local pattern re-aligns with the ether tiling. Recurrence is a multiple of the particle's true underlying period, not the period itself, because we measure it tile-by-tile, in the ether's own units.

A word on completeness, because it matters: Matthew Cook's proof that Rule 110 is computationally universal works with a considerably richer taxonomy of gliders — named A through H and beyond, with sub-variants for each. What follows is only the subset our own search happened to surface within a 12-cell perturbation. It's not the whole zoo, and we're not claiming it is. What we can promise is narrower and, we think, more useful: every number on every card below was measured directly by the engine running in your browser, not copied from a table.

The collider

A vacuum with several particle species drifting through it at different, fixed velocities has an obvious consequence: sooner or later, a faster particle catches a slower one, or two particles moving toward each other meet. Nobody scripts what happens next — there's no collision-handling code anywhere in this system, only the same three-neighbor rule applied cell by cell straight through the meeting point. Whatever emerges, emerges because the rule says so: the particles might annihilate into ether, glance off each other with new velocities, or leave behind a different species entirely.

Pick a left particle, a right particle, and a starting gap, and watch it happen.

From collisions to computation

A vacuum, a finite set of particle species, and a rulebook for what happens when they meet — that's already the raw material for computation. This is exactly the alphabet Cook's proof puts to work: strings of gliders, timed to collide in a chosen sequence, can be made to carry and process information, and Cotler, Hongler, and Hudcová's Theorem 2.4 builds on that same mechanism in the paper this essay follows. Turning "particles that collide predictably" into "particles that compute" takes one more ingredient — a way to read a program as an arrangement of gliders in the first place.

3 · The Machine in the String

Chapter 2 left us with an alphabet: a vacuum, a handful of particle species, and a rulebook for what happens when they meet — gliders that collide predictably, obeying nothing but Rule 110 applied cell by cell. That's already the raw material for computation, but it isn't a computer yet. A computer needs a way to write a program INTO the string, as an arrangement of gliders, and a way to read an answer back OUT of it. This chapter is about that translation — and about a harder question hiding inside it: when the string computes, who, exactly, is doing the work?

A computer with no moving parts

Start from the simplest thing that can be programmed at all. A cyclic tag system has no tape, no read head, no table of internal states — just a word of 0s and 1s, and a short, fixed list of productions repeated forever in a cycle. At each step: look at the word's leftmost symbol and delete it. If that symbol was a 1, append the next production in the cycle to the word's right end; if it was a 0, append nothing. Advance to the next production in the cycle. Repeat.

It doesn't look like it should be able to do much. Yet a construction due to Matthew Cook shows that cyclic tag systems can simulate Turing machines, which makes them computationally universal in their own right. Below is a small example of the machine class Cook proved universal: three productions — 011, 10, 101 — cycling forever, fed by a one-symbol word, 1. Watch the word grow, shrink, and sometimes vanish entirely — step through it by hand, or let it run. (The display caps the word at 4096 cells and halts with "overflow" past that point, purely so your browser survives an unbounded run — the underlying system has no such limit.)

Notice that the word doesn't just grow — it can also shrink all the way to nothing and halt, or run on with no end in sight. That's not a bug in this particular example; it's a shadow of the halting problem, the same one that hangs over Turing machines. Any system rich enough to be universal inherits it. There's no shortcut that tells you in advance which the tag system above will do — you have to run it and watch.

The chain

Universal machines don't usually simulate each other in one leap. Cook's proof — and the argument Cotler, Hongler, and Hudcová build on it in the paper this essay follows — walks universality down a chain of intermediate machines, each one simulating the last, until it lands on Rule 110 itself. Click through the stages below to see what stands between a reference Turing machine and the string.

Every arrow in that chain costs something. Moving from one machine to the next requires an encoder that translates the upstream machine's configuration into the downstream machine's alphabet, and a decoder that translates the answer back. Skip past that cost, and "universal" starts to mean less than it sounds like it means.

The encoder's cost, counted (Theorem 2.4)

Theorem 2.4 answers a question earlier treatments of Rule 110's universality mostly waved past: who pays for the translation? Previous universality claims for Rule 110 never fully accounted for the encoder and decoder's own computational cost — the translation in and out was treated as free. Theorem 2.4 closes that gap: it re-establishes Rule 110's local universality with the accounting included, exhibiting an encoder-decoder pair that costs only polynomial time and linear space, so the original claim survives. The accounting matters because of a cautionary tale: with an extravagant enough decoder, you could "read" a computation into almost anything — a rock, a coin flip sequence, static — because the decoder, not the substrate, would be doing all the work. That failure mode has a name: computational misattribution. Theorem 2.4 is built to rule it out.

What runs exactly here, and what does not

The tag system above ran exactly, symbol for symbol, in your browser. What it does not do is compile into a literal Rule 110 initial condition — an actual strip of cells that, evolved under the same three-neighbor rule from Chapter 1, produces gliders carrying out those exact productions. Cook's construction does exactly that: it assembles armies of gliders like the ones in Chapter 2's zoo into a static "table" structure, timed so their collisions enact each production in turn. Performing that compilation for real is left as this project's hardest stretch goal. Below, Rule 110 again, running from random noise — the same kind of gliders that a completed construction would press into service as the machine's moving parts.

Results, and the question they leave open

Rule 110 can run any program a Turing machine can, and the paper's contribution is showing that claim survives paying for its own translation. Chapter 1 asked whether this string could compute; the answer is yes. But von Neumann's original question was more demanding than that. He wanted machines that don't just compute — machines that build, including copies of themselves.

4 · Von Neumann, Flattened

Chapter 3 left the string as a working computer: something that can run any program a Turing machine can, with the cost of translating in and out paid in full rather than hidden. But computation was never von Neumann's original question. Back in the 1940s, he asked something stranger and harder: not whether a machine could compute an answer, but whether a machine could build — construct another machine out of raw parts, including, in the limit, a working copy of itself. A calculator answers questions. Von Neumann wanted something closer to biology: a device that manufactures its own offspring, forever. He designed a candidate: spread across a two-dimensional cellular automaton with 29 states per cell — rich enough for a constructing arm to read a blueprint, assemble a duplicate machine beside itself, copy the blueprint into it, and set it running. On paper, it worked. It also needed the whole plane to work in. This chapter asks whether that requirement was ever load-bearing.

The animation below is a schematic of that construction — machine block, description tape, and a building arm, drawn at the scale of the idea rather than the 29-state rule table: the arm marks out the child machine's body cell by cell, then reaches diagonally up and to the side to copy the blueprint tape into it and set it running.

The flattening

Theorem 2.5, with its construction sketched in Appendix E, states that universal self-replicators exist in one dimension. Von Neumann's constructing arm, by contrast, builds outward on a diagonal: reach up and to the side, lay down the child machine's body one cell at a time, then hand it the blueprint — and nothing about that argument obviously survives losing a dimension, since a diagonal reach needs somewhere to reach to, and a line has no "aside."

The move is to stop insisting the arm build diagonally at all, and instead have it build at a horizontal offset — laying the child down beside the parent along the same axis, not off at an angle. Once construction only ever moves sideways, everything the machine needs — body, arm, blueprint, child — fits inside a strip of bounded height, no matter how far the process runs.

The same schematic — the same read-assemble-copy-activate cycle, drawn at the scale of the idea rather than any published rule table — run with only a horizontal offset:

And a bounded strip is exactly the kind of object a one-dimensional automaton can encode directly: take a vertical slice through the strip and let it stand for a single symbol. Do that all the way along, and the whole two-dimensional construction collapses into one row of a 1D cellular automaton, evolving under a state space larger than von Neumann's original 29 — large enough for each symbol to carry everything that used to live in the strip's height. Nothing about the construction is removed in the flattening. It's folded.

The replication cycle, step by step

Flattened onto the string itself, the construction's logic is a cycle, run once per generation: read the parent's description tape, assemble a child machine cell by cell next to it, copy the tape into the child, then activate the child so it can repeat the cycle on its own — and, unlike the single-generation builds above, keep proliferating generation after generation. Below is a schematic, generation-by-generation run of exactly that cycle. Watch the arm mark out the child's body first, then step across and write the tape's bits into place beside it, then fire the spark that turns the child on. The moment a child activates, it becomes a parent in its own right and starts budding a child of its own — which is precisely the condition Definition 2.6 asks a self-replicator to satisfy: not just one successful copy, but a pattern that keeps proliferating, arbitrarily many copies down the line, all under the same bounded dynamics every generation before it used.

What doesn't change generation to generation is the recipe: every child runs the identical read-assemble-copy-activate cycle on the identical tape, which is what makes this reproduction rather than a one-time act of construction.

This animation is schematic. Theorem 2.5 proves the one-dimensional replicator exists and Appendix E sketches its construction; the paper publishes no rule table, and this widget does not claim to be that automaton — it doesn't run cell by cell the way Chapter 1's Rule 110 diagrams genuinely do. The phases, the horizontal budding, the proliferating generations down the strip mirror the structure of the proof, not its mechanics. Treat it the way you'd treat a diagram of a cycle in a textbook: true to the shape of the argument, silent on the machinery inside each step.

From building to the limits of building

So a one-dimensional string — the same kind of object Chapter 1 asked to merely survive — can, in principle, host something that builds itself, generation after generation, without ever leaving the line. That's a real answer to von Neumann's question, flattened but intact.

It's tempting to stop there and assume the hard part is over: once a system is universal enough to compute anything, the folklore goes, self-replication should come along for free — just another program for a universal machine to run.

5 · Universality Is Not Life

For roughly eighty years — since von Neumann first drew a self-replicating machine on a two-dimensional grid — the field has leaned on an unexamined assumption: computation is the hard part, and self-replication comes along for free once you have enough of it. A system that can run any program should, the thinking goes, be able to run the specific program that builds a copy of itself. Universal enough to compute is universal enough to live. Chapter 4 might even seem to feed that instinct: dimensionality was no obstacle, so what could be? This chapter is where the paper says no to the stronger version, and proves it with a machine that is fully universal and permanently unable to reproduce.

The construction

Put two ordinary computers on the same one-dimensional string, each parked on its own patch of tape and left alone to run. That's it — no coordination protocol, no shared memory, no scheduler deciding whose turn it is. Both just execute, forever, on whatever they find under their own head. The paper's §2.3 adds exactly one rule on top of that setup: every time a head steps off a cell, it marks that cell with the direction it left in — a little arrow pointing the way it went. And if a head is ever about to move onto a cell carrying a mark left by another head, it halts, right there, permanently. A head can walk back and forth across its own marks all day. It cannot survive stepping into someone else's.

Below, two of these heads run as simple binary counters, ticking upward one bit at a time, seeded close enough together on a 96-cell string that their territories are on a collision course. Watch what happens when the territories finally meet.

Nothing exotic is happening inside either head — no plan, no negotiation, no awareness that the other head even exists. Each is just counting. The halt, when it comes, isn't a decision either head makes; it's the marking rule doing its only job. Two heads can run side by side for as long as their patches of tape stay apart; the instant one would grow flush against the other's territory, it freezes.

Universal, but sterile

Theorem 2.8 is what makes this a genuine counterexample rather than a curiosity: the paper proves that adding the marking rule doesn't cost either head its computational power — each one, running alone on its own patch of string, remains locally universal in exactly the sense Chapter 3 established for Rule 110. You could still compile any Turing machine you like down onto one of these heads and get every answer a Turing machine could give you. Marking and halting don't touch what a lone head can compute. They touch something else entirely: what it can build.

Self-replication is not a solitary act. A parent has to construct a child's body, verify the construction succeeded, and then activate the child — start it running as an independent process. That activation is a message: information passing from one machine to another. On this string, every inter-head message is fatal by construction — the instant the parent's activity reaches into the child's territory, or the child's into the parent's, one of them steps onto a foreign mark and halts before the handoff can complete. The rule doesn't distinguish a friendly handoff from a hostile one. Contact is contact.

That's the theorem's other half: this construction fails the paper's formal condition for local self-replication, even though it fully satisfies local universality. Computation and construction, which the eighty-year folklore treated as the same achievement, come apart here in a single, verifiable machine. The paper states the resulting picture as a strict hierarchy — globally universal machines are a proper subset of universal self-replicators, which are in turn a proper subset of locally universal machines. Being able to compute anything sits at the outside of that chain. Being able to build offspring is a genuinely narrower, harder thing to prove, and it is not implied by the outer layer no matter how much computational power that layer has.

What this simulation is: mechanism, exactly; universality, by the paper's theorem

The widget above is a faithful reconstruction of the paper's mechanism — directional marks left on departure, a hard halt on contact with a foreign mark, two heads computing with no channel between them — implemented as a direct head simulation rather than the paper's underlying cellular automaton rule table. The heads themselves run a simple binary counter, not a universal program; universality is a theorem the paper proves about this class of machine in general, not a claim this demo makes about the two counters on screen. And the headline property — that no information crosses between heads until one of them halts — isn't just asserted above. It runs as an executable test in this project's engine suite: each head's history is checked to be bit-identical to how it would have run entirely alone, right up to the tick it halts.

The engine also contains a strengthening the paper doesn't have: a head stops one cell early, at the moment its counter would grow flush against a neighbor's marked territory — call it the "claim guard." It exists to keep the two counters decodable, and it can only ever reduce communication between heads, never add any, so nothing above about the paper's marking-and-halting mechanism is weakened by its presence. But it does mean the halt path you actually see in the shipped demo is the claim guard firing, not the paper's literal walk-onto-a-foreign-mark rule — for two counters that only ever grow leftward, that literal rule never gets the chance to fire first.

Computation without a boundary crossing

What the string is doing when two heads run past each other is transcription and translation without reproduction — each head faithfully carries out its own program and never once passes a message the other could use to come alive on its behalf. That distinction is the paper's real subject. What separates a computer from a living thing was never raw cleverness, or how much a machine can be made to calculate. It's the ability to coordinate construction across a boundary — to build something new, hand it a spark, and let it go. A universal machine can do astonishing things alone. It takes a different, stricter kind of machine to make another one.

We've now asked whether a one-dimensional string can compute, and whether it can build a copy of itself, and seen exactly where those two questions split apart. One question is left, bigger than either: whether physics itself — particles, dynamics, the stage all of this has been running on — can boot out of a string in the first place.

6 · Booting Physics from a String

Two questions carried this book. Could a one-dimensional string compute? Chapter 3 answered that cleanly: yes, Rule 110 is a universal computer, gliders and all. Could it live — build a working copy of itself? Chapters 4 and 5 answered that more carefully: it depends. A self-replicator can run on a string, but computing alone doesn't buy it; the paper's own two-headed construction is fully universal and permanently sterile. One clean yes, one qualified maybe. A third question, bigger than either, has been waiting since the first cellular automaton in Chapter 1, and it's the one this last chapter finally asks: can physics itself — not arithmetic, not replication, but particles, mass, things moving through spacetime — boot out of a string?

A quantum walk

Everything so far ran on a classical string: one bit per site, advanced by a fixed lookup-table rule. To get physics instead of arithmetic, swap the bit for something richer. Give each site two complex amplitudes — a left-moving component and a right-moving component — and replace the lookup table with one fixed unitary operation applied identically everywhere, every step: a "coin flip" that mixes the two components by a fixed angle θ, followed by a shift that sends the left component one site left and the right component one site right. No branching, no per-site lookup — one 2×2 unitary matrix and a shift, applied the same way at every site, forever. This is a discrete-time quantum walk. Everything in this section is something we built in this project's own engine, not borrowed from a paper — and every quantitative claim in it is tested.

That's a worldsheet again, the same idea as Chapter 1's space-time diagrams — but now each pixel's hue carries the local quantum phase and its brightness carries probability, so interference between amplitudes shows up directly as bands of color. Drag the mass slider and the geometry changes. At θ = 0° the coin does nothing at all — the two components decouple, and each races outward at exactly one site per step, the fastest this lattice permits — a hard-edged light cone with nothing beyond it. Turn θ up and the coin starts genuinely mixing the components: the packet can't outrun the cone drawn at θ = 0, but inside it now spreads more slowly and visibly jitters, more so the higher the angle. Whatever θ is set to, the walk conserves total probability across every step to machine precision — a unitary rule, doing exactly what unitary means.

A particle falls out

The coin angle isn't just evocative of mass — it is mass, and this is where the walk stops being a pretty animation and becomes an exact result. For a plane wave of momentum k, one step of the walk obeys a strict recurrence provable directly from the coin-and-shift rule, and its solutions satisfy

cos ω = cos θ · cos k

exactly — not an approximation, not a fit to data. This project's engine checks it directly: build a plane-wave state, step it twice, compare against the closed form, and the two agree to ten decimal places in this project's test suite.

Now take the small-momentum, small-mass limit of that same exact formula — small k, small θ — and something else falls out of it:

ω² = k² + θ²

Restore units and that's Einstein's E² = p² + m², with the coin angle standing in for the mass term. That's not a loose metaphor: it's the same limit behind an established correspondence in the literature between walks of exactly this kind and the 1+1-dimensional Dirac equation — worked out by David Meyer for quantum lattice gases, and independently by Iwo Bialynicki-Birula for lattice formulations of the Weyl and Dirac equations, with a lineage tracing back to Feynman's checkerboard model of the electron. The jitter in the widget at nonzero θ isn't a rendering artifact; it echoes Zitterbewegung, the trembling motion the Dirac equation predicts for a relativistic particle — a known, long-studied feature of relativistic quantum mechanics, not something new observed here.

Strings made of bits

None of this makes the walk above a string in the sense of string theory, and it's worth saying plainly: nothing here simulates strings, and nothing in this chapter is a claim about string theory's mathematics. But building real particle physics out of something discrete and stringlike is not this project's invention. It's an active, decades-old thread in the literature, and two research programs deserve to be named here — described, not endorsed.

Charles Thorn's string-bit models propose rebuilding string theory out of discrete, pointlike constituents strung together along the string's length, with the familiar continuous string recovered only in a limit of many bits — a program aimed at a more constructive, lattice-like foundation, not a claim shown to reproduce the full theory.

Gerard 't Hooft has separately proposed a cellular-automaton interpretation of quantum mechanics: that quantum behavior might emerge from an underlying deterministic, discrete substrate, with quantum randomness arising from information we can't directly access about that substrate's state. Like Thorn's program, this is a research direction under active debate. This chapter takes no position on whether either succeeds.

The open string

Pull the threads together, and here's where this project actually stands — plainly labeled as speculation from here on. A classical string, three bits at a time, computed anything a Turing machine could (Chapters 1–3). Suitably built, a string of that kind can also replicate itself, machine building machine (Chapter 4) — though computing alone doesn't guarantee it: a fully universal string can still be sterile (Chapter 5). Now a quantum string, one unitary rule wide, produces something that behaves like a particle with mass, tunable from a dial, obeying the same energy-momentum relation that governs the real universe at low speed. Three real results, three different strings, three distinct levels of confidence.

The paper we've followed the whole way through has an open question of its own. The paper's own Conjecture 3.1 leaves open whether Rule 110 — the computing string this book started with, back in Chapter 1 — supports universal self-replication. Nobody has proven it. Nobody has ruled it out.

So here is the question this project was built toward, and it belongs to us, not the paper: if a particle with mass can boot out of a quantum string, and a self-replicator can live out its existence on a classical one, is there a string — one string, one rule — whose physics boots both, computation and something alive to run it? We don't know. Nobody does. That open question is where this project ends.

That's Rule 110 again — the same rule, the same random soup this book opened with in Chapter 1 — gliders still condensing out of noise, six chapters later, no closer to being alive, quietly still computing. For the full accounting of what in this project is measured, what is a faithful reconstruction, what is schematic, and what is speculation like the question just above, see the About page. And if you'd rather drive any of it yourself — any of the 256 elementary rules, the collider, the tag system, or the quantum walk's own mass dial — it's all waiting in the Lab.

7 · Changing the shape of space

Chapter 6's worldsheet, like every worldsheet in this book before it, was drawn as a flat strip — wide enough that its periodic wrap never mattered on screen, so the walk looked, and behaved, like a walk on an infinite line. That's one choice of space, not the only one. This section shrinks the circumference so the gluing becomes the visible point, and otherwise keeps the walk's rule exactly as it was — same coin, same shift, same unitary step.

The cylinder

The simplest change: glue the string's two ends together. A periodic boundary means site zero and the last site are neighbors, so the walk's two wavefronts, moving out in opposite directions, eventually wrap around and run back into themselves. On an infinite line they'd separate forever; on a cylinder they re-interfere, producing recurrences a flat infinite line never shows. The circumference slider sets the cylinder's girth directly — a smaller circumference brings the wraparound sooner. Nothing about the underlying dynamics changed to produce this: it's the same tested engine from Chapter 6, with the circumference dialed down until the wrap it always had becomes visible, and its unitarity is tested to machine precision the same way Chapter 6's was. The wraparound re-interference itself is something to watch happen on screen, not a number this project's test suite checks.

The sphere, two ways

A sphere admits two different pictures of this same walk. The first — Circle — takes the periodic walk above and renders it directly on a great circle drawn on a sphere of adjustable size; the sphere's radius sets how sharply that circle curves, nothing more.

The second — Riemann — does something different in kind. Stereographic projection takes the walk's infinite line and folds it onto a circle with exactly one extra point standing in for infinity, the point the line's two ends both approach. State this plainly: that fold is a change of coordinates, not a change of dynamics. The walk underneath is the same non-wrapping walk on a line; only the picture drawn of it has moved from a line to a circle. The folded line this produces is, formally, the real projective line ℝP¹ — a circle — and it sits inside the Riemann sphere, the complex projective line ℂP¹, as its real points: the equator of the sphere the widget draws.

Higher-dimensional relatives of this compactification — complex projective spaces ℂPⁿ — are the home ground of some of the deepest open problems in mathematics, the Hodge conjecture among them; nothing in this walk touches those problems, but this is the door they live behind.

That's the limit of what a single folded line reaches: one real dimension, glued into ℝP¹, landing only on the sphere's equator. A two-dimensional field reaches further — Lenia's field is a discretized complex plane, and folding a complex plane the same way lands on the whole of ℂP¹, not just its equator.

A genuinely two-dimensional walk

The cylinder and the sphere above are still, underneath, walks on a line — one glued into a loop, one reprojected onto a circle. A torus is where the walk actually becomes two-dimensional: a Grover coin mixes four neighbors instead of two, and the walk's grid wraps on both axes at once, top edge to bottom, left edge to right. The torus is the compact orientable surface that admits an arbitrarily fine uniform lattice — refine the mesh as much as you like and every vertex still looks like every other — so the 1D walk's machinery generalizes to it cleanly, and the widget above is that generalization: total probability is conserved across every step, to the same precision the 1D walk's unitarity was tested to in Chapter 6.

That cleanliness is specific to the torus, and it's worth saying why the sphere above carries a 1D walk on a great circle rather than a 2D walk across its surface. A sphere's surface admits no arbitrarily fine uniform lattice: Euler's formula forces the vertex degrees of any triangulation of a sphere to satisfy Σ(6 − deg v) = 12, so refining an icosahedral mesh — the most uniform starting point, all 12 vertices 5-fold — always leaves twelve exceptional five-neighbor vertices, at every resolution, no matter how fine the mesh gets. That's a fact of the sphere's topology, not a limitation of this engine. A hypersphere, S³, compounds the same obstruction in three dimensions. Building a defensible walk on either — one whose coin rule and neighbor structure don't quietly break unitarity or bake in a preferred direction — is a research question, not a rendering choice, and it's why this project doesn't ship one.

Same rule, three shapes of space: a line glued into a loop, a line reprojected onto a circle, and a grid glued into a torus. The dynamics never changed. Only the arena did.

Every widget in this section runs live in the Lab, and the About page carries the same fidelity accounting the rest of this book uses: what's measured, what's a change of coordinates, and what's a plainly stated obstruction rather than something built.