## WireWorld Multiplication

Ed Pegg Jr., May 24, 2004

For A New Kind of Science, it was desirable to show a cellular automaton that demonstrated logic circuitry, within a simple picture. Systems such as the Game of Life can create logic circuits, but usually not within a 100×100 space. For example, Paul Rendell's Universal Turing Machine was created with Life, but it is somewhat large. Eventually, we looked at Brian Silverman's WireWorld rule: White (background) goes to White. Red (electron head) goes to Green (electron tail). Green (electron tail) goes to Black (wire). Black (wire) goes to Red if it touches exactly 1 or 2 Reds. In WireWorld, the logic gates are: (not, or, xor, and, nand).

Figure 1. Logic gates in Brian Silverman's WireWorld. (MCL code)

With the cellular automaton logic, and the appropriate logic gates, a construction in WireWorld is easy. For example, the logic of cellular automaton rule 30 is p xor (q or r). The following images demonstrate how WireWorld can emulate Rule 110, with a before and after shot of 3608 steps, along with an image of Rule 110.

Figure 2. WireWorld emulation of Rule 110. (MCL code)

This was a good demonstration, so it got into the book. Months later, I met the original creator of WireWorld, Brian Silverman, at the NKS2003 conference. Brian told me that he invented WireWorld after getting frustrated with the Game of Life. He only had a 40×40 screen in 1986, and designed WireWorld so that he could actually see something happening. Brian is still extending the ideas of "see something happening" today, through the continued development of the StarLogo System.

In 1996, Brian Silverman did a write-up of WireWorld for web publication, with explanations, insight, and Java demonstrations. He has very graciously allowed me to update and republish it here.

Link to Brian Silverman's interactive article, The Virtual Computer.

Obviously, it's easy to make a logic circuit in WireWorld. Still, I wondered whether it was truly universal. It's one thing to have the pieces, but can they actually be made into a computer? In constructions, timing is everything. On 24 July 2002, I posted a challenge to my mathpuzzle.com site: "If you'd like to experiment with large constructions, I'll award \$10 to the first person that can make a WireWorld construction capable of multiplying two 8 digit binary numbers."

Little did I know how much would come out of this challenge.

2 Aug 2002 -- Brian Trial took up my challenge to make a working Multiplier in WireWorld. It can be run in the free program Mirek's Cellebration. Brian: "Without Mirek's excellent application I couldn't have begun to put this together. Note that multiplication is done using a SINGLE full bit adder, with the carry bit and output fed back in as feedback loops. The entire operation takes about 18,000 generations to complete, so go get a cup of coffee. Don't forget to light the FUSE or the result won't get captured properly. The file as shown will multiply \$A3 (value in b7 - b0) by \$95 (value in a7 - a0) and put the result in c15 - c0."

Figure 3. Brian Trial's WireWorld Multiplier. (MCL Code)

18 Aug 2002 -- Nick Gardner: "I loved Brian Trial's WireWorld multiplier so much that I had to make my own. It's just a little bit smaller than Brian's version. :-) There's some brief notes about how it works in the pattern description." This is just stunning to watch in action in MCell. I didn't think multiplication of large numbers could be done with a simple cellular automata in such a small size, but there it is.

Figure 4. Nick Gardner's WireWorld multiplier. (MCL Code)

26 Sep 2003 -- Karl Scherer has made a grand page about WireWorld. His page contains many new discoveries for WireWorld logic circuits, many of which are considerably smaller than previously known constructions.  All of his constructions work within the WireWorld explorer, a program written with Zillions of Games.

13 Dec 2003 -- Nyles Heise fit a 32-bit WireWorld multiplier into a 22×93 rectangle.   Yes, that is a very tiny multiplication program. You can see his notes, or his MCL representation. (Input 1's, and Output 1's) You can download MCell from Mirek's site. In hexadecimal, the multiplier calculates EF4E75E7×EFA03229 = DFFFFFFFFFF7FFFF in 8116 cycles. See the Output 1's file for an expanded MCell version.  (Many other constructions are available at Nyles Heise's website.)

Figure 5.  Nick Gardner's WireWorld multiplier for EF4E75E7×EFA03229. (MCL Code)

On 6 July 2003, encouraged by what the previous challenge had uncovered, I tried another one. "\$20 Challenge. I'm certain that WireWorld can be used to make tape-like cells that mimic Turing machines. If you can make one, please let me know."

This challenge was also solved.

12 March 2004 -- Nyles Heise: "In response to the \$20 challenge posted on 6 July 2003, I've built several WireWorld implementations of a Turing Machine. I'm including two of them here. The Turing machines do unary multiplications. I set out to do the exact algorithm found in A. K. Dewdney's "The New Turing Omnibus", but backed of slightly by leaving the original numbers on the tape along with the product. The first design has 6 states plus halt and 4 symbols. It is basically the Nick Gardner approach. That is, it has specific latches to simulate the symbols on the tape. The symbols are read from and written to the tape location under the R/W head. The shift register is shifted either left or right one symbol. It's set up to do 4 = 2 X 2. The second design has 9 states plus halt and 2 symbols. This is Karl Scherer's approach where the tape is simulated as a loop in which electrons pass by the control mechanism and get modified as required. It's set up to do 5 X 4 = 20. Quite detailed descriptions of both machines are included in the .mcl and viewable by clicking the blue information button."

Figure 6.  Nick Gardner's WireWorld multiplier, via a Turing machine. (MCL Code)

13 May 2004 -- Nyles Heise has built Langton's Ant in WireWorld, along with many other things.  He also built a lovely Binary Counter (as explained at MathWorld).  They are incredible to watch.  All of these are differing implementations of 2-dimensional Turing machines (turmites).

Figure 7. Nick Gardner's WireWorld implementation of a 2D Turing machine that does binary counting. (MCL code)

My hope is that someday, a material can be made which can mimic a cellular automaton such as WireWorld.  With that, the Central Processing Units of computers could be made much smaller than they are today, and therefore much faster.

References:

David Eppstein, Seeds (B2/S), Gliders in Life-Like Cellular Automata, http://fano.ics.uci.edu/ca/rules/b2s/.

Nyles Heise, World Wide WireWorld, http://pages.prodigy.net/nylesheise/wireworld.html.

Paul Rendell, "A Turing Machine implemented in Conway's Game of Life," http://rendell.server.org.uk/gol/tm.htm.

Karl Scherer, WireWorld, http://karl.kiwi.gen.nz/CA-Wireworld.html.

Eric W. Weisstein et al. "WireWorld." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/WireWorld.html.

Mirek Wójtowicz, Mirek's Java Cellebration, http://www.mirekw.com/ca/mjcell/mjcell.html.

Mirek Wójtowicz, Cellular Automata rules lexicon, http://psoup.math.wisc.edu/mcell/rullex_rtab.html.

Stephen Wolfram, Universality in 2D cellular automata, A New Kind of Science, http://www.wolframscience.com/nksonline/page-1117b-text.

Zillions of Games, WireWorld, http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi/6363?do=show;id=2.