Tutorials/Rules
Oh so you want to understand rules, or even make your own cellular automata? Here's the place to learn how!
Preliminaries
Some care needs to be taken to distinguish between rules, which are part of the specification of a cellular automaton (CA), the rules according to which patterns in that CA evolve; and rulestrings, which are string representations of rules in the previous sense.
There are several ways of specifying rules beyond rulestrings, such as rule integers or rule tables, and different rulestrings may yet represent the same rule. Nonetheless, in common parlance the term "rule" is often used where "rulestring" would be more appropriate.
Totalistic rules
Totalistic rules are defined in terms of birth and survival conditions: the circumstances under which dead cells get born, and live cells survive.
There's different ways of specifying these; two common ways to write rulestrings are called "B/S notation" and "S/B" notation respectively. Life itself is specified by "B3/S23" or "23/3", but since S/B notation has fallen out of style, we'll only be focussing on B/S notation for the rest of this tutorial.
So, let's look at Life's B3/S23. In Life:
- A dead cell gets born if and only if it has three live neighbors; this is expressed by "B3".
- A live cell survives if and only iff it has two or three live neighbors; this is expressed by "S23".
As you can see, birth and survival conditions are each encoded as a string of numbers following the respective letter ("B" for birth, "S" for survival). Since there are eight cells directly neighboring a given cell, all numbers from 0 to 8 can be specified, and each combination yields a different totalistic rule.
Let's look at two more examples. Day & Night has the rulestring B3678/S34678, so in this rule, dead cells get born if they have 3, 6, 7 or 8 live neighbors, and live cells survive if they have 3, 4, 6, 7 or 8 live neighbors. Live Free or Die has the rulestring B2/S0, so in this rule, dead cells are born if they have precisely two live neighbors, and live cells only survive if they have no live neighbors at all — if they are surrounded entirely by dead cells. (Knowing this, you can probably tell how the rule got its name.)
There are many ways to generalize such CAs. For instance, one could:
- Take into account the (relative or absolute) alignment of live neighbors, in addition to their total count; this leads to non-totalistic rules.
- Change the definition of what constitutes a "neighbor", e.g. using the von Neumann neighbourhood rather than the Moore neighbourhood, or increasing the distance at which cells are considered (Larger than Life rules).
- Increase the number of states a cell can be in, up from 2 ("dead" and "live").
- Change the topology of the universe: operate on e.g. a cylinder, torus or Klein bottle, rather than an infinite plane.
- Increase the dimension of the universe, considering 1-dimensional cellular automata (e.g. Wolfram's rule 30), 3-dimensional cellular automata, etc.
- Change the tiling of the universe: instead of square cells, use hexagonal cells, or even hyperbolic tilings, Penrose tilings.
- ...and much more.
Non-totalistic rules
Non-totalistic rules differ from totalistic rules in that not only the number of live neighbors of a cell is considered when deciding whether the cell should be born (or survive, if it is already live) — birth and survival also depend on the relative alignment of the cell's live neighbors.
Rulestrings for non-totalistic rules are typically given in Hensel notation. As an example, let's look at a hypothetical rule, B2ek/S12. We understand "S12" well enough – a live cell survives if it has one or two live neighbors –, but what does "B2ek" mean?
Imagine, if you will, a cell with two live neighbors. How can these two live neighbors be aligned, relative to each other? All the following configurations are possible:
| File:Neighborhood 2c.png | File:Neighborhood 2e.png | File:Neighborhood 2k.png | File:Neighborhood 2a.png | File:Neighborhood 2i.png | File:Neighborhood 2n.png |
| c | e | k | a | i | n |
(Some of these configurations have mnemonic names; "c" stands for "corner", "e" for "edge", "k" for "knightwise", "a" for adjacent, and so on. Others are less obvious and simply have to be remembered, or looked up as necessary.)
For a totalistic rule, say B2/S12, any of these configurations would cause the center cell to be born. By contrast, in non-totalistic rules, each configuration is considered separately: in B2e/S12 a dead cell gets born if and only if it has two live neighbors which are in "e" or "k" alignment (as shown above).
For some neighbor counts, particularly 4, there is a fairly large number of possible alignments, so it is sometimes convenient to negate rather than specify, essentially saying "...in all but these alignments". As an example, consider the first non-totalistic rule ever explored, Just Friends, which is described by the rulestring B2-a/S12. In this rule, a dead cell will get born if it has two live neighbors... unless those two live neighbors are in "a" alignment! Cells in this rule don't like getting cozy; they're "just friends".
Creating custom rules: the rule table
Maybe you want to create a rule entirely from scratch, e.g. for use in Golly. Golly has the ability to run a very large class of rules, described by a special syntax which you will now learn how to employ.
To create a new rule, you first need to know how to create RuleTables, which are the transitions that occur every generation, AKA Rules. For this tutorial, we are going to recreate Life, but with the name "Tutorial". To start, open your favorite text editor and type:
@RULE RuleName
where RuleName is the name of your rule; let's call this rule Tutorial, for tutorial purposes. Next, add the table, i.e. your actual transitions for the rule. Do this before getting to the actual transitions.
@TABLE n_states:2 neighborhood:Moore symmetries:permute
- @TABLE: This tells Golly that the table starts here.
- n_states: This is how many states your rule has, INCLUDING state 0, the dead state/background, so 2 states will have live and dead states and 1 state will only have the background.
- neighborhood: This is the neighborhood the rule uses, can be Moore, Hexagonal, vonNeumann, or oneDimensional, for the full list see the RoadMap
- symmetries: This is the arrangements accepted for each transition, none will make it so for example, if you want birth at 4 neighbors, you will have to write out every single arrangement of 4 neighbors. Permute makes it easy, we will come back to that later.
Now, transition time! Here, we will make Life, B3/S23. To make a transition, type a string as so:
Starting State, N Neighbor State, NE Neighbor State, E Neighbor State, SE Neighbor State, S Neighbor State, SW Neighbor State, W Neighbor State, NW Neighbor State, New State<
So, for Life's "B3", we write:
0,1,1,1,0,0,0,0,0,1
This means that if a state 0 cell has 3 neighbors, it will become state 1. This is also where permute comes in; if we didn't have permute, say none, it would only make the cell live if it is exactly the same as we put it, live on the North, North East, and East only, but permute makes it so all B3 states are filled.
Now we'll make transitions for death. We don't do it for survival because survival means no transition happens to the cell. Live cells in life survive if they have 2 or 3 live neighbors, hence die (from loneliness, one imagines) if they have only 0 or 1, or (from overcrowding) if they have 4 or more.
1,0,0,0,0,0,0,0,0,0 1,1,0,0,0,0,0,0,0,0 1,1,1,1,1,0,0,0,0,0 1,1,1,1,1,1,0,0,0,0 1,1,1,1,1,1,1,0,0,0 1,1,1,1,1,1,1,1,0,0 1,1,1,1,1,1,1,1,1,0
The entire file should now look like this:
@RULE Tutorial @TABLE n_states:2 neighborhood:Moore symmetries:permute 0,1,1,1,0,0,0,0,0,1 1,0,0,0,0,0,0,0,0,0 1,1,0,0,0,0,0,0,0,0 1,1,1,1,1,0,0,0,0,0 1,1,1,1,1,1,0,0,0,0 1,1,1,1,1,1,1,0,0,0 1,1,1,1,1,1,1,1,0,0 1,1,1,1,1,1,1,1,1,0
Save this file and open it using the RuleLoader algorithm, or select all of it and paste it into Golly, and voilà, you've recreated Conway Life!