Visitar URL original
SubstitutionSystem—Wolfram Documentation

WOLFRAM

Wolfram Language & System Documentation Center

SubstitutionSystem[rule,init,t]

generates a list representing the evolution of the substitution system with the specified rule from initial condition init for t steps.

SubstitutionSystem[rule,init]

gives the result of evolving init for one step.

SubstitutionSystem[rule]

is an operator form of SubstitutionSystem that corresponds to one step of evolution.

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
1D List Substitution Systems  
Higher-Dimensional List Substitution Systems  
String Substitution Systems  
Time Step Specifications  
Generalizations & Extensions  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Related Guides
History
Cite this Page

SubstitutionSystem

SubstitutionSystem[rule,init,t]

generates a list representing the evolution of the substitution system with the specified rule from initial condition init for t steps.

SubstitutionSystem[rule,init]

gives the result of evolving init for one step.

SubstitutionSystem[rule]

is an operator form of SubstitutionSystem that corresponds to one step of evolution.

Details

  • In SubstitutionSystem[rule,…], rule can be of the following forms:
  • {i1rhs1,i2rhs2,…}list substitution system
    {"s1"rhs1,"s2"rhs2,…}string substitution system
  • In list substitution systems, the rhsi can be lists of any length or can be rectangular arrays of any depth but all with the same dimensions. They can also be individual elements such as integers.
  • In string substitution systems, the rhsi can be strings of any length.
  • Both lists and string substitution systems can have rules that involve patterns, but every object that appears in the rhsi must have a transformation defined by the rules given.
  • List substitution systems work with SparseArray objects.
  • In string substitution systems, the initial condition init must be a string; in list substitution systems, it must be an array whose depth is equal to the depth of the rhsi.
  • In SubstitutionSystem[rule,init,tspec], the time specification tspec can have any of the following forms:
  • tall steps 0 through t
    {t}a list containing only step t
    {t1,t2}steps t1 through t2
    {t1,t2,dt}steps t1, t1+dt, …
  • SubstitutionSystem uses the first substitutions that apply at each step, in the same way as SequenceReplace and StringReplace.

Examples

open all close all

Basic Examples  (3)

Five steps of a string substitution system:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "A"}, "A", 5]

Analogous substitution system with lists:

Wolfram Language code: SubstitutionSystem[{0 -> {0, 1}, 1 -> {0}}, {0}, 5]

Steps in a 2D substitution system:

Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{1 -> {{1, 0}, {1, 1}}, 0 -> {{0, 0}, {0, 0}}}, {{1}}, 4]

Give the fourth step only:

Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{1 -> {{1, 0}, {1, 1}}, 0 -> {{0, 0}, {0, 0}}}, {{1}}, {4}]

Alternative form:

Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{1 -> {{1, 0}, {1, 1}}, 0 -> 0}, {{1}}, {4}]

Generate a rule icon for a substitution system:

Wolfram Language code: RulePlot[SubstitutionSystem[{1 -> {{1, 0}, {1, 1}}, 0 -> {{0, 0}, {0, 0}}}]]

Scope  (16)

1D List Substitution Systems  (3)

Wolfram Language code: SubstitutionSystem[{0 -> {0, 1}, 1 -> {1, 0}}, {0}, 3]

Lists do not have to be the same length:

Wolfram Language code: SubstitutionSystem[{0 -> {0, 1}, 1 -> {0}}, {0}, 3]

The initial condition can be of any length:

Wolfram Language code: SubstitutionSystem[{0 -> {0, 1}, 1 -> {1, 0}}, {0, 1, 0}, 3]

Rules can involve patterns:

Wolfram Language code: SubstitutionSystem[{0 | 1 -> {1, 2}, 2 -> {0, 1}}, {0}, 3]
Wolfram Language code: SubstitutionSystem[{n_ :> Range[n]}, {3}, 3]

Higher-Dimensional List Substitution Systems  (5)

Wolfram Language code: SubstitutionSystem[{0 -> {{0, 0}, {0, 0}}, 1 -> {{1, 0}, {1, 1}}}, {{1}}, 2]
Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{0 -> {{0, 0}, {0, 0}}, 1 -> {{1, 0}, {1, 1}}}, {{1}}, 3]

Arrays do not have to be square:

Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{0 -> {{0, 0, 0}, {0, 0, 0}}, 1 -> {{1, 0, 0}, {1, 1, 1}}}, {{1}}, 3]

Arrays can have any depth:

Wolfram Language code: Image3D /@ SubstitutionSystem[{0 -> {{{0, 0}, {0, 0}}, {{0, 0}, {0, 0}}}, 1 -> {{{1, 0}, {0, 0}}, {{1, 1}, {1, 1}}}}, {{{1}}}, 3]

The right-hand side of a rule can be a SparseArray:

Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{0 -> SparseArray[{{2, 2} -> 1}], 1 -> SparseArray[{{1, 1} -> 1, {2, 2} -> 1}]}, {{1}}, 5]

SparseArray as an initial condition:

Wolfram Language code: SubstitutionSystem[{0 -> {{0, 1}, {1, 0}}, 1 -> {{0, 0}, {0, 0}}}, SparseArray[{{1, 1} -> 1}], 2]

String Substitution Systems  (2)

A string substitution system:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "BA"}, "A", 5]

Use any characters in the strings:

Wolfram Language code: SubstitutionSystem[{"a" -> "aA", "A" -> "Aa"}, "A", 5]
Wolfram Language code: SubstitutionSystem[{"α" -> "αβ", "β" -> "βα"}, "β", 5]
Wolfram Language code: SubstitutionSystem[{"○" -> "○■", "■" -> "■○"}, "■", 5]

Arrange output in a column:

Wolfram Language code: Column[%]

Characters that do not appear in the rules are not replaced at each step:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "BA"}, "AC", 5]

Include additional characters in rules:

Wolfram Language code: SubstitutionSystem[{"A" -> "ABx", "B" -> "BA"}, "A", 5]

Time Step Specifications  (6)

Steps 0 through 5:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "A"}, "A", 5]

Step 5 only:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "A"}, "A", {5}]

Steps 3 through 5:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "A"}, "A", {3, 5}]

Odd-numbered steps:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "A"}, "A", {1, 5, 2}]

Apply a single step of evolution:

Wolfram Language code: SubstitutionSystem[{"A" -> "AB", "B" -> "A"}, "ABBAABAB"]

Apply in operator form:

Wolfram Language code: NestList[SubstitutionSystem[{"A" -> "AB", "B" -> "A"}], "ABAA", 5]

Generalizations & Extensions  (1)

Set up neighbor-dependent string rules; rules are applied in the order given:

Wolfram Language code: SubstitutionSystem[{"AA" -> "AB", "B" -> "BA", "A" -> "B"}, "AAA", 7]

Applications  (3)

Steps in constructing a Cantor set:

Wolfram Language code: ArrayPlot[{#}]& /@ SubstitutionSystem[{1 -> {1, 0, 1}, 0 -> {0, 0, 0}}, {1}, 3]

Create an analogous 2D nested object:

Wolfram Language code: ArrayPlot /@ SubstitutionSystem[{1 -> {{1, 1, 1}, {1, 0, 1}, {1, 1, 1}}, 0 -> ConstantArray[0, {3, 3}]}, {{1}}, 5]

3D Menger sponge:

Wolfram Language code: Image3D /@ SubstitutionSystem[{1 -> 1 - CrossMatrix[{1, 1, 1}], 0 -> ConstantArray[0, {3, 3, 3}]}, {{{1}}}, 3]

Generate a "C curve" fractal:

Wolfram Language code: Graphics[Line[AnglePath[(-1) ^ # Pi / 2]]]& /@ SubstitutionSystem[{0 -> {0, 0, 1}, 1 -> {1}}, {0}, {4, 10}]

Properties & Relations  (2)

Approximate a Cantor staircase function:

Wolfram Language code: ListLinePlot[Accumulate[#]]& /@ SubstitutionSystem[{1 -> {1, 0, 1}, 0 -> {0, 0, 0}}, {1}, {2, 5}]
Wolfram Language code: Plot[CantorStaircase[x], {x, 0, 1}]

Generate steps in a Thue–Morse substitution system:

Wolfram Language code: SubstitutionSystem[{0 -> {0, 1}, 1 -> {1, 0}} , {0}, 5]

The output at each step k is given by ThueMorse[Range[0,2^k-1]]:

Wolfram Language code: Last[%] == ThueMorse[Range[0, 2 ^ 5 - 1]]

Possible Issues  (1)

SubstitutionSystem always uses only the first substitution that applies:

Wolfram Language code: SubstitutionSystem[{"A" -> "X", "A" -> "Y"}, "AAAA", 2]

Neat Examples  (2)

Wolfram Language code: SubstitutionSystem[{"☺" -> "☺", "" -> "☺"}, "", 8]//Column

3D substitution system based on the Levi–Civita tensor:

Wolfram Language code: Image3D /@ SubstitutionSystem[{1 -> Abs[LeviCivitaTensor[3]], 0 -> ConstantArray[0, {3, 3, 3}]}, {{{1}}}, 3]
Wolfram Research (2015), SubstitutionSystem, Wolfram Language function, https://reference.wolfram.com/language/ref/SubstitutionSystem.html.

Text

Wolfram Research (2015), SubstitutionSystem, Wolfram Language function, https://reference.wolfram.com/language/ref/SubstitutionSystem.html.

CMS

Wolfram Language. 2015. "SubstitutionSystem." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/SubstitutionSystem.html.

APA

Wolfram Language. (2015). SubstitutionSystem. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/SubstitutionSystem.html

BibTeX

@misc{reference.wolfram_2026_substitutionsystem, author="Wolfram Research", title="{SubstitutionSystem}", year="2015", howpublished="\url{https://reference.wolfram.com/language/ref/SubstitutionSystem.html}", note=[Accessed: 14-November-2026]}

BibLaTeX

@online{reference.wolfram_2026_substitutionsystem, organization={Wolfram Research}, title={SubstitutionSystem}, year={2015}, url={https://reference.wolfram.com/language/ref/SubstitutionSystem.html}, note=[Accessed: 14-November-2026]}