+ All Categories
Home > Documents > Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email:...

Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email:...

Date post: 13-Jul-2020
Category:
Upload: others
View: 0 times
Download: 0 times
Share this document with a friend
47
Reproducing the cyclic tag system developed by Matthew Cook with Rule 110 using the phases f i 1 Genaro J. Mart´ ınez 1 , Harold V. McIntosh 2 , Juan C. Seck Tuoh Mora 3 , and Sergio V. Chapa Vergara 4 1 Faculty of Computing, Engineering and Mathematical Sciences, University of the West of England, Bristol, United Kingdom. http://uncomp.uwe.ac.uk/genaro/ Email: [email protected] 2 Departamento de Aplicaci´ on de Microcomputadoras, Instituto de Ciencias, Universidad Aut´ onoma de Puebla, Puebla, M´ exico. http://delta.cs.cinvestav.mx/ mcintosh/ Email: [email protected] 3 Centro de Investigaci´ on Avanzada en Ingenier´ ıa Industrial, Universidad Aut´ onoma del Estado de Hidalgo Pachuca, Hidalgo, M´ exico. Email: [email protected] 4 Departamento de Computaci´ on, Centro de Investigaci´ on y de Estudios Avanzados del Instituto Polit´ ecnico Nacional, M´ exico. Email: [email protected] Abstract. This paper implements the cyclic tag system (CTS) in Rule 110 developed by Cook in [1, 2] using regular expres- sions denominated phases fi 1 [3]. The main problem in CTS is coding the initial condition based in a system of gliders. In this way, we develop a method to control the periodic phases of the strings representing all gliders until now known in Rule 110, including glider guns. These strings form a subset of regular expressions implemented in a computational system to facili- tate the construction of CTS. Thus, these phases are useful to establish distances and positions for every glider and then to de- lineate more sophisticated components or packages of gliders. In this manuscript, it is possible to find differences with the results exposed in Wolfram’s book [2], inclusively some mistakes which avoid to obtain an appropriated realization of CTS in Rule 110; fortunately, these irregularities were discussed and clarified by Cook. 5 5 M. Cook November 2002, personal communication.
Transcript
Page 1: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Reproducing the cyclic tag system

developed by Matthew Cook with

Rule 110 using the phases fi 1

Genaro J. Martınez1, Harold V. McIntosh2,Juan C. Seck Tuoh Mora3, and Sergio V. Chapa Vergara4

1 Faculty of Computing, Engineering and Mathematical Sciences, Universityof the West of England, Bristol, United Kingdom.

http://uncomp.uwe.ac.uk/genaro/

Email: [email protected] Departamento de Aplicacion de Microcomputadoras, Instituto de Ciencias,

Universidad Autonoma de Puebla, Puebla, Mexico.http://delta.cs.cinvestav.mx/∼mcintosh/

Email: [email protected] Centro de Investigacion Avanzada en Ingenierıa Industrial, Universidad

Autonoma del Estado de Hidalgo Pachuca, Hidalgo, Mexico.Email: [email protected]

4 Departamento de Computacion, Centro de Investigacion y de EstudiosAvanzados del Instituto Politecnico Nacional, Mexico.

Email: [email protected]

Abstract. This paper implements the cyclic tag system (CTS)in Rule 110 developed by Cook in [1, 2] using regular expres-sions denominated phases fi 1 [3]. The main problem in CTSis coding the initial condition based in a system of gliders. Inthis way, we develop a method to control the periodic phases ofthe strings representing all gliders until now known in Rule 110,including glider guns. These strings form a subset of regularexpressions implemented in a computational system to facili-tate the construction of CTS. Thus, these phases are useful toestablish distances and positions for every glider and then to de-lineate more sophisticated components or packages of gliders. Inthis manuscript, it is possible to find differences with the resultsexposed in Wolfram’s book [2], inclusively some mistakes whichavoid to obtain an appropriated realization of CTS in Rule 110;fortunately, these irregularities were discussed and clarified byCook.5

5 M. Cook November 2002, personal communication.

Page 2: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Keywords: Rule 110, cyclic tag system, gliders, phases andcollisions

1 Introduction

The cellular automaton (CA) Rule 110 has received special attentionby the results exposed by Cook in [4]. This work gives a list and abrief introduction about the complex activity of gliders, including theexistence of a glider gun; discussing as well some similarities between theGame of Life (GoL) [5]6 and Rule 110, suggesting to call it as LeftLife.

Some historical facts in the research of Rule 110 are as follows: thisCA evolves in one dimension with two states as alphabet, where the lo-cal function takes just three elements (left-centre-right) to determine theevolution over time. One of the first investigations about Rule 110 wasdescribed by Wolfram [6], discovering that Rule 110 displays complexbehaviors by means of the existence of gliders – a glider is a periodicstructure moving into the evolution space – from random initial con-ditions. Thus Wolfram establishes the conjecture that this rule couldperform universal computation.

Lind presents the first classification of gliders in Rule 110 in [6] with13 gliders.7 Next the first paper dedicated to the analysis of Rule 110is made by Li and Nordahl in [7], where a statistical study and some ofthe most common behaviors of Rule 110 are considered.

In 1998 a conference at the Santa Fe Institute takes place whereCook explains how Rule 110 is able to be universal; this talk is originallyplanned to be published in “New Constructions in Cellular Automata”[8, 38]. On the other hand, another perspective is reported by McIntoshin [9], analyzing Rule 110 as a problem of tiles and applying de Bruijndiagrams for characterizing every glider.

In this way, in March 2002 Wolfram presents his book “A New Kindof Science” [2]. The book explains in several pages the features of thegliders and the functionality of a CTS to demonstrate that Rule 110 isan elemental universal CA. But one limitation in this work is that it doesnot show a way to reproduce the result without the use of a proprietarysoftware.

In this sense, on trying to reproduce the operation of the CTS, ithas been found that the information proportioned in [2] is both incom-plete and insufficient. Also there are mistakes in some of their elements

6 http://www.pentadecathlon.com/7 Appendix, table 15. Also available in http://www.stephenwolfram.com/

publications/articles/ca/86-caappendix/16/text.html

Page 3: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

and others do not have the necessary components to produce a goodfunctionality.

With this background, the aim of this paper is to present a generalintroduction to Rule 110, its system of gliders and their relation withtiles, the existence of phases expressed by regular expressions via deBruijn diagrams and the CTS, all together to form a general context.Finally, we discuss and illustrate a detailed coding for the more relevantstages of the machine working into the evolution space of Rule 110.

2 Rule 110

Rule 110 is the binary local function of a CA in a one-dimensional order(k = 2, r = 1) in Wolfram’s nomenclature [6], where k represent thecardinality of the set of states and r the number of neighbors to the leftand right with regard of a central cell. In one dimension we have a finitearray of cells with periodic boundary properties, where the first and lastcells are concatenated to preserve symmetries into the evolution space.Then every configuration is an instance of each array and it is updatedapplying the local function simultaneously over all the neighborhoods togenerate the next configuration. The local function ϕ is defined in Table1.

Table 1. Local function for Rule 110 - (01110110)2.

ϕ(1, 1, 1) → 0 ϕ(0, 1, 1) → 1ϕ(1, 1, 0) → 1 ϕ(0, 1, 0) → 1ϕ(1, 0, 1) → 1 ϕ(0, 0, 1) → 1ϕ(1, 0, 0) → 0 ϕ(0, 0, 0) → 0

Figure 1 shows a typical evolution of Rule 110 generated from arandom initial condition. The evolution diagram starts from an initialcondition of 761 cells with a density of 53% in state one, time advancesup-down in 349 generations.

Figure 1 shows a typical environment produced by Rule 110. We cannote a uniform compound state or periodic background marked withother colors called “ether” by Cook [4]. This ether is a difference fromthe two-dimensional Conway’s GoL CA, which has a fixed background.Also, other periodic regions are identified by structures moving throughthe evolution space without changing their form, they are better knownas “gliders.” This word was originally adopted in GoL [5]. The chaoticregions are produced from the initial configuration appearing for some

Page 4: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 1. Typical random evolution in Rule 110.

time, in other cases they are yielded by collisions among gliders. Thuswe can look a non-trivial behavior in Rule 110.

An interesting point is that we can produce each glider from simpleor multiple collisions of other gliders as it is presented in [10, 11]. Somecollisions include complicated extensions or package of them. Now weshall characterize every glider or periodic pattern into the evolution spaceof Rule 110.

2.1 System of gliders

An extended description of gliders may be consulted in [9, 11, 12].8 Thissection displays general properties and illustrative examples using theclassification exposed by Cook [1].

Gliders in Rule 110 has a wide variety of kinds, extensions and com-binations. We can handle groups or packages of them in one or severalphases; thus notation nA means n copies of the A glider and not a pack-age of An gliders. Figure 2 lists all known gliders so far both in theirbasic representation and in packages or extensions as well.

These gliders have important characteristic useful to define distances,slopes, speeds, periods, collisions, and phases [3, 12, 11].

Table 2 summarizes some of the most relevant properties, columnstructure gives the name of each glider including two more structures: er

and el which represent the slopes of ether pattern. The next four columns

8 The next web site has several examples where one can see large pictures ofsingle or packages of gliders. http://uncomp.uwe.ac.uk/genaro/rule110/glidersRule110.html

Page 5: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

gun gun�

gun�

D� �D�D� �D� E �E E�E

��E � �E F �F G �G G

�G

�H �H

A �A A�

B �B �B � �B �B�

�B�

�B � �B �B�

�B� C� �C� C� �C� C� �C�A

Fig. 2. System of gliders in Rule 110.

labeled margins indicate the number of periodic margins in each glider.The margins are partitioned in two types with even values ‘ems’ and oddvalues ‘oms’ which are distributed as well in two groups: left and rightmargins, because every glider has even and odd number of margins intheir left or right borders (or superior and inferior ones). Particularly,the margin properties are very related to their analysis based on tilesand phases [3, 11]

Column vg indicates the speed of each glider, where g belongs to aglider of the set of gliders G. Speed is calculated dividing the displace-ment of d cells between its period p. The three types of trajectories arealso indicated in this column, this way we have three different basicspeeds. First there is a positive speed indicating a shift to the right. Sec-ond there is a negative speed with a shift to the left and the last one isa zero speed because in this particular case the differences between thefirst and the second speed avoid a shift.

The speed of gliders allows to control distances to get desired reac-tions. In general, larger gliders imply slower shifts; and any glider cannotbe faster than ver

or velin their positive or negative speed respectively.

Column lineal volume describes the minimum and maximum numberof necessary cells for determining the corresponding glider or another

Page 6: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Table 2. Properties of each glider in Rule 110.

marginsstructure left - right vg lineal

ems oms ems oms volume

er . 1 . 1 2/3 ≈ 0.666666 14

el 1 . 1 . -1/2 = -0.5 14

A . 1 . 1 2/3 ≈ 0.666666 6

B 1 . 1 . -2/4 = -0.5 8

Bn 3 . 3 . -6/12 = -0.5 22

Bn 3 . 3 . -6/12 = -0.5 39

C1 1 1 1 1 0/7 = 0 9-23

C2 1 1 1 1 0/7 = 0 17

C3 1 1 1 1 0/7 = 0 11

D1 1 2 1 2 2/10 = 0.2 11-25

D2 1 2 1 2 2/10 = 0.2 19

En 3 1 3 1 -4/15 ≈ -0.266666 19

E 6 2 6 2 -8/30 ≈ -0.266666 21

F 6 4 6 4 -4/36 ≈ -0.111111 15-29

Gn 9 2 9 2 -14/42 ≈ -0.333333 24-38

H 17 8 17 8 -18/92 ≈ -0.195652 39-53

glider gun 15 5 15 5 -20/77 ≈ -0.259740 27-55

periodic structure. For example, C1 has two values expressing that nineor twenty-three cells are needed to represent this glider.

2.2 Subset of tiles

A notorious property in Rule 110 is given by the local function ϕ whichcovers the evolution space in a two-dimensional representation with tilesor triangles of different sizes [13, 9]. A tile is described by Tn wheren ∈ N indicates the size of each triangle. State 0 defines the interior ofthe triangles and state 1 determines the perimeter. These triangles areclassified in two sets α and β for n > 1. Figure 3 shows some of them inascendent numeration, forming two subsets of countable families, suchthat |{Tα

n }| = |{T βn }|.

The T0 tile is just a cell in state 0; thus when the initial configurationis assigned by the expressions: 0*, 1* and (10)*, the evolution spaceis established by an homogenous evolution with state 0 (or tile T0).Nevertheless, the behavior is not the same for tiles T1, Tα

2 , T β2 , Tα

3 , T β3 ,

. . ., Tαn , T β

n , . . .. The evolution space can be covered by any Tn tiles for0 ≤ n ≤ 4 and for n ≥ 5, it is covered by at least two different tiles. Let

Page 7: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

T� T� T�

� T��

T�

� T�� T

� T��

T�

� T��

Fig. 3. Two sets of tiles in Rule 110: α and β.

Ti and Tj ∈ T where i 6= j, then both sets cannot operate in the planeunder the function of Rule 110 if they cover partially the space (thereare gaps) or overlap with another tiles.

Thus, the tile families {Tαn } and {T β

n } give a detailed description ofthe evolution space in Rule 110 through their sets: α and β. A secondimportant point is that the tiles establish properties by the periodic mar-gins in their recurrent structures (gliders and ether). Their interpretationis also important to derive phases, including non-periodic structures.

2.3 Regular language based on gliders and de Bruijndiagrams

This section is devoted to give a brief introduction in phases and deBruijn diagrams; a more extended explanation can be found in [3] andthe complete set of regular expressions may be consulted from a digitalfile.9

The regular language LR110 is based on a set of regular expressionsΨR110 determining each glider of G. LR110 is established via de Bruijndiagrams and with the characterization of tiles, where both have beenanalyzed for defining useful features called “phases.” They indicate withprecision the position and the exact moment where each glider must bepositioned into a given initial condition.

The set of regular expressions and their basic operations are able toconstruct desired initial conditions to yield evolutions with importantfeatures; the main interest is to control and produce collisions amonggliders. In this way LR110 becomes a powerful tool to codify initial condi-tions; immediate applications with relevant results have been performedover hundreds, thousands, millions and thousands of million of cells10

[10–12, 14].De Bruijn diagrams [15–17] are very adequate for describing evolution

rules in one-dimensional cellular automata, although originally they were9 http://uncomp.uwe.ac.uk/genaro/rule110/listPhasesR110.txt

10 http://uncomp.uwe.ac.uk/genaro/rule110/ctsRule110.html

Page 8: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

used in shift-register theory (the treatment of sequences where theirelements overlap each other). The de Bruijn diagrams can extract anyperiodic string of Rule 110 or another CA; particularity we employ theconnected cycles from extended de Bruijn diagrams to calculate anystring and its shifts over a number of generations.

A glider in Rule 110 can be seen as a periodic construction preservinga defined cyclic border with ether in the evolution space. Essentially aglider has the following characteristics: volume (number of cells repre-senting its form), period (number of evolutions to recover the originalsequence), displacement (change of horizontal position measured in cellson finishing its period) and speed (velocity produced by the period be-tween the displacement). Thus a set of gliders with different volume andspeed can be represented.

In order to explain how the sequences of each glider are determined, ade Bruijn diagram for an A glider is firstly calculated and it is decribedhow the periodic sequences are extracted from it or representing thisglider and specifying as well its set of regular expressions.

A glider moves two cells to the right in three times (see Table 2), thecorresponding extended de Bruijn diagram (2-shift, 3-gen) is depicted inFigure 4. The cycles in the diagram are periodic sequences describingeach phase in the glider; however these sequences are not ordered yet,hence they must be classified.

Fig. 4. De Bruijn diagram for A gliders within ether configurations.

Diagram in Figure 4 has two cycles: a cycle formed by just a vertex0 and another large cycle of 26 vertices composed by other nine internalcycles. The evolution of the right illustrates the location of the differentperiodic sequences producing the A glider in distinct numbers.

Page 9: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

The sequences or regular expressions determining the phases of theA glider are obtained following paths through the edges of the diagram.For instance, the following cycles specify different formations:

I. The expression (1110)*, vertices 29, 59, 55, 46 determining An glid-ers.

II. The expression (111110)*, vertices 61, 59, 55, 47, 31, 62 defining nAgliders with a T3 tile among each glider.

III. The expression (11111000100110)*, vertices 13, 27, 55, 47, 31, 62, 60,56, 49, 34, 4, 9, 19, 38 describing ether configurations in a specificphase (in the following subsection we will see that this phase is callede(f1 1)).

Cycle with period 1 represented by vertex 0 produces an homoge-neous evolution in state 0. The evolution space in Figure 4 shows differ-ent packages of A gliders, the initial condition is constructed followingsome of the seven possible cycles of the de Bruijn diagram or a combi-nation of them. In this way the number of A gliders or the number ofintermediate tiles T β

3 can be selected changing from one cycle to another.

Table 3. Four sets of phases Phi in Rule 110.

phases level one (Ph1) → {f1 1, f2 1, f3 1, f4 1}phases level two (Ph2) → {f1 2, f2 2, f3 2, f4 2}

phases level three (Ph3) → {f1 3, f2 3, f3 3, f4 3}phases level four (Ph4) → {f1 4, f2 4, f3 4, f4 4}

The alignment of the fi 1 phases is analyzed to determine the wholeset of strings for every glider. First it is necessary to describe the formand limits of each glider by tiles, then a phase is fixed (in our case thephase fi 1) and a horizontal line is placed in the evolution space boundedby two tiles T3. Thus, the sequence between both tiles aligned in each ofthe four levels determines a periodic sequence representing a particularstructure in the evolution space of Rule 110. Thus all periodic sequencesin a specific phase are calculated, enumerating the phases for each glideror non-periodic structure.

Table 3 represents every disjoint subset of phases, each level containsfour phases. Variable fi indicates the phase currently used where the sec-ond subscript j (completing notation fi j) indicates the selected set Phj

of regular expressions. Finally, this notation codifies initial conditions byphases as follows:

#1(#2, fi 1) (1)

Page 10: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

where #1 represents a glider according to Cook’s classification (Table 2)and #2 the phase of the glider with period greater than four.11

Therefore, the full list of regular expressions ΨR110 for each glider,including a glider gun, is given in [3] and it also serves as a simple finite-machine for the OSXLCAU21 system12 developed to code gliders in Rule110.

3 Universal CA

Universality in CA is developed and solved by von Neumann in [18] asa previous step in the specification of the universal constructor for hisautomaton of 29-states. The element of universality into this constructoris a necessary ingredient to handle non-reliable pieces (atomic elements)for assembling reliable components with the capacity of executing com-putations by collisions of signals.

There are several significant simplifications in universal-computingCA with fewer states and dimensions: Codd in 1968 [19], Banks in 1971[20], Smith in 1971 [21], Conway in 1982 [22], Lindgren and Nordahl in1990 [23], and finally Cook in 1998 [1].

Analogous to the search of a minimal universal Turing machine [24],Cook details the minimal universal CA with Rule 110; showing how a“simple” elemental CA is able to simulate an equivalent Turing machinewithin a novel CTS, performing a computation [1, 25] with collision ofgliders in millions of cells.

3.1 Tag systems

The concept of “tag system” has an interesting antecedent in the workdeveloped by Emil Post looking for a unique effective procedure for prov-ing if for any formula could be formally derivable in its own logic ofpropositions. This issue is referred as the “finiteness problem” consist-ing on finding a canonical form to solve a given decision problem (formore details see “Emil L. Post: His Life and Work” in [26]); inducingthe search and development for some auxiliary procedure.

The tag system is a variation from the Turing machine [29] for imple-menting computable processes; Minsky demonstrates that tag systemsare universal [30] and unsolvable [34]. Another relevant result is obtained

11 The arrangement by capital letters for the #2 parameter into the OSXL-CAU21 system [36] does not have a particular meaning; it is only used torepresent the different levels of phases in periods module four.

12 http://uncomp.uwe.ac.uk/genaro/OSXCASystems.html

Page 11: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

by Cocke and Minsky [31] proving which tag systems are universal justwith the deletion number ν = 2.

Therefore, it is worthwhile to remember the original concept to un-derstand tag systems. Thus a literal transcription from [27] is given13:

Given, a positive integer ν, and µ symbols which may be taken to be0, 1, . . . , µ−1. With each of these µ symbols a finite sequence of thesesymbols is associated as follow.

0 → a0,1a0,2 . . . a0,ν0

1 → a0,1a0,2 . . . a0,ν1

......

...µ− 1 → aµ−1,1aµ−1,2 . . . aµ−1,νµ−1 .

It is understood that in each sequence the same symbol may occurseveral times, and that a particular associated sequence may be null.In terms of this basis, we set up the following operation for obtainingfrom any given non-null sequence:

B = b1b1 . . . bl

on the symbols 0, 1, . . . , µ− 1, a unique derived sequence B′ on thosesymbols. To the right end of basis, and from the left end of this aug-mented sequence remove the first ν elements — all if there be lessthan ν elements. As long as B′ is not a null sequence, this operationcan then be applied to B′ to yield a sequence B′′, to B′′, if not null,to yield B′′′, and so on. The problem of “tag” for the given basis isthen to obtain a finite process for determining for any initial sequenceB whether the resulting iterative process does or does not terminate.

Let us see some simple samples with parameters µ = 2, ν = 2 andthe next production rules: 0 → 0 and 1 → 10. The symbol ` means aneffectively computable relation [33]; let us made some operations withdifferent initial conditions looking its “halt” condition.

(a) 0000 ` 000 ` 0 (halt disappear)(b) 1111 ` 1110 ` 1010 ` 1010 (halt periodic)(c) 0101 ` 010 ` 0 (halt disappear)(d) 1010 ` 1010 (halt periodic)(e) 00001111 ` 0011110 ` 111100 ` 110010 ` 001010 ` 10100 ` 10010

` 01010 ` 0100 ` 000 ` 0 (halt disappear)

13 This work is finished by Post in 1941 but it is published up to 1965. It maybe consulted in [28, 26]. M. Davis June 2007, personal communication.

Page 12: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Post determines two relevant conjectures in tag systems; the firstshowing that a tag system can be recursively unsolvable [26] and thesecond one finding intractable problems [32]. In particular for µ = 2 andν > 2, it is established that not all the terminal processes are known,a special case is illustrated for the pair of productions 0 → 00 and1 → 1101.

3.2 Cyclic tag systems

CTS are new machines proposed by Cook in [1] as a tool to implementcomputations in Rule 110. CTS are a variant of tag systems with somechanges; they have the same action of reading a tape in the front andadding characters at its end, nevertheless there are some new restrictionsand characteristics:

1. CTS need at least two letters in their alphabet (µ > 1).2. Only the first character is deleted (ν = 1) and its respective sequence

is added.3. In all cases if the machine reads a character zero then the production

rule is always null (0 → ε, where ε represents the empty word).4. There are k sequences from µ∗ which are periodically accessed to

specify the current production rule when a nonzero character is takenby the system. Therefore the period of each cycle is determinate byk.

This way a cycle determines a partial computation over the tape.Cook does not specify any particular halt condition because perhaps itis a direct consequence of tag systems. Let us see some samples of a CTSworking with µ = 2, k = 3 and the next production rules: 1 → 11, 1 → 10and 1 → ε. To avoid writing every chain where there is not necessity ofadding characters, the `k relation is just indicated to simplify space andredundant information.

For example, the succession 00001 `1`2`3`1`2 10 represent the nextparticular relations 00001 `1 0001 `2 001 `3 01 `1 1 `2 10. Also, eachrelation indicates which µ sequence is selected.

(a) 00001 `1`2`3`1`2 10 `3`1 (halt disappear)(b) 10101 `1 010111 `2`3`1`2 1110 `3`1 1011 `2 01110 `3`1 11011 `2

101110 `3`1`2 11010 `3`1 01011 `2`3`1`2 110 `3`1 011 `2`3`1 11`2 110 `3`1 011 (halt periodic)

(c) 01100 `1`2 10010 `3`1`2`3`1 (halt disappear)(d) 11111 `1 111111 `2 1111110 `3`1 1111011 `2 11101110 `3`1 1011101

1 `2 011101110 `3`1 110111011 `2 1011101110 `3`1`2 1101110

Page 13: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

`3`1 0111011 `2`3`1 101111 `2 0111110 `3`1 1111011 `2 11101110`3`1 10111011 `2 011101110 `3`1 110111011 `2 1011101110 `3`1`2

110111010 `3`1 011101011 `2`3`1 10101111 `2 010111110 `3`1

0111110 `2`3`1 111011 `2 1101110 `3`1 0111011 `2`3`1 1011 `2

01110 `3`1 11011 `2 101110 `3`1`2 11010 `3`1 01011 `2`3`1`2

110 `3`1 011 `2`3`1 11 `2 110 `3`1 011 (halt periodic)

This representation offers two facilities; avoiding long chains in everystep for the null relation and finding the periodic behavior between chainsand relations where both need to be repeated. In general in this case onemust hope that any chain eventually reaches a terminal condition.

The intention of the previous example is to show that the halt condi-tion in CTS behaves in the same way that in tag systems, consequently.Particularity CTS tend to growth quickly and it is more complicated tosee this behavior in this way. In this sense, Morita in [35] has demon-strated how to implement a particular halt condition in CTS given anoutput string when the system is halting, and how a partitioned CA cansimulate any CTS, consequently computing all the recursive functions.14

3.3 Comparing behaviors of tag systems and CTS

Cook explains how a CTS must simulate a tag system [1]. This sectiondisplays a very simple case where the “behavior” of a CTS emulates aterminal tag system.

Let us take a tag system with µ = 2, v = 1 and the next productions:0 → 1 and 1 → ε. Its behavior is showed with some chains having in allcases the disappearing halt condition.

(a) 0000 ` 000 ` 000 ` 00 ` 0(b) 1111 ` 111 ` 11 ` 1(c) 010101 ` 101011 ` 01011 ` 10111 ` 0111 ` 1111 ` 111 ` 11 ` 1(d) 000111 ` 001111 ` 011111 ` 111111 ` 11111 ` 1111 ` 111 ` 11 ` 1

Thus we need to specify a CTS with µ = 2, k = 2 and the nextsequences: 1 → 1 and 1 → ε. Let us take the same previous chains.

(a) 0000 `1`2`1`2`1

(b) 1111 `1 1111 `2`1 111 `2`1 11 `2`1 1 `2

(c) 010101 `1`2`1`2`1`2 1 `1 1 `2

(d) 000111 `1`2`1`2`1 11 `2`1 1 `2

14 K. Morita December 2006, personal communication.

Page 14: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

It is clear that both machines have the same behavior yielding analo-gous terminal states; although frequently a CTS uses more relations thana traditional tag system. CTS are relevant as equivalent Turing machinesand they were studied with certain dedication in the last years. Openquestions are:

– How CTS could find intractable and undecidable problems from morebasic sequences?

– What is the number of terminal subsets with minimum values in µand k?

Similar to Post with his tag system, Cook determines that for aCTS with µ = 2, k = 2, the next relations 1 → 11 and 1 → 10, andalso beginning with a 1 in the tape; it is unknown whether the processis terminal or not. Another particular problem is to establish a haltcondition in Rule 110 with a CTS; this details are discussed in the nextsection.

4 Reproducing a CTS in Rule 110

This section presents several aspects for reconstructing the operation ofa CTS in Rule 110 as the one presented in [2]. We must use a CTS withµ = 2, k = 2 and the next relations 1 → 11 and 1 → 10, begging with a1 into the tape. A segment of its behavior is given as follow:

1 `1 11 `2 110 `1 1011 `2 01110 `1`2 11010 `1 101011 `2 0101110`1`2 0111010 `1`2 1101010 `1 10101011 `2 010101110 `1`2 010111010`1`2 011101010 `1`2 110101010 `1 1010101011 `2 01010101110 `1`2

01010111010 `1`2 01011101010 `1`2 01110101010 `1`2 11010101010 `1

101010101011 `2 0101010101110 `1`2 0101010111010 `1`2 0101011101010 `1`2 0101110101010 `1`2 0111010101010 `1`2 1101010101010 `1

10101010101011 `2 010101010101110 `1`2 010101010111010 `1`2 010101011101010 `1`2 010101110101010 `1`2 010111010101010 . . ..

This example and CTS in general have an apparent inspiration inthe mathematical puzzle proposed by Kolakoski [37]. But, particularityCook was looking for a simple procedure to construct sequences avoidinga quick repetition.15

Some characteristics of the previous CTS are as follows: A chain tendsto growth in certain order by its length or package of bits and intuitivelyit seems that these relations do not repeat. For example, taking as basis15 M. Cook June 2007, personal communication.

Page 15: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

the expression 1(10)*, the CTS moves (from right to left) and adds anew pair of bits; when 1(10)* is reached again, the number of relationsselected in each interval growths lineally in order of f1 = 2(n + 1).Nevertheless, the number of bits into the chain growths parabolically aswe can see in Fig. 5. Function f2 represents the interpolated polynomialfrom the first ten initial values and function f3 the extrapolation.

Therefore, if we take consecutive copies of 1(10)* with their respectiveintervals determined by the number of j relations (represented as `j

i ),we obtain the next chains: 1 `2

i 110 `4i 11010 `6

i 1101010 `8i 1101010

`10i 110101010 `12

i 11010101010 `14i 1101010101010 `16

i . . .. So, there isnot a succession of two contiguous zeros as it was previously generatedby the CTS. The parabolic growth is given in every chain and its lineargrowth in the interval of relations.

Fig. 5. Growth function for the CTS.

Now we expose how to interpret gliders and their collisions to emulatea CTS in Rule 110, basically we must use packages of gliders to representdata and operators; their reactions read, transform and delete data inthe tape. Several details are delicate reason why its reconstruction islaborious and not an easy task. In essence we can see the representationin Figure 6 and the features and labels of this diagram are explained inthe next paragraphs.

Page 16: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

3A4_4A 1Ele_C20Ele_C2 1BloP_Eb 1BloS_Eb0Blo_EbSepInit_EEb

Cook - ANKOS

Fig. 6. Interpretation of a CTS working in Rule 110.

4.1 Components based on packages of gliders

The construction of the CTS in Rule 110 can be partitioned in threeparts. First is the left periodic part controlled by packages of 4 A4 gliders,this part is static and controls the production of 0’s and 1’s. The secondpart is the center determining the initial value in the tape, and the thirdone is the right cyclic part which has the data to process, adding aleader component specifying added or erased data from the tape in theevolution space.

In the left part, the four packages of A4 gliders must be carefullyexplained because although they are static, their phases change period-ically. The important point to implement these components is definingboth distances and phases, because a distinct phase or distance inducesa non-wished reaction; in fact all components follow this restriction be-cause every glider of each component must be correctly aligned.

Fig. 7. Packages of 4 A4 gliders.

Packages defined by A4 gliders have three different phases: f1 1, f2 1and f3 1. In order to construct the first 4 A4 we need to establish the

Page 17: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

phase of each A4; let us assign phases in the following way: A4(f3 1)-27e-A4(f2 1)-23e-A4(f1 1)-25e-A4(f3 1) as it is illustrated in Figure 7. Spacesbetween each 4 A4 are static but the phases rotate to obtain collisionslike a soliton with the E gliders generated in the system, this rotationin each A4 is also projected in the whole package 4 A4. Eventually thisbecomes periodic as follows:

{649e-A4(f2 1)-27e-A4(f1 1)-23e-A4(f3 1)-25e-A4(f2 1)-649e-A4(f1 1)-27e-A4(f3 1)-23e-A4(f2 1)-25e-A4(f1 1)]-649e-A4(f3 1)-27e-A4(f2 1)-23e-A4(f1 1)-25e-A4(f3 1)}*

if for every 4 A4 we take a phase representing the complete package, wecan rename it as:

{649e-4 A4(F2)-649e-4 A4(F1)-649e-4 A4(F3)}*

this rotation is important to preserve the left part of the system.Distances between each 4 A4 must be carefully specified since short

spaces do not allow a good construction because A gliders are fasterthan E and E gliders, and they would reach the data formed by C2

gliders before new packages of data arrive. Cook has considered thisproblem determining a necessary minimum distance when the twelfth 1is produced into the tape of its diagram in [1]. This is very close to thefourth 0 but the next 4 A4 package does not disturb this element; otherdistances for the rest of collisions are sufficiently spaced taking finallyan interval of at least 649 ether configurations.

Elements 1Ele C2 and 0Ele C2

The central part is constituted by an initial 1 into the tape repre-sented by a package of four C2 gliders. This way, an element 1Ele C2

represents a 1 and the element 0Ele C2 represents a 0 in the tape.

9T3 5T3 7T39T3 9T3 7T3

Fig. 8. Elements 1Ele C2 and 0Ele C2.

Page 18: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Particularity, the number of elements listed in Wolfram’s book [2] toconstruct a CTS is incomplete and with mistakes, this situation madeimpossible to reconstruct the system.16 In fact a discussion about theexternal factors involved in the publishing of the original work in Rule110 can be consulted in [38, 39].

The first picture in Figure 8 shows the element 1Ele C2, since thesame idea is used in the others components, first we should reproduceeach element by the phases fi 1. Thus the code in phases is: C2(A,f1 1)-2e-C2(A,f1 1)-2e-C2(A,f1 1)-e-C2(B,f2 1). The first three C2 gliders arein phase (A,f1 1) and the fourth C2 is in phase (B,f2 1), hence the dis-tances among them are: 9T3-9T3-7T3. In order to take the distance, wecount the number of T3 tiles between gliders. The phase of the last C2

cannot be other because it produces another reaction. The same analysisfor the element 0Ele C2 yields the distances 9T3-5T3-7T3.

Thus differences in both blocks are relevant, the first difference is thatthe distinct central space between both packages and the second one isthat their phases are dissimilar as well. Their phases fi 1 are projectedat each element, for instance the element 1Ele C2 has 7 phases in whichit can be represented in the initial configuration, hence we take the firstglider and the rest are aligned together. Each sequence of bits for everyelement is presented in the appendix.

Element 0Blo E

The left part stores blocks of data without transformation in packagesof E and E gliders.

10 1 2 8 8 8 10 1 2 8 8

Fig. 9. Element 0Blo E.

16 These problems were clarified by M. Cook. in november 2002 (personalcommunication).

Page 19: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

The element 0Blo E is formed by 12E gliders as we can see in figure 9.There must be an accurate phase and distance between each one of thembecause in otherwise the whole system will be disturbed. This elementrepresents a 0 into the tape in the CTS if a leader permit this conversion,when it is pre-transformed then finally we have an element 0Ele C2.Essentially this block of gliders do not need important changes like weshall see in the next element; it is only necessary to preserve distancesand phases.

Elements 1BloP E (primary) and 1BloS E (standard)

Cook establishes the existence of two components to represent 1’s:primary and standard; if one of them is not used the system does notwork suitably. Let us note that the primary element was completelyignored in Wolfram’s book [2].

4 6 2 8 8 2 10 1 2 8 8

10 1 2 8 8 2 10 1 2 8 8

Fig. 10. Elements 1BloP E (primary) and 1BloS E (standard) respectively.

They are differences in distance of their first two E gliders as figure 10displays. In essence both blocks produce the same element 1Add E al-though coming from different intervals. The reason to use both blocks

Page 20: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

is that Rule 110 is not symmetric; therefore if we use only one elementthen surely we would obtain a good production in the first collision gen-erating an element 1Add E; moreover when the second package of 4 A4

gliders finds the second block, the system is completely destroyed.

Element SepInit EE

A leader element renamed as SepInit EE (see Figure 11) is importantto separate packages of data and determine their incorporation into of thetape. Particularity its has a small but detailed code determining whichdata without transformation would be added or erased from the tape,depending on the value that it finds. This element is very delicate becausewe can define two different phases for the same index but they eventuallyare different, because the E glider has 4 phases and the E glider has 8phases. Therefore, we could have two equals phases apparently from theinitial gliders but E is in different phases.

4 14 6,7 6 9 2 8

Fig. 11. Element SepInit EE.

For this reason we have two distances at the same interval, thus if aphase works suitably the next will not because their E gliders would beout of phase. Then we should omit the second version of this element pre-sented in Wolfram’s book [2] because it is a consequence of SepInit EEafter colliding with three A gliders and it is not necessary to code it fromthe initial configuration since it is reached after several reactions on theevolution.

Elements 1Add E and 0Add E

Figure 12 illustrates the elements 1Add E and 0Add E produced bytwo previous different packages of data. An element 1Add E must be

Page 21: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

generated by a block 1BloP E or by 1BloS E. This way, both elementscan produce the same element.

On the other hand, an element 0Add E is generated by a block0Blo E although in this case it is not necessary a primary element. Nev-ertheless, we could produce E gliders modifying their first two distancesand preserving them without changing others gliders to get a reliablereaction. This is possible if we desire to experiment with other combina-tions of blocks of data although this could complicate the implementationof the system.

27 21 27

27 27 27

Fig. 12. Elements 1Add Eb and 0Add E respectively.

Again, here we have another mistake in Wolfram’s book [2] (page681). The element 1Add E has distances 27e-21e-27e in the E glidersbut in [2] this element has distances 20e-27e-21e. It is easy to deducethat this was an error on selecting the figure. The first E of such figurein [2] is an invisible glider for the CTS because it will cross as solitonall data and operators; thus the next three E gliders correspond to theelement 1Add E.

So, if a leader element SepInit EE reaches an element 1Ele E, iterases this value from the tape and adds a new data that shall be trans-

Page 22: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

formed. In other case, if it finds an element 0Ele E, then it erases thiselement from the tape and also erases a set of unchanged data whichcome from the right until finding a new leader element. Essentially thisoperation represents the addition of new values from periodic packages ofgliders coming from the right. Thus an element 1Add E is transformedinto 1Ele E colliding against a package of 4 A4 gliders representing avalue 1 in the tape, and the element 0Add E is transformed into 0Ele Ecolliding against a package of 4 A4 gliders representing a value 0 in thetape.

Table 4. Distances between the gliders of each element.

element distance

1Ele C2 9-9-70Ele C2 9-5-71BloP E 4-6-2-8-8-2-10-1-2-8-81BloS E 10-1-2-8-8-2-10-1-2-8-80Blo E 10-1-2-8-8-8-10-1-2-8-8SepInit EE 4-14-(6 or 7)-6-9-2-81Add E 27-21-270Add E 27-27-27

Finally, Table 4 enumerates all distances (number of T3 tiles) forevery necessary element in the construction; this is a practical way toidentify any element in the evolution space. Finally, we can code theconstruction of this CTS with phases representation in three main bigblocks as follows:

left: . . . -217e-4 A4(F2)-649e-4 A4(F1)-649e-4 A4(F3)-649e-4 A4(F2)-649e-4 A4(F1)-649e-4 A4(F3)-216e-

center: 1Ele C2(A,f1 1)-e-A3(f1 1)-

right: SepInit EE(C,f3 1)-1BloP E(C,f4 1)-SepInit EE(C,f3 1)-1BloP E(C,f4 1)-0Blo E(C,f4 1)-1BloS E(A,f4 1)-SepInit EE(A,f2 1)(2)-1BloP E(F,f1 1)-SepInit EE(A,f3 1)(2)-1BloP E(F,f1 1)-0Blo E(E,f4 1)-1BloS E(C,f4 1)-e-SepInit EE(B,f1 1)(2)-1BloP E(F,f3 1)-e-SepInit EE(B,f1 1)(2)-217e-. . .

this initial conditions in Rule 110 are able to generate the serial se-quence of bits 1110111 and a separator at the end also with two solitons;

Page 23: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

achieving a satisfactory construction in 57,400 generations with an ini-tial configuration of 56,240 cells. This square implies an evolution spaceof 3,228,176,000 cells; thus the simulation of the CTS in Rule 110 ishighly inefficient and it could be hardly used in practical applications.Moreover, the relevance here is to show its universality produced by asimply impressive construction and global synchronization.

In the next section we explain and display the (more relevant) stagesin the evolution space of Rule 110 with the CTS working. First we mustsee two possible cases.

4.2 Beginning from 0

Fig. 13. CTS beginning from a 0 in Rule 110.

If the system begins from zero in the tape then the machine muststop in one step because this element is erased and there is not any addedelement to the tape (remember that 0 → ε), corresponding to the pair inthe original productions. This operation is fulfilled with the packages ofgliders previously discussed because independently of how the blocks ofdata are structured, they do not produce a new element in the tape. Thestructure of data is gradually destroyed as we can see in figure 13, afterthe second package of A4 gliders reaches the a second leader component.

Page 24: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

4.3 Beginning from 1

The CTS presented in [2] begin from 1 in the tape like the illustrationin figure 6. The next snapshots show the most relevant stages of themachine working in Rule 110. In every picture we indicate with coloredlabels every different element or component.

Figure 14 displays the initial stage of the CTS with a 1 in the tape.This data is represented by the element 1Ele C2 and depicts as wellthe central part of the machine from its initial condition also with apackage of A3 gliders, such that, this package would prepare the firstleader element SepInit EE coming from the right periodic part. So thispackage of A3 gliders arrives joined or separated producing the samereaction.

The first reaction in figure 14 deletes its respective 1 in the tape(element 1Ele C2) and as consequence an element separator prepares thenext data that would be aggregated. If it finds an element 0Ele C2 thendoes not allow to add data on the tape until finding another separator.Both E gliders which remain to the first production are invisible in allthe system and do not affect in any operation because they cross assolitons the subsequent packages of 4 A4 gliders.

Figure 15 shows the continuation of the previous evolution. Thissnapshot describes a production of the element 1Add E from the pri-mary component 1BloP E. Its construction uses a basic periodic reac-tions identified vertically by the columns of C1 and pairs of C3 gliders.A C1 stops an E producing a new pair of C3 which also receive a pairof E gliders yielding a C1 again. This operation is repeated until find aleader element receiving three A gliders.

Figure 16 illustrates two aspects, the production of an element 1Ele C2

and the existence of invisible E gliders crossing as solitons the successivepackages of 4 A4 gliders. Each block of A4 gliders transforms each E in1Add E into a C2 of 1Ele C2. Analogous, in order to construct an ele-ment 0Ele C2 we have a similar structure to the previous example andtheir distances determine this element with their internal gliders.

Figure 17 displays the evolution following figure 16. In this case, wecan see an element 1Ele C2 constructed from a package of 4 A4 gliders,However, it has a very short life because quickly a separator elementarrives erasing and preparing new data that would be aggregated tothe tape. An important point is that E gliders which cross as solitonspreserve distances and phases.

Figure 18 shows how data are pre-transformed and eventually aggre-gated onto the tape and where a standard component must be correctlyplaced. Top evolution describes the transformation from a primary com-ponent 1BloP E in an element 1Add E with a glider soliton. There is as

Page 25: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 14. Initial stage of CTS in Rule 110.

Page 26: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 15. Construction of the element 1Add E from a primary component

Page 27: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 16. Operators based in packages of 4 A4 gliders.

Page 28: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 17. Constructing an element 1Ele C2.

Page 29: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 18. Constructing an element 1Add E.

Page 30: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 19. Constructing an element 0Add E.

Page 31: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 20. Transformed data crossing the tape of values.

Page 32: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

well an element 0Blo E which changes in an element 0Add E and thestandard component 1BloS E is transformed in an element 1Add E.

Figure 19 describes the formation of a 0Add E element. Note thatwhen there is not a leader element between these blocks, the systemdoes not produce solitons. In this snapshot, all E gliders are processedas data and they will be transformed for a package of 4 A4 gliders. Thus,soliton patterns are only originated from leader components. We cansee completely as well in this snapshot a standard component 1BloS Eneeded for the suitable behavior of the system (adjusting of the non-symmetric evolution space of Rule 110).

Finally in Fig. 19 a leader element SepInit EE arrives to close aperiodic block coming from the right. This periodic block begins with:a separator, a primary black block, a separator, another primary blackblock, a white block and a standard black block. Therefore, the realperiod by components to the right can be written as follows:

{SepInit EE-1BloP E-SepInit EE-1BloP E-0Blo E-1BloS E}*.

Figure 20 presents the construction of a 1Ele C2 element. In thisstage of the evolution, we can see how data is aggregated before theycross the tape with their respective values. Also, these reactions are thesame with the element 0Ele C2. Also, there is a unique option betweenC2 and E gliders to cross as solitons because any another reaction doesnot preserve this property [12]. It is really a laborious task to obtain theglobal synchronization.

Figure 21 shows a constructed 0Ele C2 element and its function inthe system. At the top, an element 1Add E is previously produced bya standard component 1BloS E crossing an element 0Ele C2. Hence aleader element comes to delete this 0 from the tape and all the subsequentincoming data. In this sequence, there are 1BloP E, 0Blo E and 1BloS Eelements.

Similar when a 1 is deleted from the tape, when a 0 is deleted, dis-tances are smaller in the first collisions and a T14 tile is generated in theprocess. This difference of distances determines a change of phases whichwill erase E gliders instead of produce C gliders. In order to delete thesepackages of gliders, a reaction A3 → E is used. Figure 22 illustrates howmust be erased sequentially packages of data and they arriving orderdoes not affect if they are deleted or pre-transformed. Finally, Figure 23shows the final stage deleting data and a new period would begin again.

Production rules in CTS establishes for 0 that the first element ofthe chain must be erased and the other elements are conserved withoutadditional data. If the first value is 1 the first element of the chain isdeleted and 10 or 11 are aggregated depending of the k value. This

Page 33: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 21. Deleting a 0Ele C2 element.

Page 34: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 22. Deleting unchanged data blocks with the reaction A3 → E.

Page 35: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

Fig. 23. Final stage deleting data.

Page 36: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

behavior is well represented when a separator finds 0 or 1 and deletesit from the tape. If the deleted data was 0, a separator does not allowthe production of new data until it finds a new one; on the other casewhether the deleted data is 1, a separator aggregates the new elements11 or 10 that will be transformed later.

This construction is repeated indefinitely. Thus, using this procedure,we can calculate up to the sixth 1 of the sequence 011<1>0 produced bythe CTS; verifying that phases fi 1 are useful to reproduce this systemin a different way. Finally, in terms of periodic phases, this CTS can bewritten as follow:

left: {649e-4 A4(F i)}*, for 1 ≤ i ≤ 3 in sequential order

center: 246e-1Ele C2(A,f1 1)-e-A3(f1 1)

right: {SepInit EE(#,fi 1)-1BloP E(#,fi 1)-SepInit EE(#,fi 1)-1BloP E(#,fi 1)-0Blo E(#,fi 1)-1BloS E(#,fi 1)}* (where1 ≤ i ≤ 4 and # represents a particular phase).

5 Final notes

The use of phases fi 1 allows to identify, control and code gliders frominitial conditions in Rule 110. Some questions arise over the universalityof Rule 110; one of them is determining if the periodic right side willbecome periodic into the tape of the CTS. In this case, could we find aperiodicity on the tape? How can be connected equivalent Turing ma-chines to CTS? Some variants may be Turing machines [40] and circularPost’s machines [41, 42].

Eventually, futures problem to solve in Rule 110 are the implementa-tion of an specific Turing machine using the glider system and looking forpossibilities to implement a universal and self-reproducing constructor.

Nowadays, some investigations have found important and relatedworks around of the universality in Rule 110 [43].17 In the case of theCTS, there are some solved problems like a Fibonnaci sequence done byChapman (January 2003). On the other hand, Neary and Woods in [44]show that Cook’s machine can run in a polynomial time. Morita in [35]proofs how to implement an explicit halt condition in the CTS and howa partitioned CA may simulate any CTS.

Finally, in this paper we have reproduced the necessary componentsand their initial conditions for a CTS working in Rule 110; explaining as17 A list of papers related in Rule 110 and its universality is presented in

http://uncomp.uwe.ac.uk/genaro/Rule110.html

Page 37: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

well each stage of the evolution space with several details, obtaining asuccessful partial computation; writing the sequence 1110111 on the tapeand a leader component at the end with two solitons. This reconstructionis performed in an evolution space of 56,240 cells in 57,400 generations(3,228,176,000 cells); running on a computer Pentium II to 233 mhz,operating system OpenStep and 256MB of RAM (February 2003).18

Acknowledgements

In special to Matthew Cook for his kind help four years ago with use-ful commentaries and for the last interview in Zurich (June 2007). ToKenichi Morita and Martin Davis by their commentaries and close pa-pers. Also, the first author thanks a previous support by CONACyT withregistry number 139509 and an actual one by EPSRC grant referenceEP/D066174; and the third author thanks the support of CONACyTwith reference number CB-2006-1/59422.

References

1. Cook, M. (2004) Universality in Elementary Cellular Automata, ComplexSystems 15 (1) 1–40.

2. Wolfram, S. (2002) A New Kind of Science, Wolfram Media, Inc., Cham-paign, Illinois.

3. Martınez, G.J., McIntosh, H.V., Seck Tuoh Mora, J.C. & Chapa Vergara,S.V. (2008) Determining a regular language by glider-based structurescalled phases fi 1 in Rule 110, Journal of Cellular Automata 3 (3) 231–270.

4. Cook, M. (1999) Introduction to the activity of rule 110 (copyright1994-1998 Matthew Cook), http://w3.datanet.hu/∼cook/Workshop/

CellAut/Elementary/Rule110/110pics.html

5. Gardner, M. (1970) Mathematical Games - The fantastic combinationsof John H. Conway’s new solitaire game Life, Scientific American 223120–123.

6. Wolfram, S. (1986) Theory and Aplications of Cellular Automata, WorldScientific Press, Singapore.

7. Lindgren, K. & Nordahl M. (1990) Universal Computation in Simple One-Dimensional Cellular Automata, Complex Systems 4 229–318.

8. Griffeath D. & Moore C. (eds.) (2003) New Constructions in CellularAutomata, Oxford University Press.

9. McIntosh, H.V. (1999) Rule 110 as it relates to the presence of gliders,http://delta.cs.cinvestav.mx/∼mcintosh/oldweb/pautomata.html

18 http://uncomp.uwe.ac.uk/genaro/rule110/ctsRule110.html

Page 38: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

10. Martınez, G.J., McIntosh, H.V. & Seck Tuoh Mora, J.C. (2003) Productionof gliders by collisions in Rule 110, Lecture Notes in Computer Science2801 175–182

11. Martınez, G.J., McIntosh, H.V. & Seck Tuoh Mora, J.C. (2006) Gliders inRule 110, Int. J. of Unconventional Computing 2 (1) 1–49.

12. Martınez, G.J. & McIntosh, H.V. (2001) ATLAS: Collisions of gliders likephases of ether in Rule 110, http://uncomp.uwe.ac.uk/genaro/papers.html

13. McIntosh, H.V. (2000) A Concordance for Rule 110, http://delta.cs.cinvestav.mx/∼mcintosh/oldweb/pautomata.html

14. Martınez, G.J., McIntosh, H.V., Seck Tuoh Mora, J.C. & Chapa Vergara,S.V. (2007) Rule 110 objects and other collision-based constructions, Jour-nal of Cellular Automata 2 (3) 219–242.

15. McIntosh, H.V. (1991) Linear cellular automata via de Bruijn diagrams,http://delta.cs.cinvestav.mx/∼mcintosh/oldweb/pautomata.html

16. Voorhees, B.H. (1996) Computational analysis of one-dimensional cellularautomata, World Scientific Series on Nonlinear Science, Series A, Vol. 15.

17. Voorhees, B.H. (2008) Remarks on Applications of De Bruijn Diagramsand Their Fragments, Journal of Cellular Automata 3 (3) 187–204.

18. von Neumann, J. (1966) Theory of Self-reproducing Automata (edited andcompleted by A. W. Burks), University of Illinois Press, Urbana and Lon-don.

19. Codd, E.F. (1968) Cellular Automata, Academic Press, Inc. New York andLondon.

20. Banks, E.R. (1971) Information and transmission in cellular automata,PhD Dissertion, Cambridge, MA, MIT.

21. Smith III, A.R. (1971) Simple computation-universal cellular spaces, J. ofthe Assoc. for Computing Machinery 18 339–353.

22. Berlekamp, E.R., Conway, J.H. & Guy, R.K. (1982) Winning Ways foryour Mathematical Plays, Academic Press, vol. 2, chapter 25.

23. Lindgren, K. & Nordahl, M.G. (1990) Universal Computation in SimpleOne-Dimensional Cellular Automata, Complex Systems 4 229–318.

24. Shannon, C.E. (1956) A Universal Turing Machine with Two InternalStates, Automata Studies, Princeton University Press, 157–165.

25. Adamatzky, A. (ed.) (2003) Collision-Based Computing, Springer.26. Davis, M. (ed.) (1994) Solvability, Provability, Definability: The Collected

Works of Emil L. Post, Birkhauser Boston.27. Post, E.L., Absolutely Unsolvable Problem and Relativity Undecidable

Propositions, 345–441, in [26].28. Davis, M. (ed.) (1965) The Undecidable, Raven Press Books.29. Turing, A.M. (1936) On Computable numbers, with an application to the

Entscheidungsproblem, Proceedings of the London Mathematical Society42 (2) 230–265. 1937 Corrections, Ibid 43 544–546.

30. Minsky, M. (1967) Computation: Finite and Infinite Machines, PrenticeHall.

31. Cocke, J. & Minsky, M. (1964) Universality of Tag Systems With P = 2,Journal of the Association for Computing Machinery 11 (1) 15–20.

Page 39: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

32. Post, E.L. (1943) Formal reductions of the general combinatorial decisionproblem, American Journal of Mathematics 65 (2) 197–215.

33. Aandreraa, S. & Belsnes, D. (1971) Decision problems for tag systems,Journal of Symblic Logic 36 (2) 229–239.

34. Minsky, M. (1961) Recursive unsolvability of Post’s problem of tag andother topics in the theory of Turing machines, Annals of Mathematics 74437–455.

35. Morita, K. (2007) Simple universal one-dimensional reversible cellular au-tomata, Journal of Cellular Automata 2 159–166.

36. Martınez, G.J. (2004) Introduction to OSXLCAU21 System, http://

uncomp.uwe.ac.uk/genaro/papers.html

37. Kolakoski, W. (1966) Problem 5304. Amer. Math. Monthly 73 681–682.

38. Giles, J. (2002) What kind of science is this?, Nature 417 216–218.

39. Martınez, G.J. (2004) Introduction to Rule 110, http://uncomp.uwe.ac.uk/genaro/papers.html

40. Arbib, M.A. (1969) Theories of Abstract Automata, Prentice-Hall Seriesin Automatic Computation.

41. Kudlek, M. & Rogozhin, Y. (2001) New Small Universal Post Machine,Lecture Notes in Computer Science 2138 217–227.

42. Kudlek, M. & Rogozhin, Y. (2001) Small Universal Circular Post Machine,Computer Science Journal of Moldova 9 (25) 34–52.

43. McIntosh, H.V. (2002) Rule 110 Is Universal!, http://delta.cs.

cinvestav.mx/∼mcintosh/oldweb/pautomata.html

44. Turlough, N. & Woods, D. (2006) P-completeness of cellular automatonRule 110, Lecture Notes in Computer Science 4051 132–143.

45. Wuensche, A. (1999) Classifying Cellular Automata Automatically, Com-plexity 4 (3) 47–66.

Appendix. Initial condition to reproduce a CTS inRule 110

This initial condition is a long chain moreover it is available from a dig-ital file (ctsR110.txt) in http://uncomp.uwe.ac.uk/genaro/rule110/ctsRule110.html.

Then the succession of components is given in the next table. Thissuccession must be reading up-down and left-right. Every letter e repre-sents an ether sequence in phase f1 1 therefore just we must write it ase (where e represents e = 11111000100110).19

19 http://uncomp.uwe.ac.uk/genaro/rule110/listPhasesR110.txt

Page 40: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

left center right. . .-217e- 1Ele C2(A,f1 1)- SepInit EE(C,f3 1)-4 A4(F2)- e- 1Blo EP(C,f4 1)-649e- 3A(f1 1)- SepInit EE(C,f3 1)-4 A4(F1)- 1Blo EP(C,f4 1)-649e- 0Blo E(C,f4 1)-4 A4(F3)- 1Blo ES(A,f4 1)-649e- SepInit EE(A,f3 1)(2)-4 A4(F2)- 1Blo EP(F,f1 1)-649e- SepInit EE(A,f3 1)(2)-4 A4(F1)- 1Blo EP(F,f1 1)-649e- 0Blo E(E,f4 1)-4 A4(F3)- 1Blo ES(C,f4 1)-216e- e-

SepInit EEr(B,f1 1)(2)-1Blo EP(F,f3 1)-e-SepInit EE(B,f1 1)(2)-217e-. . .

Finally our reconstruction has the next explicit sequence of bits; dis-played by each particular element. We are omitting in the type trivialrepetitions of the same sequence, for instance when there are ether con-figurations. In this case, ne means n copy of e ether chains.

. . . - 217e = 217e(f1 1)

4 A4(F2) = 1111100011101110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111101110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000

Page 41: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001110111000100110

649e = 649e(f1 1)

4 A4(F1) = 11111011101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011101001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001110111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111101110

649e = 649e(f1 1)

4 A4(F3) = 11111000100110111010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000111011100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111101110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001

Page 42: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

10111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101110100110

649e = 649e(f1 1)

4 A4(F2) = 1111100011101110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111101110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001110111000100110

649e = 649e(f1 1)

4 A4(F1) = 111110111011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001

Page 43: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

10111110001110111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111101110

649e = 649e(f1 1)

4 A4(F3) = 1111100010011011101001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100011101110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110111011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101111100010011011111000100110111110001001101110100110

216e = 216e(f1 1)

1Ele C2(A,f1 1) = 111110000001001101111100010011011111000100110111110000001001101111100010011011111000100110111110000001001101111100010011011111000111011010

e = e(f1 1)

A3(f1 1) = 111110111000100110

SepInit EE(C,f3 1) = 11111000100110010001110011000111001101111100010011010011111110101111100010011011111000100110111110001001

Page 44: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

10111110001001100100011100110001111100010011011111000100110011101110011000100110111110001001101000110100110001001101111100010011011111000100110110001011111000100110111110011111011100110111110001001101111100010011011101101110 1011100110

1Blo EP(C,f4 1) = 111111001111000100110111110001110111110100111110001001101111100010011011100011101100010011011111000101101000011011111000100110111110001001101111110000110111001101111100010011011111000100110111110011100000100110111011011101011100110111110001001101111100010011011101110011000010011011111000101101000011011111011111101111101011111000100110111110001001101111100111110111001101111100010011011111000100110111011011101011100110

SepInit EE(C,f3 1) = 11111000100110010001110011000111001101111100010011010011111110101111100010011011111000100110111110001001101111100010011001000111001100011111000100110111110001001100111011100110001001101111100010011010001101001100010011011111000100110111110001001101100010111110001001101111100111110111001101111100010011011111000100110111011011101011100110

1Blo EP(C,f4 1) = 111111001111000100110111110001110111110100111110001001101111100010011011100011101100010011011111000101101000011011111000100110111110001001101111110000110111001101111100010011011111000100110111110011100000100110111011011101011100110111110001001101111100010011011101110011000010011011111000101101000011011111011111101111101011111000100110111110001001101111100111110111001101111100010011011111000100110111011011101011100110

0Blo E(C,f4 1) = 1111110011110001001101111100010011011111000100110111110001110110010110111110111111011111010111110000101100100110111110001001101111100010011011101110011000010011011111000100110111110001001101111110011110001001101111100010011011111000100110111110011100000100110111110001001101111100010011011111001111101110011011100011101100010011011111000101101000011011111000100110111110001001101111110000110111001101111100010011011111000100110111110011100000100110

1Blo ES(A,f4 1) = 1110110111010111001101111100010011011111000100110111011

Page 45: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

10011000010011011111000101101000011011111011111101111101011111000100110111110001001101111100111110111001101111100010011011111000100110111011011101011100110111111001111000100110111110001001101111100010011011111000111011001011011111011111101111101011111000010110010011011111000100110111110001001101110111001100001001101111100010011011111000100110111111001111000100110

SepInit EE(A,f3 1)(2) = 11111000100110000001111100000111110101111100010011011111111110001111100010011011111000100110111110001001101111100010011000000111110000011111000100110111110001001101100010111110001001101111100010011001100011111100010011011111000100110111110001001101110001110110001001101110111001100001001101111100010011011111000100110111111001111000100110

1Blo EP(F,f1 1) = 111110100110111100110111110001001101111100111000001001101111100010011011111000101101000011011111011111101111101011111000100110111110001001101111100111110111001101111100010011011111000100110111011011101011100110111111001111000100110111110001001101111100010011011111000111011001011011111011111101111101011111000010110010011011111000100110111110001001101110111001100001001101111100010011011111000100110111111001111000100110

SepInit EE(A,f3 1)(2) = 11111000100110000001111100000111110101111100010011011111111110001111100010011011111000100110111110001001101111100010011000000111110000011111000100110111110001001101100010111110001001101111100010011001100011111100010011011111000100110111110001001101110001110110001001101110111001100001001101111100010011011111000100110111111001111000100110

1Blo EP(F,f1 1) = 111110100110111100110111110001001101111100111000001001101111100010011011111000101101000011011111011111101111101011111000100110111110001001101111100111110111001101111100010011011111000100110111011011101011100110111111001111000100110111110001001101111100010011011111000111011001011011111011111101111101011111000010110010011011111000100110111110001001101110111001100001001101111100010011011111000100110111111001111000100110

Page 46: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

0Blo E(E,f4 1) = 1111101001101111001101111100010011011111000100110111110001000110011000111110000101100100110111110001110111110010111110001001101111100010011011111000111011001011011111000100110111110001001101111101001101111001101111100010011011111000100110111011011101011100110111110001001101111100010011011101110011000010011011111000101101000011011111011111101111101011111000100110111110001001101111100111110111001101111100010011011111000100110111011011101011100110

1Blo ES(C,f4 1) = 111111001111000100110111110001001101111100010011011111000111011001011011111011111101111101011111000010110010011011111000100110111110001001101110111001100001001101111100010011011111000100110111111001111000100110111110100110111100110111110001001101111100010011011111000100011001100011111000010110010011011111000111011111001011111000100110111110001001101111100011101100101101111100010011011111000100110111110100110111100110

e = e(f1 1)

SepInit EE(B,f1 1)(2) = 111110100001110011000111001100010011011111000100000001101110011011111000100110111110001001101111100010011011111010000111001100011100110111110001001101111100001011001001101111100010011011111011101011100011011111000100110111110001001101111100011101111100101111100011101111101001111100010011011111000100110111110001000111110110

1Blo EP(F,f3 1) = 111110001001101110001011110001001101111100010011111110001111100010011011111000100110110000010011000100110100011010011000100110111110001001101111100010011111001101111100010011011111000100110111110001110000111000111110001000111110110111110001001101111100010011011111000100110111110011100000100110100011010011000100110011000111111000100110111110001001101111100011101111101001111100010011011111000100110111110001000111110110

e = e(f1 1)

SepInit EE(B,f1 1)(2) = 111110100001110011000111001100010011011111000100000001101110011011111000100110111110001001101111100010011011111010000111001100011100110111110001001101

Page 47: Reproducing the cyclic tag system developed by Matthew Cook … · 2019-10-20 · Email: schapa@cs.cinvestav.mx Abstract. This paper implements the cyclic tag system (CTS) in Rule

111100001011001001101111100010011011111011101011100011011111000100110111110001001101111100011101111100101111100011101111101001111100010011011111000100110111110001000111110110

217e = 217e(f1 1) - . . .


Recommended