By changing the underlying rules, however, the number of nodes in a network can also be made to increase. … The pictures on the next page show examples of behavior produced by two rules that use this mechanism. In both cases, a new node is inserted in the "above" connection from each existing node in The evolution of network systems with four different choices of underlying rules.

One can always make the underlying system more complicated—say by having a network of cells, or by allowing different cells to have different and perhaps changing rules. But although this will make it more difficult to recognize definite rules even if one looks at the complete behavior of every element in the system, it does not affect the basic point that there is randomness that can intrinsically be generated by the evolution of the system. … The behavior of a given cell is determined by looking at the behavior of its two neighbors on the step before according to the rule shown.

Uniqueness and Branching in Time If our universe has no built-in global clock and no construct like an active cell, then it is almost inevitable that at the lowest level there will be at least some arbitrariness in how its rules can be applied. … But must it in the end actually be true that the underlying rules for our universe force there to be a unique perceived history? … On the first step in this particular picture, there happens to be only one replacement that can be performed consistent with the rules, so only a single string is produced.

The pictures below show what happens if one starts looking in turn at each of the possible initial conditions for rule 54. … So can rule 54 achieve universality? … Forms of behavior seen in the first 100 million initial conditions for rule 54.

For rule 22, it is approximately 0.35095. For rule 30 and rule 150 it is exactly 1/2, while for rule 182 it is 3/4. … In the algebraic representation discussed on page 869 , rule 22 is Mod[p + q + r + p q r, 2] , rule 126 is Mod[(p + q)(q + r) + (p + r), 2] , rule 150 is Mod[p + q + r, 2] and rule 182 is Mod[p r (1 + q) + (p + q + r), 2] .

Algebraic forms [for cellular automaton rules] The rules here can be expressed in algebraic terms (see page 869 ) as follows: • Rule 22: Mod[p + q + r + p q r, 2] • Rule 60: Mod[p + q, 2] • Rule 105: Mod[1 + p + q + r, 2] • Rule 129: Mod[1 + p + q + r + p q + q r + p r, 2] • Rule 150: Mod[p + q + r, 2] • Rule 225: Mod[1 + p + q + r + q r, 2] Note that rules 60, 105 and 150 are additive, like rule 90.

Special [cellular automaton] rules Rule 51: complement; rule 170: left shift; rule 204: identity; rule 240: right shift. These rules only ever depend on one cell in each neighborhood.

Rule 110 Many more details of rule 110 are discussed on pages 229 and 675 . … Note that of the 8 cases in the basic rule for rule 110, only one differs from rule 102—which is a simple additive rule obtained by reflecting rule 60.

Thus, for example, rule 30 can be given as {{1, 1, 1}  0, {1, 1, 0}  0, {1, 0, 1}  0, {1, 0, 0}  1, {0, 1, 1}  1, {0, 1, 0}  1, {0, 0, 1}  1, {0, 0, 0}  0} To use rules in this form, CAStep can be rewritten as CAStep[rule_, a_List] := Transpose[{RotateRight[a], a, RotateLeft[a]}] /. rule or CAStep[rule_, a_List] := Partition[a, 3, 1, 2] /. rule The rules that are given can now contain patterns, so that rule 90, for example, can be written as {{1, _, 1}  0, {1, _, 0}  1, {0, _, 1}  1, {0, _, 0}  0} But how can one set up a program that can handle rules in several different forms? A convenient approach is to put a "wrapper" around each rule that specifies what form the rule is in. Then, for example, one can define CAStep[ElementaryCARule[rule_List], a_List] := rule 〚 8 - (RotateLeft[a] + 2 (a + 2 RotateRight[a])) 〛 CAStep[GeneralCARule[rule_, r_Integer:1], a_List] := Partition[a, 2r + 1, 1, r + 1] /. rule CAStep[FunctionCARule[f_, r_Integer:1], a_List] := Map[f, Partition[a, 2r + 1, 1, r + 1]] Note that the second two definitions have been generalized to allow rules that involve r neighbors on each side.

In the top set of pictures, the rule specifies that a cell should become black whenever any of the six neighbors with which it shares a face were black on the step before. In the second set of pictures, the rule specifies that a cell should become black only when exactly one of its six neighbors was black on the step before.