Cellular Automata
Biologically Inspired Computing
Various credits for these slides, which have in part been adapted
from slides by: Ajit Narayanan, Rod Hunt, Marek Kopicki.
Cellular Automata
A CA is a spatial lattice of N cells, each of
which is one of k states at time t.
•Each cell follows the same simple rule for updating its state.
•The cell's state s at time t+1 depends on its own state and the
states of some number of neighbouring cells at t.
• For one-dimensional CAs, the neighbourhood of a cell
consists of the cell itself and r neighbours on either side.
Hence, k and r are the parameters of the CA.
•CAs are often described as discrete dynamical systems with
the capability to model various kinds of natural discrete or
continuous dynamical systems
SIMPLE EXAMPLE
Suppose we are interested in understanding how a forest fire
spreads. We can do this with a CA as follows.
Start by defining a 2D grid of `cells’, e.g.:
This will be a spatial representation of our forest.
SIMPLE EXAMPLE continued
Now we define a suitable set of states. In this case, it makes
sense for a cell to be either empty, ok_tree, or fire_tree –
meaning:
empty: no tree here
ok_tree: there is a tree here, and it’s healthy
fire_tree: there is a tree here, and it’s on fire.
When we visualise the CA, we will use colours to represent
the states. In these cases; white, green and red seem the right
Choices.
A fairly dense forest with a couple of trees
on fire -- maybe from lightning strikes
SIMPLE EXAMPLE continued
Next we define the neighbourhood structure – when we run
our CA, cells will change their state under the influence of their
neighbours, so we have to define what counts as a “neighbour”.
You’ll see example neighbourhoods in a later slide, but usually
you just use a cell’s 8 immediately surrounding neighbours.
Let’s do that in this case.
Next we decide what the neighbourhood will be like at the
boundaries of the grid.
CA Rules
Now, the main thing: how do we update the
states at the next time step? We use
sensible rules.
E.g.
• If a tree is not on fire, and has n neighbours on
fire, it catches fire next step with probabilty n/8.
• If a tree has been on fire for 3 steps, it dies
Step 0
Step 1
Step 2
Step 3
Step 4 … and so on
CA Rules:
• A small number of sensible rules, for any given suitable
application, usually leads to convincing behaviour.
• Every CA rule says:
A cell in state X changes to a cell of state Y if certain
neighbourhood conditions are satisfied
• What about the “tree on fire dies after three steps rule?”
This can be easily modelled with “pure” CA rules. How?
• CAs are increasingly used to simulate a wide number of
complex systems, to see “what would happen if…”, and
generally investigate the effects of various strategies
Modelling HIV infection
demo coming soon
4 states: Healthy, Infected1, Infected2, Dead
Rule 1 - If an H cell has at least one I1 neighbour, or if has at least 2 I2
neighbours, then it becomes I1. Otherwise, it stays healthy.
Rule 2 – An I1 cell becomes I2 after 4 time steps (simulated weeks). (to
operate this the CA maintains a counter associated with each I1 cell).
Rule 3 - An I2 cell becomes D.
prepl (1 
Rule 4 – A D cell becomes H, with probability
prepl pInfec ; otherwise, it remains D
with probability
pInfec
; I1,)
Some additional things about CAs
A simple 1D CA to illustrate these points:
States 0 and 1:
Wraparound 1D array of 30 cells
Rules: if both neighbours are 1, become 1;
if both neighbours are 0, become 0;
otherwise, stay the same.
Synchronous update: most CAs operate this way. Each cell’s new
state for time t+1 is worked out in parallel based on the situation at t.
Start:
101001010001101000101010010001
T=1 :
T=2 :
110000000001110000010100000001
110000000001110000001000000001
Some additional things about CAs
Asynchronous update:
Sometimes applied in preference – it is arguably a more valid way
to simulate some systems. Here, at each time step, one cell is
chosen at random and updated.
Start:
T=1 :
T=2 :
T=3 :
T=4 :
T=5 :
101001010001101000101010010001
101001000001101000101010010001
101001000001101000101010010001
111001000001101000101010010001
111001000001101000101010000001
etc ...
Clearly if there are n cells, then n timesteps in an asynchronous CA
corresponds to the 1 timestep of a synchronous CA.
Boundary conditions
Rules for a cell’s state transitions are usually defined in terms of
the cell’s neighbourhood. E.g. this is the Moore neighbourhood:
But what about cells on the edge?
The common approach in 2D is to
treat the CA surface as a Toroid
This just means wraparound in
the way indicated by the
blue and green neighbourhoods
illustrated
Types of neighbourhood
Many more
neighbourhood
techniques exist - see
http://cell-auto.com and
follow the link to
‘neighbourhood survey’
More about 1D 2-state CAs
Assuming Moore neighbourhood: there are 8
possible rules:
current
pattern
111
110
101
100
011
010
001
000
new
state
for
center
cell
0
0
0
1
1
1
1
0
This is “rule 30” – why?
Rule 30 produces patterns like this
Classes of cellular automata (Wolfram)
Class 1: after a finite number of time steps, the CA tends to
achieve a unique state from nearly all possible starting
conditions (limit points)
Class 2: the CA creates patterns that repeat periodically or are
stable (limit cycles) – probably equivalent to a regular
grammar/finite state automaton
Class 3: from nearly all starting conditions, the CA leads to
aperiodic-chaotic patterns, where the statistical properties of
these patterns are almost identical (after a sufficient period of
time) to the starting patterns (self-similar fractal curves) –
computes ‘irregular problems’
Class 4: after a finite number of steps, the CA usually dies, but
there are a few stable (periodic) patterns possible (e.g. Game of
Life) - Class 4 CA are believed to be capable of universal
computation
John Conway’s Game of Life
• 2D cellular automata system.
• Each cell has 8 neighbors - 4 adjacent
orthogonally, 4 adjacent diagonally. This is
called the Moore Neighborhood.
Simple rules, executed at each
time step:
– A live cell with 2 or 3 live neighbors survives
to the next round.
– A live cell with 4 or more neighbors dies of
overpopulation.
– A live cell with 1 or 0 neighbors dies of
isolation.
– An empty cell with exactly 3 neighbors
becomes a live cell in the next round.
Is it alive?
• http://www.bitstorm.org/gameoflife/
• Compare it to the definitions…
Glider
Langton’s Loops
• CA are a main part of the research area “Artificial
Life”. A common definition of “life” involves that the
living organism(s) must be capable of selfreproduction. Langton’s “Loops” achieve that.
• Characteristics
– 8 states, 2D Cellular automata
– Needed CA grid of 100 cells
– Self Reproduction into identical copy
• A simple set of rules produces self-reproducing
“organism” – a deep connection between Life and
Computation.
Langton’s Loop
0 – Background cell state
3, 5, 6 – Phases of reproduction
1 – Core cell state
4 – Turning arm left by 90 degrees
2 – Sheath cell state
state
7 – Arm extending forward cell state
Langton’s Loops
There remains debate and interest
about the `essentials of life’ issue
with CAs, but their main BIC
value is as modelling techniques.
We’ve seen HIV – here are some more examples.
Modelling Sharks and Fish:
Predator/Prey Relationships
Bill Madden, Nancy Ricca and Jonathan Rizzo
Graduate Students, Computer Science Department
Research Project using Department’s 20-CPU Cluster
• This project modeled a predator/prey relationship
• Begins with a randomly distributed population of
fish, sharks, and empty cells in a 1000x2000 cell
grid (2 million cells)
• Initially,
– 50% of the cells are occupied by fish
– 25% are occupied by sharks
– 25% are empty
Here’s the number 2 million
• Fish: red; sharks: yellow; empty: black
Rules
A dozen or so rules describe life in each cell:
• birth, longevity and death of a fish or shark
• breeding of fish and sharks
• over- and under-population
• fish/shark interaction
• Important: what happens in each cell is
determined only by rules that apply locally, yet
which often yield long-term large-scale patterns.
Do a LOT of computation!
•
•
•
•
•
Apply a dozen rules to each cell
Do this for 2 million cells in the grid
Do this for 20,000 generations
Well over a trillion calculations per run!
Do this as quickly as you can
Rules in detail: Initial Conditions
Initially cells contain fish, sharks or are empty
• Empty cells = 0 (black pixel)
• Fish = 1 (red pixel)
• Sharks = –1 (yellow pixel)
Breeding Rule: Before
EMPTY
Breeding Rule: After
Rules in Detail: Fish Rules
If the current cell contains a fish:
• Fish live for 10 generations
• If >=5 neighbors are sharks, fish dies (shark
food)
• If all 8 neighbors are fish, fish dies
(overpopulation)
• If a fish does not die, increment age
Rules in Detail: Shark Rules
If the current cell contains a shark:
• Sharks live for 20 generations
• If >=6 neighbors are sharks and fish
neighbors =0, the shark dies (starvation)
• A shark has a 1/32 (.031) chance of dying
due to random causes
• If a shark does not die, increment age
Results
• Next several screens show behavior over a
span of 10,000+ generations
Generation: 0
Spring 2005
BM
43
Generation: 100
Spring 2005
BM
44
Generation: 500
Generation: 1,000
Generation: 2,000
Generation: 4,000
Generation: 8,000
Generation: 10,500
Long-term trends
• Borders tended to ‘harden’ along vertical,
horizontal and diagonal lines
• Borders of empty cells form between like
species
• Clumps of fish tend to coalesce and form
convex shapes or ‘communities’
What can be discovered by
simulating very small populations
• Fish can live in stable isolated communities
as small as 20-30
• A community of less than 200 sharks tends
not to be viable
Forest Fire Model (FFM)
Forest Fire Model is a stochastic 3-state cellular automaton
defined on a d-dimensional lattice with Ld sites.
Each site is occupied by a tree, a burning tree, or is empty.
During each time step the system is updated according to
the rules:
1. empty site  tree with the growth rate probability p
2. tree  burning tree with the lightning rate probability f, if
no nearest neighbour is burning
3. tree  burning tree with the probability 1-g, if at least one
nearest neighbour is burning, where g defines immunity.
4. burning tree  empty site
The application
Eventually
After some time forest
reaches the steady state
in which the mean
number of growing trees
equals the mean number
of burning trees.
Modelling brain tumour growth
Kansal et al, 2000, Journal of Theoretical Biology
Incidence of primary malignant brain tumours is 8/100,000 p.a.
3D CA, modelling brain tumour growth
Shows that Macroscopic tumour behaviour can be predicted via
microscopic parameters
Uses only 4 parameters
Makes predictions that match the biological reality
MRI scan showing a
tumour; the white area
Represents blood leakage
around the tumour
Kansal et al use the Delaunay Tesselation as their lattice – on the right
we see blackened cells representing the tumour, in a simplified 2D version
States and Rules
Not easy to glean from the
paper, but: cells are either
healthy (empty lattice site)
or tumour.
Tumour cells are either
proliferative (they divide
into additional tumour
cells) or not. When a
proliferative tumour cell
wants to divide, it fills a
healthy space with a new
tumour cell if it can find
one within delta_p of its
position. If it can’t find
one, it becomes nonproliferative.
1.5M lattice sites
Initial tumour is 1000 proliferative cells at centre of lattice
Result seems realistic
Very good fit to real data;
The lines are the CA model predictions of tumour radius and
volume against time
The plotted points are measurements from real cases of untreated tumours
Read about various applications
for yourself.
See the www site for the:
Influenza CA paper
Tumour CA paper
A Traffic Simulation CA paper
Historic urban growth in the San Francisco bay area CA
Not examinable reading, but recommended
Next week
‘revision’ lecture
• I’ll go quickly over the examinable material from
my lectures (not Patricia’s)
• I’ll be here to answer (reasonable) questions about
the exam