## 0013100132 |
## 0123000001 |
## 1113202133 |
## 3002311232 |

## One-dimensional Cellular Automata |

Cellular automata are not fractals. Some cellular automata generate fractals. The four pictures above are depictions of time histories of one dimensional cellular automata.

A cellular automata has four parts:

- A collection of cells. The cellular automata used to generate the examples above have cells arranges as a one-dimensional array from left to right.
- A set of states for the cells, e.g. the colors in the above examples.
- A specification, for each cell, of a set of cells that form the
*nieghborhood*of the cell. - A rule for finding the next state of each cell that is based only on the current state of the cells in its neighborhood.

Let's go through the proccess used to generate a time history of a one-dimensional cellular automata.

Time | Cells | ||||||||

0 | ## 0 |
## 0 |
## 0 |
## 0 |
## 1 |
## 0 |
## 0 |
## 0 |
## 0 |

1 | ## 0 |
## 0 |
## 0 |
## 1 |
## 1 |
## 1 |
## 0 |
## 0 |
## 0 |

2 | ## 0 |
## 0 |
## 1 |
## 0 |
## 0 |
## 0 |
## 1 |
## 0 |
## 0 |

3 | ## 0 |
## 1 |
## 1 |
## 1 |
## 0 |
## 1 |
## 1 |
## 1 |
## 0 |

4 | ## 1 |
## 0 |
## 0 |
## 0 |
## 0 |
## 0 |
## 0 |
## 0 |
## 1 |

5 | ## 0 |
## 1 |
## 0 |
## 0 |
## 0 |
## 0 |
## 0 |
## 1 |
## 0 |

6 | ## 1 |
## 1 |
## 1 |
## 0 |
## 0 |
## 0 |
## 1 |
## 1 |
## 1 |

7 | ## 0 |
## 0 |
## 0 |
## 1 |
## 0 |
## 1 |
## 0 |
## 0 |
## 0 |

This method of specifying a rule is cammed a *sum* automata.
If we have 5 cell states we would need to specify an array of 13
numbers, for the possible sums 0+0+0 to 4+4+4 (0-12) with the numbers
in the range 0-4 (the five states).

The numerical rule could be summarized "be blue if there is one blue cell in your neighborhood, otherwise be white." If we run the example above for a longer time we can see it generates another version of the Sierpinski triangle, at least until it hits itself because of the cell space wrap-around. This shows that some cellular automata do generate fractals.

An important point is that the next value for each cell is computed
simultaneously and they are all updated together. It is also possible
to update cellular automata in other ways, e.g. pick a cell at random
and update only it. These two types of updating are call
*synchronous* and *asynchronous* updating. The examples in
this article were all generated with synchronous updating.

The sum automata rule is simple and convenient, but there are actually an enormous number of number of different ways to specify automata rules. Sum automata are symmetric (they don't care about the order of the cells in their neighborhood at all) and so are easier to get symmetric pictures from.