aa r X i v : . [ c s . CC ] J un T. Neary, D. Woods, A.K. Seda and N. Murphy (Eds.):The Complexity of Simple Programs 2008.EPTCS 1, 2009, pp. 31–55, doi:10.4204/EPTCS.1.4 c (cid:13)
M. Cook
A Concrete View of Rule 110 Computation
Matthew Cook
Institute of Neuroinformatics, University of Zurich and ETH Zurich
Rule 110 is a cellular automaton that performs repeated simultaneous updates of an infinite row ofbinary values. The values are updated in the following way: 0s are changed to 1s at all positionswhere the value to the right is a 1, while 1s are changed to 0s at all positions where the values to theleft and right are both 1. Though trivial to define, the behavior exhibited by Rule 110 is surprisinglyintricate, and in [1] we showed that it is capable of emulating the activity of a Turing machineby encoding the Turing machine and its tape into a repeating left pattern, a central pattern, and arepeating right pattern, which Rule 110 then acts on. In this paper we provide an explicit compilerfor converting a Turing machine into a Rule 110 initial state, and we present a general approach forproving that such constructions will work as intended. The simulation was originally assumed torequire exponential time, but surprising results of Neary and Woods [2] have shown that in fact, onlypolynomial time is required. We use the methods of Neary and Woods to exhibit a direct simulationof a Turing machine by a tag system in polynomial time.
In this section we give a concrete algorithm for compiling a Turing machine and its tape into an initialstate for Rule 110, following the construction given in [1]. We will create an initial state that will eventu-ally produce the bit sequence 01101001101000 if and only if the corresponding Turing machine halts. Or,if one prefers time sequences to spatial sequences, it is also the case that the sequence 110101010111111will be produced over time by a single cell if and only if the Turing machine halts. (These sequences arethe shortest that occur for the first time in the collision that produces the F glider as in figure 12(z), whichonly occurs if the algorithm halts.) While based directly on the methods of [1], the presentation of the al-gorithm here is self-contained. This section can be viewed as heavily commented high level pseudocode,the intent being to explicitly provide all the details a program would use, regardless of programminglanguage or input or output format.Following [1], we will convert the Turing machine into a tag system, which we then convert intoa cyclic tag system, and finally into a bit sequence for Rule 110. Of course, if one is starting with atag system, or a cyclic tag system (whose appendants’ lengths are multiples of 6), then the unnecessaryconversions may be omitted. For example, Paul Chapman’s tag system [3] for the 3 x + { A ❀ C , B ❀ D , C ❀ AE , D ❀ BF , E ❀ CCD , F ❀ DDD } , with a starting tape of C [ D ] x − , orLiesbeth De Mol’s more recent tag system for the same problem [4], { A ❀ CY , C ❀ A , Y ❀ AAA } , canbe implemented nicely in Rule 110 without going through a Turing machine representation. As anotherexample, the cyclic tag system { YYYYYY , /0 , NNNNNN , /0 } , starting with a single Y on the tape, yieldsexactly the same behavior as the cyclic tag system shown in figure 2 of [1] with runs of Y s (after theinitial Y ) doubled and runs of N s lengthened by a factor of six. This cyclic tag system is also shown onPage 96 of [5], which shows a random-looking graph of its behavior during the first million steps.If we start with a cyclic tag system whose appendants are not each a multiple of six long, we canconvert it into such a form as follows: Expand each appendant by adding 5 N symbols after every symbol,and expand the list of appendants by adding 5 empty appendants after every appendant. The tape should2 AConcrete ViewofRule 110 Computationalso be expanded just as each appendant was. This will make every appendant’s length be a multiple ofsix, while performing the same computation, on every sixth step, as the original cyclic tag system. Suppose we are given a Turing machine with m states Y = { y , y , . . . , y m } and t symbols S = { s , s , . . . , s t } and we are given its lookup tables for which symbol to write ¡ ( y i , s j ) ∈ S , whichway to move D ( y i , s j ) ∈ { left , right , halt } , and what state to go into G ( y i , s j ) ∈ Y . ( ¡ and G do not needto be defined for (state, symbol) pairs that cause the machine to halt, i.e. for which D is halt .)Suppose further that the Turing machine is currently in state y g , and that the tape is of the form s a w s a w − · · · s a s b x s b x − · · · s b s c s d s d · · · s d y s e s e · · · s e z , where the box represents the current position of the Turing machine’s head, and the portions with linesover them are repeated into the distance of the two-way infinite tape.Our task is to convert this complete description of the Turing machine and its infinite tape into aninitial state for Rule 110. Our first transformation will be to convert this Turing machine into a set of tag system rules for a tagsystem with deletion number s , meaning that at each step, s symbols are removed from the front of thetape, and an appendant is appended according only to the first of the s removed symbols. There are twogeneral approaches for doing this. The traditional (since 1964) approach of Cocke and Minsky [6] issimpler, but results in an exponential slowdown in simulation time. The modern (since 2006) approachof Neary and Woods [2] is more complicated, but amazingly solves what I call the “geometry problem”of cyclic-state tape processors such as tag systems and cyclic tag systems. The geometry problem in thisinstance is that the processing head is unaware, as it scans the tape, of which tape symbols are next towhich other tape symbols. This is because it effectively has a fixed number of bits of memory, consistingof the phase of the head with respect to the tape, and these bits can only be read or written with difficulty.One difficulty is that the bits must be shared for an entire pass of processing the tape, meaning that themachine is unable to simply remember at each step what symbol it just saw, as a Turing machine mightdo. Indeed, everything the machine does remember is due to the sum total effect of the previous pass,rather than the current pass. This makes it nearly impossible for the system to know the ordering ofthe symbols on the tape. Without being able to detect the order of the symbols, encodings are limitedto a unary representation, which makes the tape exponentially larger than a binary representation, thusmaking passes over the tape take exponentially longer.In this section we will perform the transformation using the simpler method of Cocke and Minsky.For an explanation of why it is that a transformation like this results in a tag system that correctlyemulates the Turing machine, see [1]. Here we just focus on the mechanics of the transformation itself.In section 3 we will show how a conversion like this can be done using the more complicated method ofNeary and Woods.To enable our transformation, we will first add two symbols to the alphabet, s t + and s t + , for a totalof s = t + ¡ , D , or G for s t + or s t + ..Cook 33Now we can transform the Turing machine into a set of tag system rules on an alphabet F of 4 m + ms symbols: F = ( H y i , L y i , R y i , R y i ∗ for each i ∈ { . . . m } H y i s j , L y i s j , R y i s j for each i ∈ { . . . m } and j ∈ { . . . s } ) The tag system rules, one for each symbol in F , are based on ¡ , D , and G as follows: H y i ❀ H y i s H y i s . . . H y i s s L y i ❀ L y i s L y i s . . . L y i s s R y i ❀ R y i s R y i s . . . R y i s s R y i ∗ ❀ [ R y i ] s H y i s j | D ( y i , s j )= left ❀ [ R G ( y i , s j ) ∗ ] s ( s − ¡ ( y i , s j )) [ H G ( y i , s j ) ] j H y i s j | D ( y i , s j )= right ❀ [ H G ( y i , s j ) ] j [ L G ( y i , s j ) ] s ( s − ¡ ( y i , s j )) H y i s j | D ( y i , s j )= halt ❀ /0 H y i s t + ❀ [ H y i ] t + + s − a [ L y i ] s w + (cid:229) wk = ( s − a k ) s k − H y i s t + ❀ [ R y i ∗ ] (cid:229) zk = ( s − e k ) s k − [ H y i ] t + + s − e L y i s j | D ( y i , s j )= left ❀ L G ( y i , s j ) L y i s j | D ( y i , s j )= right ❀ [ L G ( y i , s j ) ] s L y i s j | D ( y i , s j )= halt ❀ /0 L y i s t + t + ❀ [ L y i ] s R y i s j | D ( y i , s j )= left ❀ [ R G ( y i , s j ) ] s R y i s j | D ( y i , s j )= right ❀ R G ( y i , s j ) R y i s j | D ( y i , s j )= halt ❀ /0 R y i s t + t + ❀ [ R y i ] s The notation [ symbol ] n represents n consecutive copies of the symbol. Each symbol whose subscript isa pair ( y i , s j ) that causes the Turing machine to halt leads to an empty right hand side, denoted by /0. Ifthe Turing machine does not halt, these empty right hand sides will never be used.Additionally, we transform the Turing machine tape into the following tag system tape: [ H y g ] + s − c [ L y g ] s x + + (cid:229) xk = ( s − b k ) s k [ R y g ] (cid:229) yk = ( s − d k ) s k This completes our transformation of the Turing machine into a tag system with deletion number s .If for some reason one wants to to avoid tag system rules that are exponentially long (in the lengthof the Turing machine’s tape’s periodicity), then instead of using one new symbol at the end of the tapeto extend the tape by another period, one can use many new symbols, each of which extends the tape bya limited amount. Similarly, if one wants to avoid an initial tag system tape that is exponentially long(in the length of the initial Turing machine tape), new states can be added to the Turing machine forthe sole purpose of writing the initial tape and positioning the Turing machine on it. Using these twomethods, the entire compilation algorithm in this section takes only polynomial time in the size of theTuring machine’s initial configuration, and creates a Rule 110 initial state of polynomial size.4 AConcrete ViewofRule 110 Computation Our next transformation will be to convert the tag system tape and rules into a tape and cyclic appendantsequence for a cyclic tag system.Cyclic tag systems were invented as part of the proof of Rule 110’s universality, but they are alsointeresting in their own right. For example, Neary and Woods introduced their method in [2] by showinghow a cyclic tag system can emulate a Turing machine. They simply cycle through a list of appendantsas they read the tape, appending the current appendant to the end of the tape whenever a Y is read.To begin this transformation, we assign an ordering to the tag system alphabet F : f = H y , f = H y , . . . , f m + ms = R y m s s Next, we extend F so that its size | F | becomes a multiple of 6, by addinganywhere from 0 to 5 dummy rules to the tag system, of the form: f m + ms + ❀ /0 , f m + ms + ❀ /0 , . . . Now we can create the cyclic tag system by listing the tag system’s rules in order, and convertingeach right hand side into a string of Y s and N s via a simple unary encoding where each f i becomes astring of | F | N s with the i th one changed to a Y : f i [ N ] i − Y [ N ] | F |− i So for example the first rule, H y ❀ H y s H y s . . . H y s s can be rewritten using the f i s as f ❀ f m + f m + . . . f m + s whose right hand side gets converted to N m Y N | F |− m − N m + Y N | F |− m − . . . N m + s − Y N | F |− m − s which happens to simplify to N m Y [ N | F | Y ] s − N | F |− m − s and so this is the first appendant in the cyclic tag system’s cyclic list.The cyclic tag system’s cyclic list starts with the | F | appendants that can be generated in this wayfrom the rules of the tag system, and then it is extended to a length of s | F | by simply adding ( s − ) | F | empty appendants.The initial tape for the cyclic tag system is simply the unary encoding of the tag system’s tape into Y sand N s. This completes our conversion of the tag system into a cyclic tag system with s | F | appendants. Our final transformation will be to convert the cyclic tag system’s tape and appendants into an initialstate for Rule 110. We will do this by simply gluing together bit sequences for the various glider clustersinvolved. We will start with the central tape region, and then we will specify the periodic sequences toits right and left.We will start the central bit sequence with the row marked in figure 1, block C . We will first extendthis row to the right by attaching other blocks. Each time we attach another block, we do it so that thezig-zag seam fits together perfectly, as if the two blocks were pieces of a large simple jigsaw puzzle,without worrying about whether the top or bottom edges of the blocks are aligned. Usually, the newblock will not be able to be at exactly the same height as the previous block, but we simply need to makesure that the new block extends the t = C . This row will be the initial state forRule 110. Programmatically, “attaching the blocks” is a very simple process: As we extend the initialstate, we just keep track of which phase of the zig-zag the t = N becomes ED ,and each Y becomes FD , but then the very last D is changed to G , and C is stuck on the front. So forexample, a tape of NNY N would become
CEDEDFDEG .Next, we form the periodic right hand side with a periodic sequence of blocks based on the cyclictag system’s appendants. Each appendant from the cyclic tag system’s list is converted by changing each Y to II and each N to IJ , but then the very first I is replaced with KH . If there is no first I , due to.Cook 35 A BC t = 0 DEFG
Figure 1: Blocks of bits used in generating the initial state for Rule 110. Two blocks are joined by simplyfitting them together along the zig-zag edge so that the t = C , gets extended intothe new block. Each block except for C is periodic: Blocks A and B repeat every 3 lines, and the otherblocks repeat every 30 lines. The cyclic left hand side of Rule 110’s initial state is built with blocks A and B . The central region is built with blocks C - G .6 AConcrete ViewofRule 110 Computation HIJKL
Figure 2: More blocks of bits used in generating the initial state for Rule 110. The blocks in this figureare used to create the cyclic right hand side of Rule 110’s initial state based on the cyclic tag system’sappendant list. A program for creating the Rule 110 initial state would just store 30 strings of bits foreach block, along with the vertical phase offset of the right hand zig-zag from the left hand one. Notethat there is an ¯ E glider traveling right in the middle of every zig-zag region, so two blocks always joinat an ¯ E ..Cook 37the appendant being empty, then an L is used for that appendant. Once this is done for all appendants,the initial K of the first appendant is moved to the very end. So for example, the cyclic appendant list { Y N , NYY N , /0 , /0 } would become HIIJKHJIIIIIJLLK . This sequence of blocks gets repeated on theright hand side, and so the bit sequence for the t = [ A ] v B [ A ] B [ A ] B [ A ] B where v = · (the total number of Y s in all appendants) + · (the total number of N s in all appendants) + · (the number of nonempty appendants) + · (the number of empty appendants)Calculating the periodic sequence of bits for the t = t = C , crossingover from block C to block B , then twelve copies of block A , and so on. The bit sequence will have togo through the [ A ] v B [ A ] B [ A ] B [ A ] B block sequence three times before it starts repeating.This completes our algorithm for transforming an arbitrary Turing machine into an initial state forRule 110 consisting of a periodic sequence of bits on the left, followed by a central sequence, followedby a periodic sequence on the right. The blocks in figures 1 and 2 correspond to the conceptual clusters of gliders used in the constructionin [1].For example, the
B A B A B A B assembly is an ossifier , containing an A in each B , separatedby pure ether in the A s.The E block, including the ¯ E s at its seams, is a moving data N , while the F block is a moving data Y .The D block glues adjacent elements of moving data together.The remaining blocks each contain a glider cluster, extending from the first fully present glider to the¯ E in the right seam, so only the ¯ E in the left seam is not a member of the cluster. The ¯ E in the left seamis simply the last ¯ E of the previous cluster, thus providing the position of the block’s cluster in relationto the previous cluster.The H is a primary component , while I and J are standard components , differing only in the spacingfrom the previous component. The J uses more space, so that IJ encodes an N of table data , while II encodes a Y of table data .The K block is a raw leader , and the L block is a raw short leader . The G block is a preparedleader . There is no block shown for a prepared short leader , since our algorithm assumed that the firstappendant would not be empty. If the first appendant is empty, we would need a block for a preparedshort leader, to be used in place of the G . This block would be a modified form of L using exactly thesame modification that turned the K into the G .The calculation of v for the periodic left hand side corresponds to a conservatively large rough esti-mate of twice the total vertical height of all the table data, including both components and leaders. Thisis used to set the vertical spacing between ossifiers so that ossifiers do not hit tape data by mistake. Thisassumes that at least one nonempty appendant will be appended on each cycle through the appendantsif the system is not halting. This will indeed be the case if the system has been compiled from a Turingmachine as described above, since the transformation to a tag system specifically ensures this property.If the system was compiled directly from a tag system or cyclic tag system, then an appropriate value of v v increases linearlywith each ossifier, since the length of the tape can only increase linearly with time, and clearly at anytime the length of the tape constitutes a bound on the number of consecutively rejectable symbols. Notethat if the entire tape is rejected before the next ossifier arrives, then there will be a collision between aprepared leader and an ossifier, as opposed to an ossifier hitting tape data as in figure 12(z).The reader has probably noticed that we are encoding the tape as moving data. Although it might bemore natural to encode it as tape data as described in [1], encoding it as moving data gives us some nicecomputational simplifications: Only two slopes of glider appear in the initial Rule 110 state, each glideronly needs to be positioned relative to its immediate neighbors, and the moving data does not need to bereversed from the cyclic tag system tape.The algorithm forced the tag system to have a size that is a multiple of six so that every appendant inthe cyclic tag system would have a length that is a multiple of six. This is required so that the leader aftera rejected appendant will hit the next symbol of tape data correctly (requiring the rejected appendant tohave even length, as shown in figure 11(y)), producing invisibles that indeed pass through the ossifiers(requiring the rejected appendant to have length a multiple of three, as shown in figure 8(o)).A cyclic tag system appendant in this construction may have a length that is not a multiple of sixonly if the cyclic tag system will always append that appendant. Otherwise the construction will notwork properly. The safest approach is clearly to always use appendants whose length is a multiple of six. We can continue with our series of conversions by converting the Rule 110 initial condition back into aninitial state for a Turing machine tape. The benefit obtained from this big cycle of conversions is thatthe final Turing machine can be very small, since it only has to emulate Rule 110. The program, on theother hand, will have become much larger after going through the extensive compilation process in thiscycle of conversions. Here we will show some Turing machines that can emulate Rule 110, and give anexample for each of how it would emulate the evolution of the standard ether pattern. Encoding the Rule110 inital state into an initial tape for these Turing machines is fairly direct and we will not discuss thedetails of these transformations.Figures 3 and 4 show the lookup tables for the Turing machines of [1]. The captions give examples ofinitial tapes that allow the Turing machines to implement Rule 110 logic. Each machine emulates Rule110 by sweeping back and forth over an ever wider stretch of tape, with each rightward sweep computingone more step of Rule 110’s activity.More detailed initial tapes can be used to make the machines perform more detailed Rule 110 com-putations, for example by inserting gliders into a central ether region, or including gliders in the periodicportion. Note that the periodic patterns on the sides of the Turing machine’s tape correspond to periodicpaths through both space and time on the sides of the Rule 110 evolution.In contrast with the Turing machine of figure 3, the other three machines operate in such a way thatthe Rule 110 rows shift one cell to the right on the Turing machine tape with each simulated time step.More recently, Neary and Woods [7] have achieved even smaller Turing machines that similarlyemulate Rule 110..Cook 390 1 0 = S ( , S , L ) ( = , S , L ) ( , S , R ) ( , S , R ) ( , S , R ) S ( = , S , L ) ( , S , L ) X ( , S , R ) ( , S , R ) Figure 3: This 2 state 5 symbol Turing machine can be started in state S on the two-way infinite tape [ ] ¥ [ = = ] ¥ , starting on the cell marked here with a box, and it will start computing Rule110’s ether pattern. This Turing machine is slightly modified from the one in [1] so that fewer transitionsare needed (the unused one is marked with “ X ”). R R L L S x ( L , S x , R ) ( L , S , R ) ( R , S x , L ) ( R , S x , L ) S ( L , S x , R ) ( L , S , R ) X XS ( L , S x , R ) ( L , S , R ) X X BS x ( , S x , R ) ( , S , R ) ( , S B , L ) S ( , S x , R ) ( , S , R ) XS ( , S x , R ) ( , S , R ) XS B ( , S B , L ) ( , S B , L ) ( , S x , R ) S x ( , T x , R ) ( , T , R ) S ( , T x , R ) ( , T , R ) S ( , T x , R ) ( , T , R ) S L ( , T x , L ) ( , T x , L ) T x ( , S x , R ) ( , S L , L ) T ( , S , R ) XT ( , S , R ) X Figure 4: The 3 state 4 symbol Turing machine can be started in state S x on the tape [ L L R ] ¥ L [ L L R R L ] ¥ to compute the ether pattern. The 4 state 3 symbol Turing machine canbe started in state S x on the tape [ B ] ¥ B [ B B ] ¥ to compute the ether pattern. The 7 state2 symbol Turing machine can be started in state S on the tape [ ] ¥ [ ] ¥ , and it willcompute the ether pattern on every second cell of the tape. This machine was compressed down to sevenstates by David Eppstein [8].0 AConcrete ViewofRule 110 Computation The original exposition of the Rule 110 construction in [1] took a motivated approach to understandinghow the construction could be made to work, by showing how some parts of the construction placedrequirements on other parts of the construction, and then showing how the other parts had enough flexi-bility to satisfy those requirements. Only the inner workings of the components and leaders were treatedas given without analysis. Of course, those could have been explained as well, as they were similarly de-signed by examining how to satisfy the relevant constraints, but this would have significantly lengthenedthe exposition.In the present paper we take the converse approach, treating the entire construction as handed to usin a completely specified form, as given in section 1, for which all we have to do is check that as Rule110 acts on the initial state, all of the ensuing collisions will be of the right form.Each collision, whether between individual gliders or between clusters of gliders (which can bethought of as very large gliders), is completely determined by the spacing between its parts. In Rule110’s two dimensional space-time, spacings can be completely specified in terms of ⌢ distance (“overdistance”) and ր distance (“up distance”), described in [1].Our general approach is that each time there is a collision, we can determine the spacing between itsparts by examining the spacings among all of the previous collisions bordering the ether region above thecollision in question. If every such region can be shown to lead to the proper collision, then by induction,all the collisions will be correct.All the collisions (at a glider cluster level) in this construction are between ¯ E material (leaders, tabledata, invisibles, moving data) on the right and either C material (tape data) or A material (ossifiers,acceptors, rejectors) on the left.The slopes of the A gliders and C gliders, are directly related to the measurements that we need.When C material hits ¯ E material, the correctness of the collision depends only on the ⌢ distance mod4. When A material hits ¯ E material, the correctness of the collision depends only on the ր distance mod6. The values are only important mod 4 and mod 6 because of the periodicity of the ¯ E .For most of the collisions, some participants in the collision have emerged from crossing collisions.In these cases, we measure the relevant distance back at the point when those gliders were first created,before all the crossing collisions, since the crossing collisions do not affect the relative distances. Onlycollisions with acceptors and rejectors are never preceded by crossing collisions.This construction uses only the following collisions: • ossifiers hitting moving data or invisibles – Measurements of these collisions are shown in figure 6. – The moving data is created with the correct spacing as shown in figure 7. – The invisibles are created with the correct spacing as shown in figure 8. • tape data passing through moving data or invisibles – Measurements of these collisions are shown in figure 5. – The tape data is created with the correct spacing as shown in figure 6(e). – The moving data and invisibles are created with the correct spacing as shown in figure 10. • an element of tape data hitting a prepared leader – Measurements of this collision are shown in figure 11(v). – The prepared leader is created with the correct spacing as shown in figure 11(w,x,y)..Cook 41 • an acceptor or rejector hitting table data – Measurements for these collisions are shown in figure 7. • an acceptor or rejector hitting a raw leader – Measurements for these collisions are shown in figure 9.We avoid an overly formal style in this presentation, but the general approach used here would bea good starting point for a complete formalization of the proof, a formalization of the sort that couldbe checked automatically by an automated proof checker. Most of the simpler spacing claims haveessentially already been checked insofar as simulations of this construction appear to work with noproblems. But of course most of the more general claims that appear cannot be verified in their fullgenerality so trivially.
Variations on the Construction
Other than the A ր ¯ E reaction used for ossification, shown in figure 6(e), there are two other reac-tions between an A and an ¯ E that result in a C . One of them, in which the ¯ E is ր from the A , is clearlyunusable because it does not allow the ossification of figure 6(e) to work, since the ⌢ distance betweenthe new C and the ¯ E is one, not zero. The other, in which the ¯ E is ր from the A , does not have thisproblem. If it were used, then the leaders and primary components would need to have different internalarrangements. It turns out that, regardless of the details of these arrangements, the equation of invisibilityafter rejection, 4 + + ( c − ) · + + + =
0, from figure 8(m,o) and figure 6(g), which containsvalues that derive from nearly every aspect of the construction, would wind up being odd on one side andeven on the other, and so the equation would be violated regardless of the value of c , and the construc-tion would not work, regardless of any restrictions on the lengths of appendants. The construction asoriginally designed in February of 1994 suffered from this problem, which was discovered and fixed inthe ensuing weeks. Note that [5] is mistaken when it says on page 1115 that some mistakes in the proofwere corrected in 1998. In fact, the basic construction, completed in 1994, leaves a lot of flexibility inchoosing many of the spacings (even within the leaders and components, whose internal design is notdiscussed in [1]), and what happened in 1998 was that a particular set of arrangements were chosen (forcompactness) while writing a program to automatically generate a Rule 110 initial state correspondingto an arbitrary cyclic tag system (see [5], page 1116). Finally, in 1999, a standardized set of methods ofmeasurement and analysis were chosen during the writing of the exposition of the 1994 construction, thepublication of which (in [1]) was delayed until after the publication of [5].The astute reader may notice that primary components (as well as short leaders) could be avoided ifthe acceptor and rejector could be produced ր + from where the leader currently produces them. Thereader is invited to attempt this simplification, preferably without increasing the size of the construction. In [2], Neary and Woods solved the geometry problem described here on page 32 by using the followingidea, which we present in a form adapted to tag systems. (Another adaptation to tag systems is given inNeary’s thesis [9].)First of all, note that on a circular tape, it is sufficient for the Turing machine head to always move tothe right. For example, the natural approach to simulating a cellular automaton works in this way: The2 AConcrete ViewofRule 110 Computation ( a ) ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E C C ♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ( b ) C C ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E ♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣ ( c ) ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E C C C C ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ⌢ ( d ) C C C C C ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ⌢ ⌢ ⌢ ⌢ ♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣ ♣♣♣♣♣ ⌢ ♣♣♣♣♣ ♣♣♣♣♣ ⌢ ♣♣♣♣♣ ?? ?Figure 5: An ¯ E crossing a C . Vertical columns of dots represent the vertical columns of ether trianglesused when measuring ⌢ distance, which we treat as a value mod 4 due to the periodicity of the ¯ E .Sequences of parallel short vertical columns of dots represent the marking of every fourth column ofether triangles for convenience of measurement. (a) Some basic measurements of the unique collision inwhich an ¯ E crosses a C . Note that the three measurements shown logically imply that the regenerated C must be ⌢ from the regenerated ¯ E . (b) Putting together some measurements from (a), we see thattwo consecutive ¯ E s can both cross a C if and only if they are ⌢ from each other. Note that the spacingbetween the ¯ E s will be the same after the collisions as before the collisions, since each ¯ E undergoes anidentical displacement in the collision. (c) Similarly, we see that consecutive C s can both cross an ¯ E ifand only if they are + ⌢ , which is ⌢ , from each other. Note that they will still be ⌢ from each other afterthe collisions, since they each undergo the same displacement. (d) If we align several C s and ¯ E s so thatthe first collisions are crossing collisions, then what will the remaining collisions be? After crossing thefirst ¯ E , the C s are still ⌢ from each other, so the second ¯ E will also cross them all, and indeed, all ofthe ¯ E s will cross all of the C s..Cook 43 ( e ) A ❅❅❅❅❅ C C ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E C ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ( f ) A ❅❅❅❅❅❅ A A ❅❅❅❅❅❅ A ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ( g ) A ❅❅❅❅❅ ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր k ♣♣♣♣♣♣♣♣♣♣♣♣ ? k = C k = ( h ) A ❅❅❅❅❅❅❅❅❅ A ❅❅❅ ¯ E (cid:0)(cid:0)(cid:0) ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) C ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣ ˜ ♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣ ր k ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ˜ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣ ? k = C k = Figure 6: How an ¯ E can hit an A . Vertical columns of dots are as in figure 5. Diagonal rows of dotsrepresent the diagonal rows of ether triangles used when measuring ր distance, which we treat as a valuemod 6 due to the periodicity of the ¯ E . Sequences of parallel short diagonal rows of dots represent themarking of every sixth row of ether triangles for convenience of measurement. (e) There are three waysan ¯ E can hit an A to produce a C , but only one works for the construction. It is the one where the ¯ E is ր from the A . The resulting C is ⌢ from the ¯ E that created it. (f) An ¯ E will cross an A if and onlyif it is ր from the A . The crossing causes a visually striking but irrelevant displacement (not indicatedhere) to the A . The incoming A is ր from the regenerated ¯ E . We see that consecutive A s must be ր from each other if they are both to cross an ¯ E , and the construction always uses such a spacing between A s. Every ¯ E will either pass through all the A s (we call such an ¯ E an “invisible”), or else it is “movingdata” and will be converted (“ossified”) into a C (“tape data”) by the first A (“ossifier”) it hits, as in(e). (g) After an invisible ¯ E , the ր distance to the next ¯ E determines whether it is another invisible orossifiable moving data. (h) After a moving data ¯ E , the ր distance to the next ¯ E determines whether itis more moving data or an invisible.4 AConcrete ViewofRule 110 Computation ( k ) acc ❅❅ ❣❛❞ ❅❅ ❣❛❞ ❅❅ accmd (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) pri/stdmd (cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0) std ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣ ( l ) rej ❅❅ ❣❛❞ ❅❅ ❣❛❞ ❅❅ rej (cid:0)(cid:0) pri/std (cid:0)(cid:0)(cid:0)(cid:0) std ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣ ( i ) td ❣❛❞ ❅❅ ❣❛❞ ❅❅ accinv (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) prepmd (cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0) pri ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣ ( j ) td ❣❛❞ ❅❅ ❣❛❞ ❅❅ rejinv (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) prep (cid:0)(cid:0)(cid:0)(cid:0) pri ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣ Figure 7: Primary ( pri ) and standard ( std ) components will get processed correctly by either an acceptor( acc ) or a rejector ( rej ). An acceptor converts components into moving data ( md ), whereas a rejectordeletes components. The acceptor or rejector is produced by a prepared leader ( prep ) hitting a characterof tape data ( td ), which produces a pair of invisibles ( inv ) as well as the acceptor or rejector. Notethat lines in these diagrams represent clusters of parallel gliders, and the collisions between clusters aremarked with a circle representing the many collisions that occur where the clusters meet. A measurementto or from a cluster is made to or from the closest glider in the cluster, namely the one that touches theether in which the measurement is being made..Cook 45 ( m ) td ❣❛❞❣❛❞ ❅❅ acc/rejinv/md (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) inv/mdinv (cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) prep ♣♣♣♣♣ ˜ ♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣ ր k ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ˜ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣ ( n ) acc ❅❅ ❣❛❞ ❅❅ ❣❛❞ md (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) stdprep (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0) raw ♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր k ♣♣♣♣♣♣♣♣♣ k = ( o ) td ❣❛❞♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ❣❛❞ ❅❅ ❣❛❞ ❅❅❅ ❣❛❞ rejinv (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) prep pri (cid:0)(cid:0)(cid:0) std (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) raw (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) prep ♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ✂✂✂✂✂ ✂✂ | {z } c − ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր k ♣♣♣♣♣♣♣♣♣♣♣♣♣♣ k = Figure 8: Invisibles are the result of a prepared leader hitting an element of tape data. (m)
The alignmentof the invisibles ( k +
5) depends on the alignment ( k ) of the prepared leader. The incoming invisible ormoving data was originally produced as in (o) or (n). (n) When invisibles follow moving data, the leaderwas prepared by an acceptor, and the prepared leader’s offset from the moving data is k =
0. As shown in(m), this gives the invisibles an alignment of k + =
5, which will yield the correct interaction with theossifiers, as shown in figure 6(h). (o)
When invisibles follow previous invisibles, the leader was preparedby a rejector. If c characters of table data were rejected, then k = + + ( c − ) · + = c +
2. Since c is a multiple of 6, we get k =
2. In the special case c =
0, the previous leader was a short leader, andthis figure does not apply, but we still get k = k + =
1, yielding the correct collision with the ossifiers asshown in figure 6(g).6 AConcrete ViewofRule 110 Computation ( p ) acc ❅❅ ❣❛❞ ❅❅ ❣❛❞ md (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) stdprep (cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0) raw ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣ ( q ) rej ❅❅ ❣❛❞ ❅❅ ❣❛❞ (cid:0)(cid:0) stdprep (cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0) raw ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣ ( r ) td ❣❛❞ ❅❅ ❣❛❞ inv (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) shortprepprep (cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0) raw ♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ր k ♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣ ր ♣♣♣♣♣♣♣ ♣♣♣♣ ր ♣♣♣♣♣♣♣♣ k = Figure 9: Raw leaders are placed ր from the previous component, which yields the correct alignmentwhen prepared by either an acceptor (p) or a rejector (q). If there were no previous components, thenthe raw leader is placed ր from the previous short leader (r) (whose lower right gliders are untouchedby the preparation), again yielding the correct alignment for preparation. Raw leaders that come aftershort leaders yield prepared leaders aligned as in (r), with k =
2. This is the zero-component version offigure 8(o). Note that raw short leaders, due to the different position of their initial ¯ E , are always placed ր + higher, as measured through the E n s, than the raw regular leaders shown here..Cook 47 ( s ) td ❣❛❞ ❅❅❅❅ ❣❛❞ ❅❅❅ accinv (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) prepmd (cid:0)(cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) pri ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣ ( u ) acc ❅❅ ❣❛❞ ❅❅❅❅ ❣❛❞ ❅❅❅ accmd (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) pri/stdmd (cid:0)(cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) std ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣ ( t ) tdtd td ❅❅❅❅❅❅ acc/rejprep (cid:0)(cid:0) ❣❛❞ (cid:0)(cid:0)(cid:0)(cid:0) inv ❣❛❞ (cid:0)(cid:0) inv ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣ Figure 10: Moving data and invisibles are created with the correct alignment to pass through tape data.The top collision in (s) is also the top collision in (t), but (t) applies even when a rejector is produced.The lower collision in (s) is also the top collision in (u), but (u) applies also to later components, wherethe lower collision in (u) becomes the top collision in (u). (s)
The first moving data after an invisiblehas correct alignment to pass through tape data, as in figure 5(b). (t)
An invisible always has correctalignment to pass through tape data, as in figure 5(a,c). (u)
Moving data after previous moving data isalso aligned correctly for passing through tape data, as in figure 5(b).8 AConcrete ViewofRule 110 Computation ( v ) td ❣❛❞❣❛❞ ❅❅ acc/rej ¯ E (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) ¯ E prep (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) inv ♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣ ( w ) td ❣❛❞ ❅❅❅ ❣❛❞ shortprep (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) inv raw (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) prep ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣ ( x ) acc ❅❅ ❣❛❞ ❅❅❅ ❣❛❞ std (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) md raw (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) prep ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣ ( y ) td ❣❛❞ ❅❅ ❣❛❞ ❅❅ ❣❛❞ ❅❅❅ ❣❛❞ rejinv (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) (cid:0)(cid:0) prep pri (cid:0)(cid:0)(cid:0)(cid:0)(cid:0) std (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) prep (cid:0)(cid:0) (cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0)(cid:0) raw ♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣♣♣♣♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣ ♣♣♣♣♣♣♣♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣ ≀ ♣♣♣♣♣♣ ⌢ ♣♣♣♣♣♣♣♣♣♣ ✂✂✂✂ ✂✂ | {z } c − c is a multiple of 6, the total ⌢ distance mod 4 is1 + + + ( c − ) · ( + ) + = c + =
1, as needed in (v)..Cook 49 ( z ) A ❅❅❅❅ A ❅❅❅❅❅❅❅❅ AA ❅❅ A ❅❅❅❅ AC (cid:0)(cid:0) ¯ EC (cid:0)(cid:0) ¯ EC C C ✄✄✄ F C C C C Figure 12: An F is produced if and only if the Turing machine halts. The tag system in section 1 is setup so that when the Turing machine halts, no more appendants are produced for the tape. This will causeossifier A s to eventually hit a character of tape data, which leads to the production of an F as shown.Turing machine can store the local configuration of the tape in its finite state, and can read in the oldconfiguration and write out the new configuration in a single pass. Extra cells can be written onto thetape at the wrap-around point as necessary, allowing it to grow.So, when the simulated Turing machine head is at a certain position on the tag system tape, what wewould like to do is to find the next position on the tape to the right of the current position. The tag systemcan do this not in a single pass, but in a series of log( n ) cycles, where each cycle consists of four passes.On the first cycle, it eliminates every second possibility. On the next cycle, it eliminates every secondremaining possibility, and so on. After log( n ) cycles, the only remaining possibility is the first one: thenext position on the tape.So that the system can know when log( n ) cycles have occurred, it keeps on its tape a power of 2 thatis larger than n , called the counter. It performs this same halving-of-possibilities process on the counter,where it is able to detect the end of the process since then for the first time there will be an odd numberof possibilities remaining.When the tape grows in length past a power of two, then the counter must be doubled in size. Thiscondition is detected by keeping track of a “growth flag” which is set at the beginning of each series ofcycles, and then if the tape is ever noticed to have a non-power-of-two length, then the flag is reset. Ifthe flag is still set at the end of the series of cycles, and the tape is being extended, then the counter sizeis doubled.In tag systems, one must take care that the counter behaves properly when the Turing machine “head”jumps across it, since then the counter gets processed twice before the tag system head is at the beginningof the tape again.In the tag system, we keep all sorts of information in the symbols, using a large alphabet, since thecommunication bandwidth between symbols is very low (a single bit or less per pass). For example,every symbol on the tape knows the current state of the Turing machine and the current stage of thesimulation algorithm. We use six stages, and each stage does one pass over the tape.0 AConcrete ViewofRule 110 ComputationWe will use the following symbols: • For the head: H, h, P, QP is used for a head remembering “A”, Q for “B”. • For the counter: U u X x V v Y yX is an eliminated U, and V and Y are a form of U and X that represent the growth flag havingbeen reset. • For the tape: A a B b C c D dA and B represent the two values used on the binary Turing machine tape. C and D are theeliminated forms of A and B.The lower-case letters are used when we need to be able to detect which of the two positions is beingread or ignored.If the Turing machine has k states, then there are actually 6 k symbols for each of the above symbols.We could write these for example as H , being the H symbol that is used in stage 4 when the Turingmachine is in state 7, but usually we will omit the indices, to avoid clutter. Not all of the 6k symbols areused, since not all of the letters are used in all stages.For clarity, we will also use “-” as a symbol, to be used in positions where we know it will not beread, and we will use “0” as a symbol with an empty appendant. These two symbols do not need anysubscripts. Stages
There is a cycle of four stages, with stage 4 going back to stage 1 until the first tape symbol has beenisolated, at which point stage 4 goes on to stage 5 and then 6. Stage 6 performs the simulation of a stepof the Turing machine and jumps back to stage 3 to start isolating the next tape symbol.We will start in stage 2, because it has the simplest form. At the front is Hh, then the tape is somecombination of AA and BB, and somewhere there is a power of 2 of Uu’s, at least as long as the A/Bportion of the tape.We will explain the stages by following an example.
Stage 2
Example: H h A A U u U u U u U u B B A A (Turing machine tape is “A,B,A”)Incoming parity: If reading second symbol of each pair, then the growth flag is unset.Outgoing parity: Start with first symbol of each pair.Main change: Cut number of U’s in half, and check whether counter size should be doubled.Transfer to stage 3:
H * : H -h * : - H -A * : A AB * : B BC * : C CD * : D DU * : Uu * : VX * : X X .Cook 51 x * : Y YV * : VY * : Y Y
Stage 3
Example: H - A A U U U U B B A AIncoming parity: Start with first symbol of each pair.Outgoing parity: If reading second symbols, then there was just one U.Main change: Change odd U’s (first, third, etc.) to UuXx, erase even U’s.Transfer to stage 4:
H * : H hA * : A aB * : B bC * : C cD * : D dU * : U u X xV * : V v Y yX * : X xY * : Y y
Stage 4
Example: H h A a U u X x U u X x B b A aIncoming parity: If reading small letters, then first tape symbol is isolated, and we will go on to stage 5.Otherwise we go back to stage 1.Outgoing parity: Start with the first symbol of each pair.Main change to stage 1: Change A to Aa0, and B to Bb0.Transfer to stage 1:
H * : H -A * : A a 0B * : B b 0C * : C CD * : D DU * : U UV * : V VX * : X XY * : Y Y
Stage 1
Example: H - A a 0 U U X X U U X X B b 0 A a 0Incoming parity: We read the H.Outgoing parity: If there were an even (resp. odd) number of A’s and B’s, then we will read the first(resp. second) symbol of each pair.2 AConcrete ViewofRule 110 ComputationMain change: Every second A or B is turned into a C or D.Transfer to stage 2:
H * : H hA * : A Aa * : C CB * : B Bb * : D DC * : C CD * : D DU * : U uV * : V VX * : X xY * : Y Y
Stage 2
Example: H h A A U u X x U u X x D D A A (read h)
Stage 3
Example: - H - A A V Y Y V Y Y D D A A (read H)
Stage 4
Example: H h A a V v Y y Y y Y y D d A a (read H)
Stage 1
Example: H - A a 0 V V Y Y Y Y Y Y D D A a 0 (read H)
Stage 2
Example: H h A A V V Y Y Y Y Y Y D D C C (read H)
Stage 3
Example: H - A A V Y Y Y Y Y Y D D C C (read H)
Stage 4
Example: H h A a V v Y y Y y Y y Y y D d C c (read h)Main change to stage 5: H and U disappear. Isolated A/B becomes P/Q. C/D turn back into A/B. X/Ybecomes a mixed-stage form UX/VY. The “head” has jumped from the H to the P/Q, so it has jumpedonto the symbol it is reading. This may cause it to jump over the counter (the X’s/Y’s), which will bediscussed below.Transfer to stage 5:.Cook 53 h * :a * : - P -b * : - Q -c * : A -d * : B -u * :v * :x * : U xy * : V y
Note regarding the transfer: The x and y symbols are written with a stage 4 subscript!
Stage 5
Example: - P - V y V y V y V y B - A - (read P)Incoming parity: We read the P or Q.Outgoing parity: Read first symbols if P, read second symbols if Q.Main change: x and y “stage 4” symbols disappear (more on them below), and parity is set to reflect Pvs. Q.Transfer to stage 6:
P * : P -Q * : QA * : A aB * : B bU * : U uV * : V v
Stage 6
Example: P - V v V v V v V v B b A a (read P)Incoming parity: If P at front, will read first of each pair. If Q at front, will read second of each pair.Outgoing parity: Will read first of each pair.Main change: A step of the Turing machine is simulated. The state (invisible subscript) changes. Thenew symbols get written onto the tape. V’s turn back into U’s (i.e. the growth flag is reset). The countersize (number of U’s) doubles if necessary. The counter size is also halved for direct entry to stage 3.Transfer to stage 3:
P * : [A a B b] H -Q * : [A a B b] - H -A * : A A (new state when reading an A)a * : A A (new state when reading a B)B * : B B (new state when reading an A)b * : B B (new state when reading a B)U * : U [U] (new state when reading an A)u * : U [U] (new state when reading a B)V * : U (new state when reading an A)v * : U (new state when reading a B)
Stage 3
Example: H - U U U U B B A A B B B B
Stage 4
Example: H h U u X x U u X x B b A a B b B b
Stage 1
Example: H - U U X X U U X X B b 0 A a 0 B b 0 B b 0
Stage 2
Example: H h U u X x U u X x B B C C B B D D
Stage 3
Example: H - U X X U X X B B C C B B D D
Stage 4
Example: H h U u X x X x X x B b C c B b D d
Stage 1
Example: H - U U X X X X X X B b 0 C C B b 0 D D
Stage 2
Example: H h U u X x X x X x B B C C D D D D
Stage 3
Example: H - U X X X X X X B B C C D D D D
Stage 4
Example: H h U u X x X x X x X x B b C c D d D d (read h)Now we will see what the mixed-stage stuff is doing, where the stage-4 “x” turns into a “U x” pairwith the U in stage 5 but the x in stage 4. Recall that h and u both disappear..Cook 55
Stage 4.5
Example: U x U x U x U x - Q - A - B - B - (read x)Now we see that that the stage-5 U’s will get ignored as stage 4 finishes by processing the counter asecond time.
Stage 5
Example: - Q - A - B - B - U x U x U x U xAnd we see that this time the stage-4 x’s will get ignored during the stage-5 processing. Stage 5doesn’t do much because it is mostly serving as a signal to the counter regarding what stage is happening.The counter knows it is still stage 4 while the second symbols are getting read, and the counter knowsstage 5 has arrived when the first symbols get read. So stage 5 has to have a fixed parity during itsprocessing, making it a boring stage.
Stage 6
Example: Q A a B b B b U u U u U u U uAnd so on... The counter will double in size on the next step if necessary. It works well in simulation.As mentioned in [10], the fact that tag systems can compute efficiently means that all known smalluniversal Turing machines work in polynomial time.
References [1] M. Cook, Universality in elementary cellular automata, Complex Systems 15 (1) (2004) 1–40.[2] T. Neary, D. Woods, P-completeness of cellular automaton rule 110, Lecture Notes in Computer Science 4051(2006) 132–143. URL