Digital Life 00: What Would Digital Life Mean?

Suppose we wanted to build life in software.

Not simulate a bird.

Not animate a creature.

Not create an AI assistant and give it a name.

Something more fundamental.

A computational system that begins to exhibit properties we associate with living things:

structure
persistence
response
adaptation
repair
memory
inheritance
evolution

The obvious temptation is to start implementing those words.

We could create:

class Metabolism:
    ...

class Memory:
    ...

class Reproduction:
    ...

class Apoptosis:
    ...

and very quickly end up with software that looks biologically inspired.

But that would prove almost nothing.

Calling a function reproduce() does not mean reproduction is doing anything useful.

Calling a variable energy does not make the system metabolic.

Saving a checkpoint does not automatically give a system memory in any interesting sense.

And preserving a configuration from one run to the next does not demonstrate evolution.

That is the problem this book is going to take seriously.

The cargo cult of life

A cargo cult copies the visible form of a system without reproducing the mechanism that made the original system work.

Digital life has an obvious version of this problem.

We can copy the vocabulary of biology:

cell
organism
energy
fitness
birth
death
memory
inheritance
evolution

and build software structures with those names.

The software may even be impressive.

But the names themselves tell us nothing.

So this book begins with a rule:

We do not get to claim a life-like property merely because we implemented something with the same name.

We have to earn the property experimentally.

If we claim persistence, we must measure persistence.

If we claim regeneration, we must damage the system and measure recovery.

If we claim learning, performance must improve.

If we claim inheritance, a successor must gain something useful from its predecessor.

If we claim evolution, variation and selection must produce measurable improvement across generations.

The goal is not to make the software sound alive.

The goal is to discover how far the evidence actually takes us.

Start with almost nothing

To investigate that question, we need a substrate simple enough that we can see what is happening.

Cellular automata are almost perfect.

A basic cellular automaton contains only:

state
+
local interaction
+
time

Imagine a row of cells.

Each cell might contain only:

0
or
1

At every step, each cell looks at a small neighborhood and applies the same rule.

For example:

left  centre  right
  1      0      1

        ↓

       next state

Every cell performs the same operation.

There is no central controller.

There is no model of the whole world.

There is no global plan.

There is just a local rule repeated everywhere.

And yet those tiny mechanisms can create remarkably complicated global behavior.

That is why we begin here.

Complexity does not have to be stored explicitly

One of the most important ideas in this book is that the complexity we observe does not necessarily exist in any individual component.

Consider a system with:

201 cells

2 possible states per cell

1 tiny local transition rule

No cell knows the shape of the global pattern.

No cell stores a blueprint of the future.

No cell knows where the interesting structures are.

Each cell sees only a tiny part of the world.

Yet after repeated updates we can obtain:

triangles
waves
moving structures
persistent motifs
collisions
irregular regions

The global structure emerges from repeated local interaction.

That immediately gives us our first question:

How much organization can arise without the organization being explicitly designed into the individual parts?

That question will follow us through the entire book.

But surprise is cheap

There is a danger here.

A complicated-looking cellular automaton can be mesmerizing.

We can run a rule, generate a beautiful spacetime diagram and think:

Something profound is happening.

Maybe.

Maybe not.

Random noise can look complicated.

A short-lived transient can look astonishing just before disappearing.

A periodic system can look chaotic if we observe only a small window.

A pattern can resemble an organism without possessing any property beyond its appearance.

So visual surprise is not enough.

We need another rule:

Look first. Then measure.

Our workflow will repeatedly become:

observe
    ↓
measure
    ↓
compare
    ↓
perturb
    ↓
form a hypothesis
    ↓
run another experiment

The visual pattern gives us a question.

The experiment tells us what we can actually claim.

What would count as progress?

We are not going to begin by deciding whether a system is alive.

That question is too large and too ambiguous.

Instead, we will investigate specific properties.

A rough ladder might look like this:

state exists
    ↓
state changes
    ↓
structure emerges
    ↓
structure persists
    ↓
information propagates
    ↓
structure responds to its environment
    ↓
structure survives disturbance
    ↓
structure repairs itself
    ↓
local rules accomplish global tasks
    ↓
local rules can be learned
    ↓
learned behaviour generalizes
    ↓
useful information survives one execution
    ↓
successors inherit useful information
    ↓
variation changes future performance
    ↓
selection improves later generations
    ↓
progress accumulates across a lineage

This is not a definition of life.

It is an experimental program.

Every step gives us something concrete to test.

Persistence is not enough

A program can persist indefinitely by doing nothing.

while True:
    pass

It is persistent.

It is not interesting.

Likewise, a cellular automaton can fall into a stable pattern and remain there forever.

Persistence alone therefore tells us very little.

What we care about is something stronger.

Can a system:

maintain useful structure

respond to change

spend resources productively

recover from damage

improve its behavior

preserve useful progress

Eventually we will ask an even harder question:

Can one computational system leave something behind that allows its successor to start from a better position?

That is very different from merely keeping one process alive forever.

A simple example of inherited progress

Imagine a difficult search task.

Generation 0 begins knowing nothing.

It explores:

A
B
C
D

and discovers that:

B is promising
D is useless
C fails under condition X

Then it terminates.

Generation 1 starts.

If it starts from scratch, the previous work is gone.

But suppose Generation 0 leaves behind a useful artifact:

what was tried
what failed
what worked
how far the search progressed

Generation 1 begins from there.

It explores:

B1
B2
B3

and makes further progress.

Then it leaves a better artifact for Generation 2.

Conceptually:

generation 0
     ↓
progress
     ↓
legacy

generation 1
     ↓
inherits legacy
     ↓
progresses further
     ↓
better legacy

generation 2
     ↓
...

Now we have something much more interesting than persistence.

We have the possibility of cumulative improvement across lifetimes.

We will eventually try to build and measure exactly that.

But not yet.

First we need the foundations.

Why begin with cellular automata?

Because cellular automata remove excuses.

If something interesting happens, we cannot easily hide the explanation inside a giant neural network or a complex software stack.

We know the ingredients.

For an elementary cellular automaton:

one-dimensional grid
binary state
radius-1 neighborhood
one deterministic rule
synchronous update

That is nearly the entire system.

We can inspect every rule.

We can replay every state.

We can change one bit.

We can measure exactly what happens next.

That makes cellular automata ideal for learning how to investigate emergence without immediately confusing complexity with mystery.

The first experiment

We will begin with one of the smallest possible worlds.

A line of cells:

00000000001000000000

One active cell sits in the center.

At every step, each cell looks at:

left
centre
right

and calculates its next state.

The transition is applied everywhere at once.

Conceptually:

current generation
        ↓
local neighborhoods
        ↓
same rule everywhere
        ↓
next generation

Repeat that process and stack the generations vertically:

generation 0
generation 1
generation 2
generation 3
...

The resulting image is called a spacetime diagram.

The horizontal axis is space.

The vertical axis is time.

And something remarkable happens.

Very small rules can generate patterns that are not obvious from the rule itself.

What we will not do

Throughout this book, we will resist several shortcuts.

We will not say:

This pattern looks organic, therefore it is alive.

We will not say:

This system maintains a value, therefore it has homeostasis.

We will not say:

This model was optimized, therefore it evolved.

We will not say:

This state was copied to another process, therefore information was inherited meaningfully.

Instead we will continually ask:

Compared with what?

Measured how?

Under which conditions?

Does the effect survive perturbation?

Does it generalize?

What happens if we remove the proposed mechanism?

Those questions matter more than the terminology.

The experiment grows with the book

We will begin with tiny deterministic automata.

Then progressively add capabilities.

local binary rules
      ↓
persistent structures
      ↓
measurement
      ↓
information processing
      ↓
search
      ↓
continuous state
      ↓
artificial-life systems
      ↓
damage and regeneration
      ↓
learned local rules
      ↓
memory
      ↓
adaptation
      ↓
inheritance
      ↓
lineages
      ↓
cumulative improvement

Each new mechanism must earn its place.

We should always be able to answer:

What can the system do now that it could not do before?

The real question

At the end of this book, we may still refuse to say that anything we built is alive.

That is acceptable.

The more useful outcome is to be able to say precisely:

this system persists

this system transports information

this system restores structure after damage

this system learns a local rule

this system generalizes beyond training conditions

this system transfers useful state to a successor

this lineage improves across generations

Those are testable statements.

They give us somewhere solid to stand.

And once enough of those properties accumulate, the interesting question changes.

It is no longer:

Does this look alive?

It becomes:

What exactly is missing before the distinction becomes difficult to draw?

That is the experiment.

In the next chapter we will build the smallest mechanism in the book: a line of binary cells governed entirely by a local rule.

From almost nothing, we will see what begins to emerge.