Universal One-Dimensional Cellular Automata Derived for Turing Machines and its Dynamical Behaviour

07/06/2019 ∙ by Sergio J. Martinez, et al. ∙ UWE Bristol 0

Universality in cellular automata theory is a central problem studied and developed from their origins by John von Neumann. In this paper, we present an algorithm where any Turing machine can be converted to one-dimensional cellular automaton with a 2-linear time and display its spatial dynamics. Three particular Turing machines are converted in three universal one-dimensional cellular automata, they are: binary sum, rule 110 and a universal reversible Turing machine.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 5

page 7

page 11

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In this paper, we research the spacial dynamics of Turing machines as discrete dynamical systems and its conversion as cellular automata. Cellular automata are dynamical systems that evolve in states and time discrete. Historically cellular automata are used recurrently to explore novel unconventional domains of computability across of signals, gliders, particles, waves, and mobile self-localization interactions [7, 22, 29, 1, 12, 11, 17, 31].

Turing machines are computable models invented by Alan Turing in 1936 to proof if a problem has a solution or not [26, 24, 5]. The behaviour of such machine is displayed as a sequence of instantaneous descriptions, which describes a string on an infinite tape where every instantaneous description is determined by the sequential selection of a rule from a finite set of rules. If such sequence of instantaneous descriptions reaches a final state or cannot do more descriptions hence the computation is done.

Frequently the construction of computers in cellular automata are handled just with primitive signals (classic examples include von Neumann rule [27], Codd [3], Banks [2]) or with non-trivial patterns known as gliders, particles, waves or self-localizations (classic examples include the Game of Life [6], Rule 110 [4, 30]), and recently by packages of signals ([18, 10]). Actually, we have some Turing machines implemented in cellular automata, one of them in the Game of Life by Paul Rendell [23] and in one dimension by Smith [25] and other by Lindgren and Nordahl [9].

The paper has the next structure. Initially, we introduce basic concepts to Turing machines and cellular automata. Later, we show an algorithm able to convert a Turing machine to its equivalent one-dimensional cellular automaton. Finally, we show conversions of three particular Turing machines to three one-dimensional cellular automata.

2 Basic concepts

2.1 Turing machines

A Turing machine is defined as a 7-tuple , where is the finite set of states, the alphabet of input symbols, is the complete set of symbols in the tape, the transition function, the start state, the blank symbol and the set of final or accepting states. The transition function determines relations between a state with a symbol to other state, as follows: and , and a direction (left or right). This way, the language that a Turing machine can recognize is defined as , where is a string of and denotes a move of a Turing machine [8, 16].

2.2 Cellular automata

One-dimensional cellular automata is represented by an array of cells where and each takes a value from a finite alphabet . Thus, a sequence of cells {} of finite length describes a string or global configuration on . The set of finite configurations will be expressed as . An evolution is comprised by a sequence of configurations produced by the mapping ; thus the global relation is symbolized as: , where represents time and every global state of is defined by a sequence of cell states. The global relation is determined over the cell states in configuration updated at the next configuration simultaneously by a local function as follows: . Wolfram represents one-dimensional cellular automata with two parameters , where is the number of states, and is the neighbourhood radius. In this domain, we have that determines the number of neighbourhoods of size , and represents the number of distinct evolution rules [28, 14].

3 Converting a Turing machine to a one-dimensional cellular automaton

In 1971 [25], Alvy Smith III proved that a Turing machine of internal states and tape symbols in 2-linear time can be simulated by a one-dimensional cellular automaton with a neighbourhood of radius and colours (cellular automata states). Later in 1990 [9], Lindgren and Nordahl pointed that not all colours is necessary to accomplish this and asserted that colours are necessary. It is plus the cardinality of the set of pairs such that it is possible for the machine to reach such state by moving in such direction. Nevertheless, this number of colours is not enough to do the simulation according to the idea shown by Smith, since there are needed at least 2 colours to represent the machine’s head when it moves to the left. This way, the smaller number of colours required to accomplish this particular simulation is ( plus plus the cardinality of the set of states that can be reached by moving to the left).

3.1 Algorithm construction

To an arbitrary Turing machine there exists a one-dimensional equivalent cellular automaton with an alphabet and radius . So, it is constructed from [9], as following.

, where is a set of auxiliary symbols that will help to simulate the movements of the head to the left. So, the number of auxiliary symbols for the cellular automaton will be . Note that is formed by the union of a set of tape symbols and a set of states . This is possible because they are both treaties just as sets of symbols and not as symbols and states separately.

The movements to the right for a cellular automaton is defined in the next way:

.

.

where is a natural number on and indicates every symbol on . That means that for every rule shown, there are defined rules on . By applying this rules, we get a behaviour like this,

Table 1: Simulation of the head movements to the right

where . Finally, for the Turing machine’s transitions to the left, , we define the following rules on .

.

.

is a new symbol and it is an auxiliary symbol which indicates that in the next time step the head of the machine will move to the left. To simulate this one, we need add the next rule.

.

.

By applying these rules, we get a behaviour like this ():

Table 2: Simulation of the head movements to the left

Note that the simulation of a Turing machine by using these rules will take at most twice the time used by the Turing machine itself.

3.2 Algorithm description

By generalizing the sets of rules shown, we can build an algorithm such that, given a Turing machine as input produces an equivalent cellular automaton .

Data: Turing machine,
Result: One-dimensional cellular automaton,
;
;
for every such that  do
       if D = Right then
             Add to ;
             Add to ;
            
       end if
      if D = Left then
             if  then
                   Add to ;
                   Add to ;
                   Add to ;
                  
             end if
            Add to ;
             Add to ;
            
       end if
      
end for
for every undefined ,  do
       Add to ;
      
end for

Note that the cycle at the end of the algorithm that takes time, where . It is only used to indicate that every undefined combination of symbols will keep constant. By taking this for granted, the algorithm takes just time where and .

Figure 1: Behaviour of the Turing machine and its equivalent cellular automaton for the input string . (left) Representation of the symbols. (center) Turing machine dynamics. (right) Cellular automaton dynamics.

3.3 Simulation ending

The halting condition is well specified for Turing machines but not for cellular automata. For a cellular automaton the simulation of a Turing machine ends when the global configuration remains constant. This way, the automaton has finished the analysis of the string at a time step when .

Similarly, we say the string has been accepted by if where , once has ended the simulation at a time step .

4 Universal cellular automata from Turing machines

4.1 Binary sum

A classic example in computer science is the design of computable functions performing arithmetical operations. In this way, a Turing machine performing sum is our first case of study.

Let be a Turing machine capable of recognizing strings of the form , where are binary numbers and returning (this machine was presented in [16, 15]). , , and is the transition function shown in the Table 3. is the initial state of the machine and is the blank symbol.

State
Table 3: Transition table for the binary sum Turing machine .

The behaviour of the Turing machine for the input string , is shown in Fig. 3(center). By using as input for the algorithm described, we get a cellular automaton , thich behaves almost as . This is shown in Fig. 3(right). As we can see, the inputs and outputs of both and are the same, that means the simulation was done properly. However, the behaviour of both models is not exactly alike; takes twice the time of to move its head to the left. The set of rules defined for is shown in Table 4.

equivalent transitions
-
-
-
-
-
-
-
-
-
1 1
1
0 0
0
0
0 =
1
1 =
+
0
0 0
1
1 1
+
0
0 0
1
1 1
+
0
0
1
1
Table 4: Set of rules defined for to simulate .
=
=
0
0
1
1
=
=
0 1
0
1
1 0
=
= 1
=
0 0
0
1 1
1
+ +
+
=
=
0
0 0
1
1 1
=
=
0 0
0
1 1
1
0
1
+
+
Figure 2: Dynamical behaviour of the Turing machine and its equivalent cellular automaton for the input string . (left) Representation of the symbols. (center) Turing machine dynamics. (right) Cellular automaton dynamics.

The input string for both and is . The instantaneous description of when it stops is . The global configuration of at the end of the simulation is .

4.2 Rule 110

The second case of study is the famous elementary cellular automaton Rule 110, for details see [13, 19].222Rule 110 repository. http://uncomp.uwe.ac.uk/genaro/Rule110.html This rule is computationally universal simulating a cyclic tag system with a complicated system of gliders and collisions, for details see [30, 20].333Cyclic tag system working in Rule 110. http://uncomp.uwe.ac.uk/genaro/rule110/ctsRule110.html

state 0 1
Table 5: Turing machine transition table that simulate Rule 110.

Let the Turing machine be capable of simulating the behaviour of the elementary cellular automaton Rule 110. This machine is one of several proposed with the same capacities described in Cook’s paper [4]. This way, is the set of states of the machine, is the set of input symbols, is the complete set of tape symbols, is the transition function shown in Table 5, is the initial state of the machine and is the blank symbol.

equivalent transitions
-
0 0
0
1 1
1
0
0 1
0
1 1
1
0 1
0
1 0
1
0
0 0
1
1 1
0
Table 6: Set of rules defined for to simulate .

Following the algorithm, we have the whole set of rules defined for the cellular automaton to simulate in Table 5.

The input string for both and machines is . The instantaneous description of when it stops is (Fig. 2 center). The global configuration of at the end of the simulation is (Fig. 2 right).

We will note that in this system is not relevant a halt condition because the goal is yield the belong string. In a cellular space for Rule 110 starting with the string , it yields the string five generations later.

4.3 Reversible Turing machine

Figure 3: Dynamical behaviour of the Turing machine and its equivalent cellular automaton for the input string . (left) Representation of the symbols. (center) Turing machine dynamics. (right) Cellular automaton dynamics.

In our last case, we consider a special kind of Turing machines that are reversible in its table transitions. It is an universal reversible Turing machine able to simulate any cyclic tag system proposed by Morita and Yamaguchi with 17 states and five symbols. For details see [21].

Let the Turing machine be which is an universal reversible Turing machine. is the set of states of the machine, is the set of input symbols, is the complete set of tape symbols, is the transition function shown in the Table 7, is the initial state of the machine and is the blank symbol.

State * $
Table 7: Transition table for a universal reversible Turing machine .

As we did in the last two examples, we can observe that both, the behaviour of the Turing machine (Fig. 3 center) and the behaviour of its equivalent cellular automaton (Fig. 3 right) differ only in the amount of time required to process the movements of the head to the left. The set of rules defined for is shown in Table 8.

equivalent transitions
-
-