Cellular Automaton is a discrete model of computation which evolves from an initial tiling of cells based off specific rules defined by it’s neighbors. In a standard cellular automaton system, there is only one path, which continues from one state to another. However, in a multiway system, there are many possible paths and therefore, can unfold in countless ways. Observing just one model of Cellular Automaton evolution may seem insignificant, and that is why this project seeks to use multiway systems to build and derive patterns in triangular aggregation and tilings. Because it is impossible to create and explore all rules of the growing triangular aggregation, this project will be limited to a specific set of rules which allow growth only if there is some specific amount of neighbors that are tiled. Later in this article, it will examine the terminating behaviors of branches of the multiway system. And instead of evolving the multiway system to find terminating branches, the article will use SAT solvers to find terminating cases and attempt to find those in the multiway system.

Introduction

What is a multiway system? A multiway system as defined by Steven is “a kind of substitution system in which multiple states are permitted at any stage”. In simpler terms, given some initial state, we apply the rule or function to create branches of all following possible states. A multiway system of a growing triangular aggregation based on the rule that if some neighboring triangle has only one tiled neighbor looks like this:
In[]:=
aggregationMultiwaySystemBuild[{{1,1,1}},3,1,5]
Out[]=
given one more iteration it looks like this :
In[]:=
aggregationMultiwaySystemBuild[{{1,1,1}},3,1,4]
Out[]=
Notice that this tree like structure doesn’t seem to merge in any sort of way. This is because it isn’t canonicalized, which means that aggregations that can be made equal through rotations, reflections, and translations are treated differently.
​
Objectives:
- Create functions that can flexibly create triangular aggregations based off some rules
- Create a multiway system of the possibilities of triangular aggregations
- Analyze terminating behaviors of branches in the multiway system

Aggregation and Tiling Structure and System

This section seeks to build the structure for growing the triangular aggregation and define rules that will determine the behaviors of the triangular aggregation.
At the beginning, I attempted to build the triangular aggregation system using polygons. However, after completing it, there were errors in the code due to dis-connected polygons, which were caused due to very small seems of around length 10⁻⁷ from merging polygons and graphics. Although I attempted to get around this obstacle, the method that caused this error was to deeply embedded inside my code, so I started over. In order to build a flexible system in which we are able to grow and aggregation of triangles, we will create a grid to place the triangles where each triangle’s position is defined by three integers. The diagonals with positive slope acts as the x-axis, the diagonals with negative slope acts as the y-axis, and the third number determines whether the triangle is facing upwards or downwards. We will call right side up triangles “rsu” triangles and we call upside down triangle “ud” triangles. In order to cover more unexplored ground and to find more interesting behaviors, we will be defining rules that consider different neighbors to create a triangle.

Building and Tiling The Triangular Aggregation

The inputs x and y scale a point to bring the it to a vertex of the triangular grid, and the last input (state) determines whether it goes to the center of a right side up or upside down triangle. 0 → Doesn’t Exist, 1 → rsu, 2 → ud. The function is show below:
In[]:=
trigridVertex[{x_,y_,state_}]:=​​x*{Sqrt[3],0}+y*{(Sqrt[3]/2),(3/2)}+Switch[state,0,0,1,{(Sqrt[3]/2),(1/2)},2,{0,1}]
For Visualization, the grid is shown below:
Out[]=
The grid above is built of two components, the text and the dots. The graphics below are visualizations of the components of the grid above. The code is at the bottom of this article.
In order to form the triangles, we perform some basic geometry and figure out the coordinates of a triangle with side length
3
based off its center. We create a function for the ud and rsu triangles. The function is show below:
In[]:=
trigridTriangle[{x_,y_,1}]:=​​Translate[Triangle[{{0,1},{(-Sqrt[3]/2),(-1/2)},{(Sqrt[3]/2),(-1/2)}}],trigridVertex[{x,y,1}]]​​​​trigridTriangle[{x_,y_,2}]:=​​Translate[Triangle[{{0,-1},{(Sqrt[3]/2),(1/2)},{(-Sqrt[3]/2),(1/2)}}],trigridVertex[{x,y,2}]]
To plot any aggregation, we will use the function trigridTriangle to plot each triangle separately:
aggregationPlot[aggregation_]:=​​Graphics[{FaceForm[GrayLevel[0.8]],EdgeForm[Black],​​trigridTriangle/@aggregation}]

Defining Neighborhoods and Rules For Growth

As a result of a project based on building and exploration, in order to see more complex behaviors, we will define rules for 3 - cell neighborhoods, 6 - cell neighborhoods, and 12 - cell neighborhoods. When building the triangular aggregation system, in order to streamline the process, we will define terms. First, we will define terms that will be used to talk about the rules of the growth of the triangular aggregation.
■
A neighborhood is the triangles surrounding an untiled triangle that determine whether or not the triangle is able to grow
■
A cell is simply a singular triangle
■
For a neighborhood of n, Let its rules be defined with 1 → n, where the numbers 1 → n represent how many neighbors a candidate is able to have in order to grow.
In order to create these rules, we will simply define the candidate triangle with either index (x,y,1) or (x,y,2). Then we create the indices of its neighbors in terms of x and y.
The functions for 3-cell, 6-cell, and 12-cell neighborhoods are shown below:
3 - Cell Neighborhood
In[]:=
aggregationNeighborhood3[{x_,y_,1}]:={{x+1,y,2},{x+1,y-1,2},{x,y,2}}​​aggregationNeighborhood3[{x_,y_,2}]:={{x-1,y+1,1},{x-1,y,1},{x,y,1}}
6 - Cell Neighborhood
12 - Cell Neighborhood
Now that we have determined the neighboring triangles for one triangle, we will do so for the entire aggregation of triangles. In order to do this, we find the neighbors of all triangles inside an aggregation, and then delete all triangles already inside the aggregation. In this way, we obtain all triangles that outline the triangular aggregation. Three Functions have been created, each one for a different neighborhood.
3 - Cell Neighborhood
6 - Cell Neighborhood
12 - Cell Neighborhood
A visual is shown below. The first image is of the aggregation of triangles and the second image are the neighbors of the aggregation. These aggregations are generated randomly for the sake of visualization:
The types of rules that we will be focusing on and analyzing are those of the format:
■
If a candidate has n neighbors, then it can grow
Now we move into defining functions to check the candidates for the ones that satisfy our rule. Below are the functions.
3 - Cell Neighborhood
6 - Cell Neighborhood
12 - Cell Neighborhood
Taking the previous triangular aggregation of the candidates, we will apply the rule 1 on it.
So far we have laid the groundwork for building triangular aggregations using 3 - cell, 6 - cell, and 12 - cell neighborhoods as well as for different types of rules.

Building Multiway System

This section seeks to create a multiway system of all possible triangular aggregations based of some rules.
In order to build a multiway system, we must create all possible aggregations for each step in its growth. The code below uses functions we defined previously to find candidates at each step in growth and then create a list of all possible aggregations. It’s important to note that the function below is only for one step.
The function below begins by applying the aggregationAppendList function which creates 3 different branches, each of a different possible shape . Then by iterating the aggregationAppendList function on each branch created (how NestGraph works), we create a tree like structure with all possible triangular aggregations after some amount of steps .
The Multiway System below has shows the graph of all possible triangular aggregations after 3 steps .

Canonicalization

To start off, under the project’s circumstance(exploring and analyzing the multiway system’s terminating behaviors), whether we canonicalize the multiway system of possible triangular aggregations is trivial.
The first attempt at writing a function that checked if two aggregations were congruent was the code shown below. However, the code ended up not working due to bugs in the Wolfram Language’s function “RegionCongruent”, which was meant to check if two regions were congruent. However, the function RegionSimilar seemed to work better than RegionCongruent, so I added a restriction to scaling the aggregation, however it turned out that RegionSimilar also had bugs in it. This is only a portion of the code I wrote to delete rotations, reflections, and translations. The rest of the code creates a list of lists of the congruent aggregations given any multiway system of the possible triangular aggregations. Then it uses a function VertexContract to combine all the vertices of the multiway system using that list of lists as the input.
As a consequence of the two large set backs and working on a large piece of code only to end up realizing that the function used was buggy, I was so not able to finish writing this piece of code though . However, I have though about it and have a good idea of what I should do .

Analyzing Terminating Behavior

Below is a multiway system of the possible triangular aggregations that can be formed after 4 steps given rule 1.
Given a 3 - Cell neighborhood, we can see that using Rule 1, the triangular aggregation will never terminate, as triangles will continuously grow on the edges of any aggregations. It is equally as important to note that using Rules 2 or need different initiation cases, and will also eventually lead all possible triangular aggregations to terminate, as in order for triangles to form using Rules 2, the following structures must be formed:
Or some variation of a hole in the aggregation
Notice that when triangles form though Rule 2, holes and gaps can only be filled in, and eventually, will “run out”. So all triangular aggregations formed through Rule 2 will terminate. Below, are examples of holes being filled in.
Triangular aggregations made with Rule 3 behaves very similarly.
Building off the behaviors of these rules, we realize that any triangular aggregation formed using a combination of rules 1, 2, or 3 with rule 1 will never terminate, and using a combination of rules 2 and 3 will always terminate.
Shown below are graphs of a triangular aggregation using rule 1.
We can easily observe that configurations of will terminate.
We can also quickly and easily observe that without a combination of different rules or initiating cases, triangular aggregations formed using neighborhood 12 terminate after the first step.

Conclusion

While I wasn’t able to find and analyze all possible termination cases for triangular aggregations using a 6 or 12 neighborhood due to major setbacks at the beginning, this project explored and created code to grow triangular aggregations, as well as following Steven in utilizing multiway systems to classify and see other computational proceses through a larger view. Obvious future works are solving the satisfiability problem (of which I have created an outline) in order to find all possible terminations for 3, 6, and 12 neighborhoods and canonicalizing the multiway systems. Deeper studies of the behaviors of the triangular aggregations could be formulating a formula or creating a case study to find the maximum amount of steps till termination and other relate behaviors.

Code

Grid of Text

Grid of Points

References

■
  • Wolfram, Stephen. “Aggregation and Tiling as Multicomputational Processes.” Stephen Wolfram Writings, 3 Nov. 2023, writings.stephenwolfram.com/2023/11/aggregation-and-tiling-as-multicomputational-processes/. Accessed 10 July 2025.‌
    • ■
  • “Multiway System.” Wolfram.com, Wolfram Research, Inc., 2021, mathworld.wolfram.com/MultiwaySystem.html. Accessed 10 July 2025.
    • ■
  • “Propositional Logic and SAT.” Www.cs.cmu.edu, www.cs.cmu.edu/~15281/coursenotes/proplogic/index.html

    • Acknowledgements

    First, I would like to extend my deepest thanks to Stephen Wolfram for laying the groundwork of exploring the method of building aggregations by utilizing multicomputational proceses with squares. I would also like to thank the entire Wolfram Summer Research Program Team for helping me through some large hurdles these past 2 weeks, and Stephen Wolfram for giving me this invaluable opportunity to work on this project. I would like to thank my mentor Tate Allen for his guidance and continuous support throughout my project. I would like give a special thanks to Dugan Hammock who provided me with ideas and suggestions that paved the way to pretty much recoding my project. To Logan Gilbert, William Choi-Kim, Ethan Kong, Austin Jiang, Annie Zhu, Anoushka Muchhal, for their continuous technical advice and support.

    CITE THIS NOTEBOOK

    Analyzing terminating behaviors of triangular aggregations using multiway systems​
    by Alan Archerman​
    Wolfram Community, STAFF PICKS, July 11, 2025
    ​https://community.wolfram.com/groups/-/m/t/3502618