Printed from the Complete Wolfram Language Documentation 1

TUTORIAL Related Tutorials Functions URL

Cellular Automata
Cellular automata provide a convenient way to represent many kinds of systems in which the values of cells in an array are updated in discrete
steps according to a local rule.

CellularAutomaton rnum,init,t evolve rule rnum from init for t steps

Generating a cellular automaton evolution.

This starts with the list given, then evolves rule 30 for four steps.

In[1]:= CellularAutomaton 30, 0, 0, 0, 1, 0, 0, 0 , 4

autómata celular

Out[1]= 0, 0, 0, 1, 0, 0, 0 , 0, 0, 1, 1, 1, 0, 0 , 0, 1, 1, 0, 0, 1, 0 , 1, 1, 0, 1, 1, 1, 1 , 0, 0, 0, 1, 0, 0, 0

This shows 100 steps of rule 30 evolution from random initial conditions.

In[2]:= ArrayPlot CellularAutomaton 30, RandomInteger 1, 250 , 100

representac autómata celular entero aleatorio

Out[2]=

a1 ,a2 , explicit list of values ai

a1 ,a2 , ,b values ai superimposed on a b background
a1 ,a2 , ,blist values ai superimposed on a background of repetitions
of blist
a11 ,a12 , , d1 , ,blist values aij at offsets di

Ways of specifying initial conditions for one-dimensional cellular automata.

If you give an explicit list of initial values, CellularAutomaton will take the elements in this list to correspond to all the cells in the system,
arranged cyclically.

The right neighbor of the cell at the end is the cell at the beginning.

In[3]:= CellularAutomaton 30, 1, 0, 0, 0, 0 , 1

autómata celular

Out[3]= 1, 0, 0, 0, 0 , 1, 1, 0, 0, 1

It is often convenient to set up initial conditions in which there is a small "seed" region, superimposed on a constant "background". By default,
CellularAutomaton automatically fills in enough background to cover the size of the pattern that can be produced in the number of steps of
evolution you specify.

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 2

This shows rule 30 evolving from an initial condition containing a single black cell.

In[4]:= ArrayPlot CellularAutomaton 30, 1 , 0 , 100

representac autómata celular

Out[4]=

This shows rule 30 evolving from an initial condition consisting of a 1, 1 seed on a background of repeated 1, 0, 1, 1 blocks.

In[5]:= ArrayPlot CellularAutomaton 30, 1, 1 , 1, 0, 1, 1 , 100

representac autómata celular

Out[5]=

Particularly in studying interactions between structures, you may sometimes want to specify initial conditions for cellular automata in which
certain blocks are placed at particular offsets.

This sets up an initial condition with black cells at offsets 40 .

In[6]:= ArrayPlot CellularAutomaton 30, 1 , 40 , 1 , 40 , 0 , 100
representac autómata celular

Out[6]=

n k 2, r 1, elementary rule

n,k general nearest-neighbor rule with k colors

n,k,r general rule with k colors and range r
n, k,1 k-color nearest-neighbor totalistic rule
n, k,1 ,r k-color range r totalistic rule
n, k, wt1 ,wt2 , ,r rule in which neighbor i is assigned weight wti
n,kspec, off1 , off2 , , offs rule with neighbors at specified offsets
lhs1 rhs1 ,lhs2 rhs2 , explicit replacements for lists of neighbors
fun, ,rspec rule obtained by applying function fun to each neighbor
list

Specifying rules for one-dimensional cellular automata.

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 3

In the simplest cases, a cellular automaton allows k possible values or "colors" for each cell, and has rules that involve up to r neighbors on each
side. The digits of the "rule number" n then specify what the color of a new cell should be for each possible configuration of the neighborhood.

This evolves a single neighborhood for 1 step.

In[7]:= CellularAutomaton 30, 1, 1, 0 , 1

autómata celular

Out[7]= 1, 1, 0 , 1, 0, 0

Here are the 8 possible neighborhoods for a k 2, r 1 cellular automaton.

In[8]:= Tuples 1, 0 , 3
tuplas

Out[8]= 1, 1, 1 , 1, 1, 0 , 1, 0, 1 , 1, 0, 0 , 0, 1, 1 , 0, 1, 0 , 0, 0, 1 , 0, 0, 0

This shows the new color of the center cell for each of the 8 neighborhoods.

In[9]:= Map CellularAutomaton 30, , 1 2, 2 &,

apl autómata celular

Out[9]= 0, 0, 0, 1, 1, 1, 1, 0

For rule 30, this sequence corresponds to the base-2 digits of the number 30.

In[10]:= FromDigits ,2
de dígitos a número

Out[10]= 30

This runs the general k 3, r 1 rule with rule number 921408.

In[11]:= ArrayPlot CellularAutomaton 921 408, 3, 1 , 1 , 0 , 100
representac autómata celular

Out[11]=

For a general cellular automaton rule, each digit of the rule number specifies what color a different possible neighborhood of 2 r 1 cells should
yield. To find out which digit corresponds to which neighborhood, one effectively treats the cells in a neighborhood as digits in a number. For an
r 1 cellular automaton, the number is obtained from the list of elements neig in the neighborhood by neig. k ^ 2, k, 1 .

It is sometimes convenient to consider totalistic cellular automata, in which the new value of a cell depends only on the total of the values in its
neighborhood. One can specify totalistic cellular automata by rule numbers or "codes" in which each digit refers to neighborhoods with a given
total value, obtained for example from neig. 1, 1, 1 .

In general, CellularAutomaton allows one to specify rules using any sequence of weights. Another choice sometimes convenient is k, 1, k ,
which yields outer totalistic rules.

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 4

This runs the k 3, r 1 totalistic rule with code number 867.

In[12]:= ArrayPlot CellularAutomaton 867, 3, 1 , 1 , 1 , 0 , 100
representac autómata celular

Out[12]=

Rules with range r involve all cells with offsets r through r. Sometimes it is convenient to think about rules that involve only cells with specific
offsets. You can do this by replacing a single r with a list of offsets.

Any k 2 cellular automaton rule can be thought of as corresponding to a Boolean function. In the simplest case, basic Boolean functions like
And or Nor take two arguments. These are conveniently specified in a cellular automaton rule as being at offsets 0 , 1 . Note that for
compatibility with handling higher-dimensional cellular automata, offsets must always be given in lists, even for one-dimensional cellular
automata.

This generates the truth table for 2-cell-neighborhood rule number 7, which turns out to be the Boolean function Nand.

In[13]:= Map CellularAutomaton 7, 2, 0 , 1 , ,1 2, 2 &, 1, 1 , 1, 0 , 0, 1 , 0, 0

apl autómata celular

Out[13]= 0, 1, 1, 1

Rule numbers provide a highly compact way to specify cellular automaton rules. But sometimes it is more convenient to specify rules by giving
an explicit function that should be applied to each possible neighborhood.

This runs an additive cellular automaton whose rule adds all values in each neighborhood modulo 4.

In[14]:= ArrayPlot CellularAutomaton Mod Apply Plus, , 4 &, ,1 , 1 , 0 , 100

representac autómata celular op aplica suma

Out[14]=

The function is given the step number as a second argument.

In[15]:= ArrayPlot CellularAutomaton Mod Total 2, 4 &, ,1 , 1 , 0 , 100

representac autómata celular op total

Out[15]=

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 5

When you specify rules by functions, the values of cells need not be integers.

In[16]:= ArrayPlot CellularAutomaton Mod 1 2 Apply Plus, , 1 &, ,1 , 1 , 0 , 100

representac autómata celular operació aplica suma

Out[16]=

They can even be symbolic.

In[17]:= Simplify CellularAutomaton Mod Apply Plus, , 2 &, ,1 , a ,0 ,2 ,a Integers

simplifica autómata celular op aplica suma números enteros

Out[17]= 0, 0, a, 0, 0 , 0, Mod a, 2 , Mod a, 2 , Mod a, 2 , 0 , Mod a, 2 , 0, Mod a, 2 , 0, Mod a, 2

CellularAutomaton rnum,init,t evolve for t steps, keeping all steps

CellularAutomaton rnum,init, t evolve for t steps, keeping only the last step
CellularAutomaton rnum,init, spect keep only steps specified by spect
CellularAutomaton rnum,init evolve rule for one step, giving only the last step

Selecting which steps to keep.

This runs rule 30 for 5 steps, keeping only the last step.

In[18]:= CellularAutomaton 30, 1 , 0 , 5

autómata celular

Out[18]= 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1

This keeps the last 2 steps.

In[19]:= CellularAutomaton 30, 1 ,0 , 4, 5

autómata celular

Out[19]= 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0 , 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1

This gives one step.

In[20]:= CellularAutomaton 30, 0, 0, 1, 0, 0

autómata celular

Out[20]= 0, 1, 1, 1, 0

The step specification spect works very much like taking elements from a list with Take . One difference, though, is that the initial condition for
the cellular automaton is considered to be step 0. Note that any step specification of the form must be enclosed in an additional list.

u steps 0 through u
u step u
u1 ,u2 steps u1 through u2
u1 ,u2 ,du steps u1 , u1 du,

Cellular automaton step specifications.

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 6

This evolves for 100 steps, but keeps only every other step.

In[21]:= ArrayPlot CellularAutomaton 30, 1 ,0 , 0, 100, 2

representac autómata celular

Out[21]=

CellularAutomaton rnum,init,t keep all steps, and all relevant cells

CellularAutomaton rnum,init, spect ,spec x

keep only specified steps and cells

Selecting steps and cells to keep.

Much as you can specify which steps to keep in a cellular automaton evolution, so also you can specify which cells to keep. If you give an initial
condition such as a1 , a2 , , blist , then rd is taken to have offset 0 for the purpose of specifying which cells to keep.

All all cells that can be affected by the specified initial

condition
Automatic all cells in the region that differs from the background
default
0 cell aligned with beginning of aspec
x cells at offsets up to x on the right
x cells at offsets up to x on the left
x cell at offset x to the right
x cell at offset x to the left
x1 ,x2 cells at offsets x1 through x2
x1 ,x2 ,dx cells x1 , x1 dx,

Cellular automaton cell specifications.

This keeps all steps, but drops cells at offsets more than 20 on the left.

In[22]:= ArrayPlot CellularAutomaton 30, 1 , 0 , 100, 20, 100

representac autómata celular

Out[22]=

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 7

This keeps just the center column of cells.

In[23]:= CellularAutomaton 30, 1 , 0 , 20, 0

autómata celular

Out[23]= 1 , 1 , 0 , 1 , 1 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 1 , 0 , 0 , 1 , 0

If you give an initial condition such as a1 , a2 , , blist , then CellularAutomaton will always effectively do the cellular automaton as if there

were an infinite number of cells. By using a specx such as x1 , x2 you can tell CellularAutomaton to include only cells at specific offsets x1

through x2 in its output. CellularAutomaton by default includes cells out just far enough that their values never simply stay the same as in the
background blist.

In general, given a cellular automaton rule with range r, cells out to distance rt on each side could in principle be affected in the evolution of the
system. With spec x being All , all these cells are included; with the default setting of Automatic , cells whose values effectively stay the same as in
blist are trimmed off.

By default, only the parts that are not constant black are kept.

In[24]:= ArrayPlot CellularAutomaton 225, 1 , 0 , 100

representac autómata celular

Out[24]=

Using All for specx includes all cells that could be affected by a cellular automaton with this range.

In[25]:= ArrayPlot CellularAutomaton 225, 1 , 0 , 100, All

representac autómata celular todo

Out[25]=

CellularAutomaton generalizes quite directly to any number of dimensions. Above two dimensions, however, totalistic and other special types of
rules tend to be more useful, since the number of entries in the rule table for a general rule rapidly becomes astronomical.

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 8

n,k, r1 ,r2 , ,rd d -dimensional rule with 2 r1 1 2 r2 1 2 rd 1

neighborhood
n, k,1 , 1,1 two-dimensional 9-neighbor totalistic rule
n, k, 0,1,0 , 1,1,1 , 0,1,0 , 1,1

two-dimensional 5-neighbor totalistic rule

n, k, 0,k,0 , k,1,k , 0,k,0 , 1,1

two-dimensional 5-neighbor outer totalistic rule

Higher-dimensional rule specifications.

This is the rule specification for the two-dimensional 9-neighbor totalistic cellular automaton with code 797.

In[26]:= code797 797, 2, 1 , 1, 1 ;

This gives steps 0 and 1 in its evolution.

In[27]:= CellularAutomaton code797, 1 ,0 ,1

autómata celular

Out[27]= 0, 0, 0 , 0, 1, 0 , 0, 0, 0 , 0, 0, 0 , 0, 0, 0 , 0, 0, 0

This shows step 70 in the evolution.

In[28]:= ArrayPlot First CellularAutomaton code797, 1 , 0 ,

representac primero autómata celular
70

Out[28]=

This shows all steps in a slice along the x axis.

In[29]:= ArrayPlot Map First,

representac apl primero
CellularAutomaton code797, 1 , 0 ,
autómata celular
70, 0 , All
todo

Out[29]=

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language

 Printed from the Complete Wolfram Language Documentation 9

Related Tutorials

Numerical Operations on Data

1988–2018 Wolfram Research, Inc. All rights reserved. http://reference.wolfram.com/language