---
title: "RulePlot"
language: "en"
type: "Symbol"
summary: "RulePlot[sys] generates a plot representing the rule for the computational system sys. RulePlot[sys, init, t] generates a plot of the evolution of the system sys from initial condition init for t steps. RulePlot[sys, evol] generates a plot of the evolution evol assuming it is derived from a system of the form sys."
keywords: 
- rule plot
- rule set plot
- rule numbering plot
- cellular automaton plot
- cellular automaton rules
- cellular automaton evolution
- cellular automata plot
- cellular automata rules
- cellular automata evolution
- Turing machine plot
- Turing machine rules
- Turing machine evolution
- substitution system plot
- substitution system rules
- Boolean function plot
- Boolean function rules
- computational system plot
- computational system rules
- computational system evolution
canonical_url: "https://reference.wolfram.com/language/ref/RulePlot.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Boolean Computation"
    link: "https://reference.wolfram.com/language/guide/BooleanComputation.en.md"
  - 
    title: "Computational Systems"
    link: "https://reference.wolfram.com/language/guide/ComputationalSystemsAndDiscovery.en.md"
  - 
    title: "Iterated Maps & Fractals"
    link: "https://reference.wolfram.com/language/guide/IteratedMapsAndFractals.en.md"
  - 
    title: "Discrete Mathematics"
    link: "https://reference.wolfram.com/language/guide/DiscreteMathematics.en.md"
related_functions: 
  - 
    title: "ArrayPlot"
    link: "https://reference.wolfram.com/language/ref/ArrayPlot.en.md"
  - 
    title: "CellularAutomaton"
    link: "https://reference.wolfram.com/language/ref/CellularAutomaton.en.md"
  - 
    title: "TuringMachine"
    link: "https://reference.wolfram.com/language/ref/TuringMachine.en.md"
  - 
    title: "SubstitutionSystem"
    link: "https://reference.wolfram.com/language/ref/SubstitutionSystem.en.md"
  - 
    title: "BooleanFunction"
    link: "https://reference.wolfram.com/language/ref/BooleanFunction.en.md"
  - 
    title: "BooleanTable"
    link: "https://reference.wolfram.com/language/ref/BooleanTable.en.md"
---
# RulePlot

RulePlot[sys] generates a plot representing the rule for the computational system sys.

RulePlot[sys, init, t] generates a plot of the evolution of the system sys from initial condition init for t steps.

RulePlot[sys, evol] generates a plot of the evolution evol assuming it is derived from a system of the form sys.

## Details and Options

* Possible computational systems ``sys`` include:

|                          |                      |
| ------------------------ | -------------------- |
| CellularAutomaton[spec]  | cellular automaton   |
| TuringMachine[spec]      | Turing machine       |
| SubstitutionSystem[spec] | substitution system  |
| BooleanFunction[spec]    | Boolean function     |

* ``TuringMachine[{rule, s, k}]`` can be used to specify a Turing machine in which ``rule`` does not uniquely specify a transformation for each of the ``s k`` possible configurations, but that nevertheless will be rendered assuming ``s`` head states and ``k`` tape colors.

* ``RulePlot`` works with 1D and 2D systems.

* Options include:

|              |             |                                           |
| ------------ | ----------- | ----------------------------------------- |
| Appearance   | Automatic   | overall appearance                        |
| ColorRules   | Automatic   | rules for determining colors from values  |
| Frame        | Automatic   | whether to draw a frame around rule cases |
| FrameStyle   | Automatic   | the style to use for a frame              |
| Mesh         | Automatic   | whether to draw a mesh                    |
| MeshStyle    | Automatic   | the style to use for a mesh               |
| PlotLegends  | None        | legends to include                        |
| PlotMarkers  | Automatic   | markers for Turing machines, etc.         |
| PlotTheme    | \$PlotTheme | overall theme for the rule plot           |
| Spacings     | Automatic   | horizontal and vertical spacings          |

* Possible appearance elements include:

|         |              |                              |
| ------- | ------------ | ---------------------------- |
| [image] | "Contiguous" | no space between states      |
| [image] | "Stacked"    | small space between states   |
| [image] | "Arrow"      | draw an arrow between states |
| [image] | "Squares"    | squares for cells            |
| [image] | "Bricks"     | bricks for cells             |
| [image] | "Hexagons"   | hexagons for cells           |
| [image] | "Simplified" | simplified rule cases        |
| [image] | "Short"      | show shortened list of rules |

* Possible plot legend forms include:

|        |                           |
| ------ | ------------------------- |
| "Icon" | use an icon as the legend |
| "Text" | use text as the legend    |
| expr   | arbitrary plot legend     |

* In the form ``RulePlot[sys, evol]``, specific rules are typically ignored; only the implicit or explicit specification of number of colors, states, etc. is used.

---

## Examples (70)

### Basic Examples (5)

Return the rule icon for elementary cellular automaton rule 30:

```wl
In[1]:= RulePlot[CellularAutomaton[30]]

Out[1]= [image]
```

---

Plot the evolution of a cellular automaton for 10 steps:

```wl
In[1]:= RulePlot[CellularAutomaton[30], {{1}, 0}, 10]

Out[1]= [image]
```

Include the rule icon:

```wl
In[2]:= RulePlot[CellularAutomaton[30], {{1}, 0}, 10, PlotLegends -> "Icon"]

Out[2]= [image]
```

---

Plot the evolution of a Turing machine:

```wl
In[1]:= RulePlot[TuringMachine[{596440, 2, 3}], {1, {{}, 0}}, 20]

Out[1]= [image]
```

Return its rule icon:

```wl
In[2]:= RulePlot[TuringMachine[{596440, 2, 3}]]

Out[2]= [image]
```

---

Generate the evolution of a Turing machine:

```wl
In[1]:= evolution = TuringMachine[{596440, 2, 3}, {1, {{}, 0}}, 5]

Out[1]= {{{1, 2, 0}, {0, 0, 0}}, {{2, 3, 1}, {0, 1, 0}}, {{1, 2, 0}, {0, 1, 2}}, {{1, 1, -1}, {0, 2, 2}}, {{2, 2, 0}, {1, 2, 2}}, {{1, 3, 1}, {1, 0, 2}}}
```

Use ``RulePlot`` to display the history, using information on the rule to determine the form:

```wl
In[2]:= RulePlot[TuringMachine[{596440, 2, 3}], evolution]

Out[2]= [image]
```

---

Show the rule icon for a substitution system:

```wl
In[1]:= RulePlot[SubstitutionSystem[{1 -> {1, 0}, 0 -> {0, 1}}], Appearance -> "Arrow"]

Out[1]= [image]
```

### Scope (42)

#### System Rules (31)

##### CellularAutomaton (11)

Elementary cellular automaton rule 90:

```wl
In[1]:= RulePlot[CellularAutomaton[90]]

Out[1]= [image]
```

---

Cellular automaton with more than two colors:

```wl
In[1]:= RulePlot[CellularAutomaton[{679458, 3}]]

Out[1]= [image]
```

---

Cellular automaton with range greater than 1:

```wl
In[1]:= RulePlot[CellularAutomaton[{1234, 2, 2}]]

Out[1]= [image]
```

---

Cellular automaton with fractional range:

```wl
In[1]:= RulePlot[CellularAutomaton[{9, 2, 3 / 2}]]

Out[1]= [image]
```

---

Totalistic 3-color cellular automaton:

```wl
In[1]:= RulePlot[CellularAutomaton[{1599, {3, 1}}]]

Out[1]= [image]
```

---

Outer totalistic 3-color cellular automaton:

```wl
In[1]:= RulePlot[CellularAutomaton[{1000, {3, {3, 1, 3}}}]]

Out[1]= [image]
```

---

General two-dimensional cellular automaton:

```wl
In[1]:= RulePlot[CellularAutomaton[{23571113171923, 2, {1, 1}}]]

Out[1]= [image]
```

---

Totalistic two-dimensional 5-neighbor rule:

```wl
In[1]:= RulePlot[CellularAutomaton[{20, {2, {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}}}, {1, 1}}]]

Out[1]= [image]
```

---

Totalistic two-dimensional 9-neighbor rule:

```wl
In[1]:= RulePlot[CellularAutomaton[{111, {2, {{1, 1, 1}, {1, 1, 1}, {1, 1, 1}}}, {1, 1}}]]

Out[1]= [image]
```

---

Outer totalistic two-dimensional rule:

```wl
In[1]:= RulePlot[CellularAutomaton[{222, {2, {{2, 2, 2}, {2, 1, 2}, {2, 2, 2}}}, {1, 1}}]]

Out[1]= [image]
```

---

Rules specified using associations:

```wl
In[1]:= RulePlot[CellularAutomaton[<|"RuleNumber" -> 30|>]]

Out[1]= [image]

In[2]:= RulePlot[CellularAutomaton[<|"TotalisticCode" -> 14, "Dimension" -> 2|>]]

Out[2]= [image]

In[3]:= RulePlot[CellularAutomaton[<|"OuterTotalisticCode" -> 110, "Dimension" -> 2, "Neighborhood" -> 5|>]]

Out[3]= [image]
```

##### TuringMachine (8)

Turing machine rule 2506:

```wl
In[1]:= RulePlot[TuringMachine[2506]]

Out[1]= [image]
```

---

Turing machine with more than two states:

```wl
In[1]:= RulePlot[TuringMachine[{600720, 3}]]

Out[1]= [image]
```

---

Turing machine with more than two colors:

```wl
In[1]:= RulePlot[TuringMachine[{596440, 2, 3}]]

Out[1]= [image]
```

---

Turing machines specified by rules:

```wl
In[1]:= RulePlot[TuringMachine[{{1, 2} -> {1, 1, -1}, {1, 1} -> {1, 2, -1}, {1, 0} -> {2, 1, 1}, {2, 2} -> {1, 0, 1}, {2, 1} -> {2, 2, 1}, {2, 0} -> {1, 2, -1}}]]

Out[1]= [image]
```

---

Explicitly specify values of the number of states ``s`` and the number of colors ``k`` for the same transition rules:

```wl
In[1]:= rules = {{1, 1} -> {2, 0, -1}, {1, 0} -> {2, 1, 1}, {2, 1} -> {1, 0, 1}, {2, 0} -> {1, 1, -1}};

In[2]:= RulePlot[TuringMachine[{rules, 2, 2}]]

Out[2]= [image]

In[3]:= RulePlot[TuringMachine[{rules, 3, 3}]]

Out[3]= [image]
```

---

Single-state Turing machine heads are represented with a dot:

```wl
In[1]:= RulePlot[TuringMachine[{{1, 1} -> {1, 0, -1}, {1, 0} -> {1, 0, -1}}]]

Out[1]= [image]
```

Increase the number of states to change the representation:

```wl
In[2]:= RulePlot[TuringMachine[{{{1, 1} -> {1, 0, -1}, {1, 0} -> {1, 0, -1}}, 2, 2}]]

Out[2]= [image]
```

---

An underspecified Turing machine does not have rules for all ``s k`` input configurations:

```wl
In[1]:= RulePlot[TuringMachine[{{1, 0} -> {2, 1, 1}, {2, 1} -> {1, 0, 1}, {2, 0} -> {1, 1, -1}}]]

Out[1]= [image]
```

---

A nondeterministic Turing machine specifies different rules for the same input configuration:

```wl
In[1]:= RulePlot[TuringMachine[{{1, 0} -> {1, 0, -1}, {1, 0} -> {1, 0, 1}}]]

Out[1]= [image]
```

##### SubstitutionSystem (8)

String substitution system for two characters:

```wl
In[1]:= RulePlot[SubstitutionSystem[{"a" -> "ba", "b" -> "aa"}]]

Out[1]= [image]
```

---

String substitution system for more than two characters:

```wl
In[1]:= RulePlot[SubstitutionSystem[{"a" -> "ba", "b" -> "da", "c" -> "ca", "d" -> "bc"}]]

Out[1]= [image]
```

---

String substitution system for length-2 strings:

```wl
In[1]:= RulePlot[SubstitutionSystem[{"aa" -> "bc", "ab" -> "aa", "ba" -> "ab", "cb" -> "ac", "cc" -> "ba"}]]

Out[1]= [image]
```

---

String substitution system for strings of different lengths:

```wl
In[1]:= RulePlot[SubstitutionSystem[{"aa" -> "ba", "ab" -> "c", "bac" -> "aba", "bba" -> "b", "c" -> "bc"}]]

Out[1]= [image]
```

---

List substitution system for two integer values:

```wl
In[1]:= RulePlot[SubstitutionSystem[{0 -> {0, 1}, 1 -> {0, 0}}]]

Out[1]= [image]
```

---

List substitution system for more than two integer values:

```wl
In[1]:= RulePlot[SubstitutionSystem[{0 -> {0, 1}, 1 -> {2, 3}, 2 -> {1, 2}, 3 -> {2, 0}}]]

Out[1]= [image]
```

---

List substitution system with lists of different lengths:

```wl
In[1]:= RulePlot[SubstitutionSystem[{0 -> {0, 1, 3}, 1 -> {2, 3}, 2 -> {1}, 3 -> {2, 0}}]]

Out[1]= [image]
```

---

Two-dimensional substitution systems:

```wl
In[1]:= RulePlot[SubstitutionSystem[{0 -> {{0, 0}, {0, 0}}, 1 -> {{0, 1}, {1, 1}}}]]

Out[1]= [image]

In[2]:= RulePlot[SubstitutionSystem[{0 -> {{0, 0, 0}, {0, 0, 0}}, 1 -> {{1, 0, 0}, {1, 1, 1}}}]]

Out[2]= [image]
```

##### BooleanFunction (4)

Boolean function in two variables:

```wl
In[1]:= RulePlot[BooleanFunction[8, 2]]

Out[1]= [image]
```

---

Boolean function in more than two variables:

```wl
In[1]:= RulePlot[BooleanFunction[251084, 5]]

Out[1]= [image]
```

---

Boolean function based on a vector of truth values:

```wl
In[1]:= RulePlot[BooleanFunction[{True, True, True, False, False, False, False, False}]]

Out[1]= [image]
```

---

Boolean function based on a table of truth rules:

```wl
In[1]:=
RulePlot[BooleanFunction[{
	{True, True, True} -> 0, {True, True, False} -> 0, 
	{True, False, True} -> 0, {True, False, False} -> 1, 
	{False, True, True} -> 0, {False, True, False} -> 0, 
	{False, False, True} -> 1, {False, False, False} -> 1
	}]]

Out[1]= [image]
```

#### System Evolution (11)

##### CellularAutomaton (5)

Evolution of rule 30 for 10 steps:

```wl
In[1]:= RulePlot[CellularAutomaton[30], {0, 0, 1, 1, 1, 0, 0}, 10]

Out[1]= [image]
```

Evolution for 50 steps from a single 1 on a background of 0s:

```wl
In[2]:= RulePlot[CellularAutomaton[30], {{1}, 0}, 50]

Out[2]= [image]
```

---

Evolution of a 3-color cellular automaton:

```wl
In[1]:= RulePlot[CellularAutomaton[{679458, 3}], {{1}, 0}, 120]

Out[1]= [image]
```

Evolution from a single 1 on a background of repeated 0110 blocks:

```wl
In[2]:= RulePlot[CellularAutomaton[{679458, 3}], {{1}, {0, 1, 1, 0}}, 120]

Out[2]= [image]
```

---

Evolution of a 3-color totalistic code:

```wl
In[1]:= RulePlot[CellularAutomaton[{2049, {3, 1}}], {{1}, 0}, 100]

Out[1]= [image]
```

---

Evolution of a 3-color outer totalistic code:

```wl
In[1]:= RulePlot[CellularAutomaton[{50010, {3, {3, 1, 3}}}], {{1}, 0}, 100]

Out[1]= [image]
```

---

Evolution of rules specified by associations:

```wl
In[1]:= RulePlot[CellularAutomaton[<|"RuleNumber" -> 23898, "Range" -> 3 / 2|>], {{1}, 0}, 80]

Out[1]= [image]

In[2]:= RulePlot[CellularAutomaton[<|"TotalisticCode" -> 1599, "Colors" -> 3|>], {{1}, 0}, 200]

Out[2]= [image]
```

##### TuringMachine (6)

Evolution of a 2-state, 2-color Turing machine, starting with a tape of four 0s:

```wl
In[1]:= RulePlot[TuringMachine[2506], {1, {0, 0, 0, 0}}, 20]

Out[1]= [image]
```

Evolution starting with an infinite tape of 0s:

```wl
In[2]:= RulePlot[TuringMachine[2506], {1, {{}, 0}}, 20]

Out[2]= [image]
```

---

Evolution of a 3-state, 2-color Turing machine:

```wl
In[1]:= RulePlot[TuringMachine[{956440, 3}], {1, {{}, 0}}, 20]

Out[1]= [image]
```

Evolution starting with a tape of 1 on a background of 0s:

```wl
In[2]:= RulePlot[TuringMachine[{956440, 3}], {1, {{1}, 0}}, 20]

Out[2]= [image]
```

---

Evolution of a 2-state, 3-color Turing machine:

```wl
In[1]:= RulePlot[TuringMachine[{596440, 2, 3}], {1, {{}, 0}}, 20]

Out[1]= [image]
```

Evolution with the head initially in state 2:

```wl
In[2]:= RulePlot[TuringMachine[{596440, 2, 3}], {2, {{}, 0}}, 20]

Out[2]= [image]
```

---

Evolution of a Turing machine specified by rules, starting from a background of repeated 021 blocks:

```wl
In[1]:=
RulePlot[TuringMachine[{
	{1, 0} -> {1, 2, 1}, {1, 1} -> {1, 2, 1}, {1, 2} -> {2, 0, -1}, 
	{2, 0} -> {2, 1, -1}, {2, 1} -> {1, 2, 1}, {2, 2} -> {2, 0, -1}
	}], {1, {{}, {0, 2, 1}}}, 50]

Out[1]= [image]
```

---

A nondeterministic Turing machine can give different evolutions depending on the order of its rules:

```wl
In[1]:= RulePlot[TuringMachine[{{1, 0} -> {1, 0, -1}, {1, 0} -> {1, 0, 1}}], {1, {{}, 0}}, 10, PlotLegends -> "Icon"]

Out[1]= [image]

In[2]:= RulePlot[TuringMachine[{{1, 0} -> {1, 0, 1}, {1, 0} -> {1, 0, -1}}], {1, {{}, 0}}, 10, PlotLegends -> "Icon"]

Out[2]= [image]
```

---

An underspecified Turing machine does not have rules for all ``s k`` input configurations:

```wl
In[1]:= RulePlot[TuringMachine[{{1, 0} -> {2, 1, 1}, {2, 1} -> {1, 0, 1}, {2, 0} -> {1, 1, -1}}], {1, {{}, 0}}, 10]

Out[1]= [image]
```

Specifying a complete set of rules eliminates the fixed point:

```wl
In[2]:= RulePlot[TuringMachine[{{1, 1} -> {2, 0, -1}, {1, 0} -> {2, 1, 1}, {2, 1} -> {1, 0, 1}, {2, 0} -> {1, 1, -1}}], {1, {{}, 0}}, 10]

Out[2]= [image]
```

### Options (19)

#### Appearance (4)

Use hexagons:

```wl
In[1]:= RulePlot[CellularAutomaton[{9, 2, 1 / 2}], Appearance -> "Hexagons"]

Out[1]= [image]
```

---

Use bricks:

```wl
In[1]:= RulePlot[CellularAutomaton[{9, 2, 1 / 2}], Appearance -> "Bricks"]

Out[1]= [image]
```

---

Sometimes you can get a simplified result that shows cells whose value does not matter:

```wl
In[1]:= RulePlot[CellularAutomaton[30], Appearance -> "Simplified"]

Out[1]= [image]
```

---

Shorten the display of the rule set:

```wl
In[1]:= RulePlot[CellularAutomaton[{31469, 5}], Appearance -> "Short"]

Out[1]= [image]
```

#### ColorRules (1)

Specify color rules for explicit values or patterns:

```wl
In[1]:= RulePlot[CellularAutomaton[{1234, 3}], ColorRules -> {0 -> White, 1 -> Red, _ -> Purple}]

Out[1]= [image]
```

#### Frame (1)

Do not use a frame:

```wl
In[1]:= RulePlot[CellularAutomaton[30], Frame -> False]

Out[1]= [image]
```

#### FrameStyle (2)

Make the frame blue:

```wl
In[1]:= RulePlot[CellularAutomaton[30], FrameStyle -> Blue]

Out[1]= [image]
```

---

Give a composite directive for the frame:

```wl
In[1]:= RulePlot[CellularAutomaton[30], FrameStyle -> Directive[Orange, Dashed]]

Out[1]= [image]
```

#### Mesh (1)

By default, a mesh is drawn around individual cells:

```wl
In[1]:= RulePlot[CellularAutomaton[30], PlotTheme -> "Web"]

Out[1]= [image]
```

Do not use a mesh:

```wl
In[2]:= RulePlot[CellularAutomaton[30], Mesh -> False, PlotTheme -> "Web"]

Out[2]= [image]
```

#### MeshStyle (2)

Make the mesh blue:

```wl
In[1]:= RulePlot[CellularAutomaton[30], MeshStyle -> Blue]

Out[1]= [image]
```

---

Give a composite directive for the mesh:

```wl
In[1]:= RulePlot[CellularAutomaton[30], MeshStyle -> Directive[Orange, Thick]]

Out[1]= [image]
```

#### PlotLegends (3)

Give a plot legend describing the rule in text:

```wl
In[1]:= RulePlot[CellularAutomaton[30], PlotLegends -> "Text"]

Out[1]= [image]
```

---

Give a plot legend describing the rule as an icon:

```wl
In[1]:= RulePlot[CellularAutomaton[30], {{1}, 0}, 20, PlotLegends -> "Icon"]

Out[1]= [image]
```

---

Give an arbitrary plot legend:

```wl
In[1]:= RulePlot[CellularAutomaton[30], {{1}, 0}, 100, PlotLegends -> Placed[Text["complex behavior"], Below]]

Out[1]= [image]
```

#### PlotMarkers (2)

Make the marker of a Turing machine gray:

```wl
In[1]:= RulePlot[TuringMachine[{596440, 2, 3}], {1, {{}, 0}}, 20, PlotMarkers -> Gray]

Out[1]= [image]
```

---

Draw the outline of the default markers:

```wl
In[1]:=
RulePlot[TuringMachine[{596440, 2, 3}], {1, {{}, 0}}, 20, PlotMarkers -> Directive[EdgeForm[{Black, AbsoluteThickness[1]}], 
	FaceForm[]]]

Out[1]= [image]
```

#### PlotTheme (2)

Use the web plot theme:

```wl
In[1]:= RulePlot[CellularAutomaton[30], PlotTheme -> "Web"]

Out[1]= [image]
```

Use this theme without a mesh:

```wl
In[2]:= RulePlot[CellularAutomaton[30], PlotTheme -> "Web", Mesh -> False]

Out[2]= [image]
```

---

Use the scientific plot theme:

```wl
In[1]:=
RulePlot[TuringMachine[{
	{1, 0} -> {1, 2, 1}, {1, 1} -> {1, 2, 1}, {1, 2} -> {2, 0, -1}, 
	{2, 0} -> {2, 1, -1}, {2, 1} -> {1, 2, 1}, {2, 2} -> {2, 0, -1}, 
	{3, 0} -> {5, 2, -1}, {3, 1} -> {3, 2, 1}, {3, 2} -> {3, 1, 1}, 
	{4, 0} -> {5, 0, -1}, {4, 1} -> {4, 1, 1}, {4, 2} -> {4, 0, 1}, 
	{5, 0} -> {5, 1, 0}, {5, 1} -> {5, 2, -1}, {5, 2} -> {5, 0, -1}, 
	{6, 0} -> {3, 2, 1}, {6, 1} -> {5, 0, -1}, {6, 2} -> {6, 0, -1}
	}], PlotTheme -> "Scientific"]

Out[1]= [image]
```

#### Spacings (1)

Change the spacing inside the frame:

```wl
In[1]:= RulePlot[CellularAutomaton[30], Spacings -> 1]

Out[1]= [image]
```

Change the spacing on each side of the icon:

```wl
In[2]:= RulePlot[CellularAutomaton[30], Spacings -> {{1, 2}, {3, 4}}]

Out[2]= [image]
```

### Applications (2)

```wl
In[1]:= ArrayPlot[CellularAutomaton[30, {{1}, 0}, 50], PlotTheme -> "Web"]

Out[1]= [image]

In[2]:= RulePlot[CellularAutomaton[30], PlotTheme -> "Web"]

Out[2]= [image]
```

---

Use ``RulePlot`` to legend the evolution of a ``CellularAutomaton`` :

```wl
In[1]:= RulePlot[CellularAutomaton[30], {{1}, 0}, 50, PlotLegends -> "Icon"]

Out[1]= [image]
```

### Properties & Relations (2)

Plot the evolution of a cellular automaton with ``ArrayPlot`` :

```wl
In[1]:= ArrayPlot[CellularAutomaton[90, {{1}, 0}, 50]]

Out[1]= [image]
```

Use ``RulePlot`` to plot the evolution and the rule icon:

```wl
In[2]:= RulePlot[CellularAutomaton[90], {{1}, 0}, 50, PlotLegends -> "Icon"]

Out[2]= [image]
```

---

Plot the evolution of a Turing machine with ``ArrayPlot`` :

```wl
In[1]:= ArrayPlot[Last /@ TuringMachine[2506, {1, {{}, 0}}, 20]]

Out[1]= [image]
```

Use ``RulePlot`` to plot the evolution and the head of the machine:

```wl
In[2]:= RulePlot[TuringMachine[2506], {1, {{}, 0}}, 20]

Out[2]= [image]
```

## See Also

* [`ArrayPlot`](https://reference.wolfram.com/language/ref/ArrayPlot.en.md)
* [`CellularAutomaton`](https://reference.wolfram.com/language/ref/CellularAutomaton.en.md)
* [`TuringMachine`](https://reference.wolfram.com/language/ref/TuringMachine.en.md)
* [`SubstitutionSystem`](https://reference.wolfram.com/language/ref/SubstitutionSystem.en.md)
* [`BooleanFunction`](https://reference.wolfram.com/language/ref/BooleanFunction.en.md)
* [`BooleanTable`](https://reference.wolfram.com/language/ref/BooleanTable.en.md)

## Related Guides

* [Boolean Computation](https://reference.wolfram.com/language/guide/BooleanComputation.en.md)
* [Computational Systems](https://reference.wolfram.com/language/guide/ComputationalSystemsAndDiscovery.en.md)
* [Iterated Maps & Fractals](https://reference.wolfram.com/language/guide/IteratedMapsAndFractals.en.md)
* [Discrete Mathematics](https://reference.wolfram.com/language/guide/DiscreteMathematics.en.md)

## History

* [Introduced in 2016 (11.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn110.en.md) \| [Updated in 2020 (12.1)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn121.en.md) ▪ [2021 (12.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn123.en.md)