A note on accelerated Turing machines

In this note we prove that any Turing machine which uses only a finite computational space for every input cannot solve an uncomputable problem even in case it runs in accelerated mode. We also propose two ways to define the language accepted by an accelerated Turing machine. Accordingly, the classes of languages accepted by accelerated Turing machines are the closure under Boolean operations of the sets Σ1 and Σ2. 1. ACCELERATED TURING MACHINES An accelerated Turing machine (sometimes called Zeno machine) is a Turing machine that takes 2−n units of time (say seconds) to perform its nth step; we assume that steps are in some sense identical except for the time taken for their execution. Such a machine can run an infinite number of steps in one unit of time. Accelerated Turing machines have been discovered by Weyl [25] in 1927 and studied by various authors including Boolos and Jeffrey [2], Calude and Păun [4], Copeland [3], Ord [11], Potgieter [12], Shagrir [15, 16], Stewart [21], Svozil [22]. The main feature of an accelerated Turing machine consists in its capability of computing in a finite time an infinite sequence of steps, thus allowing it to solve uncomputable problems. For example, the following (informal) accelerated Turing machine can solve the halting problem of an arbitrarily given Turing machine T and input w in finite time: begin program write 0 on the first position of the output tape; set i = 1; begin loop simulate the first i steps of T on w; if T(w) has halted, then write 1 on the first position of the output tape; i = i + 1; end loop end program Calude: Department of Computer Science, The University of Auckland, Private Bag 92019, Auckland, New Zealand, [email protected]. Staiger: Martin-Luther-Universität Halle-Wittenberg, Institut für Informatik, D 06099 Halle, Germany, [email protected]. Work done during L. Staiger’s visit to CDMTCS in January 2009. 2 CRISTIAN S. CALUDE, LUDWIG STAIGER By inspecting the first position of the output tape we need one unit of time to run the above machine in order to decide whether T(w) stops or not. Alternatively, we can clock the computation and see whether the machine itself has halted before one unit of time or not. Note that Svozil [22] proved that the halting problem of accelerated Turing machines is not decidable by any accelerated Turing machine. Relativistic computation computation offers a physical model for acceleration, see [9, 6, 1]. Are accelerated Turing machines physically possible? This is a challenging problem discussed by various authors. We contribute with a small result to this discussion by examining the computational space required by an accelerated Turing machine running an infinite computation: is it finite or not? This question was posed to the first author by Fearnley [8]. 2. IS THE SPACE USED BY AN ACCELERATED TURING MACHINE ALWAYS FINITE? Let us start with the following informal example: set i=0; begin loop i=i+1; end loop It is clear that the accelerated Turing machine executing the above set of instructions needs an infinite computational space. Is this just an accident or do we have a more general situation? Before being tempted by a hasty answer let us note that the following set of instructions is infinite, but requires only a finite amount of space: set i=1; while (i > 0) do i=1; end while To be able to answer the above question we will introduce a formal model of Turing machine and we state a few general facts. We assume that reader is familiar with the basics of Turing computability, e.g. [17, 24]. Let (X, Γ, S, s0, , δ) be a Turing machine in which X is the input alphabet, Γ ⊃ X is the work tape alphabet, S is the set of states, s0 is the initial state, ∈ Γ \ X is the blank symbol1, and δ is the (partial) transition function. We assume that the Turing machine has one tape where initially the input is written on, and the machine starts its processing in state s0 by scanning the first symbol of the input word. A configuration of the Turing machine is a word k ∈ Γ∗SΓ∗, where the first and last symbols are different from the blank symbol . Here states (in S) are considered also to be symbols, so for uniqueness we assume that S ∩ Γ = ∅. A configuration w1sw2, with 1We explicitly exclude the blank symbol from the input alphabet. A NOTE ON ACCELERATED TURING MACHINES 3 w1, w2 ∈ Γ∗, s ∈ S describes the machine with w1w2 on the tape, in state s with the head scanning the first symbol of w2. If w2 is the empty word then the right part of the (infinite) tape is assumed to contain only blank symbols. If w1 is the empty word then the infinite tape left to the cell scanned by the machine is assumed to contain only blank symbols. The successor configuration of a configuration k = w1sw2 is obtained by a simple local re-writing process derived only from δ, s and its left and right neighbour letters in k. Let M = (X, Γ, S, s0, , δ) be a Turing machine and x an input word. We define the computational space used by M on x, spaceM(x), to be the number—finite or infinite—of cells used by M on x. The function timeM(x) denotes the number of steps executed by M on input x (see [24]). By M(x) < ∞ we denote the fact that M stops on x. Clearly, spaceM(x) < ∞ whenever M(x) < ∞, and M(x) = ∞ iff timeM(x) = ∞. The halting problem for M is the problem of deciding given x whether M(x) < ∞. It is well known that for most Turing machines M, the halting problem for M is undecidable. A simple counting2 argument justifies the following (see [24]): Lemma 1. If M(x) < ∞, then timeM(x) ≤ |Γ|spaceM(x) · |S| · spaceM(x). Theorem 2. If for every x, spaceM(x) < ∞, then the halting problem for M is decidable. Proof. Consider the Turing machine M, input x and let spaceM(x) = cx < ∞. If M does not stop on x then the list of all configurations is infinite, but there are at most (|Γ|+ |S|)cx+1 different configurations of length cx + 1. Thus one configuration appears twice in that list. Otherwise, if M stops on x then no repetition can occur. Having in mind this observation one constructs an observer Turing machine O that lists all configurations of M generated by the computation M(x) and continues as follows: (1) If M stops on x then O stops too and declares M(x) < ∞. (2) If M does not stop on x then on the first repetition in the list of configurations generated by M(x) the machine O stops and declares that M(x) = ∞. Corollary 3. If the halting problem for M is undecidable then {x ∈ X∗ : spaceM(x) = ∞} 6= ∅. Corollary 4. If spaceM(x) < ∞, then the problem whether M(x) halts or not is algorithmically decidable. Corollary 5. The set {(M, x) : M Turing machine, x ∈ X∗, spaceM(x) < ∞} is computably enumerable but not computable. 2|Y| denotes the cardinality of the set Y. 4 CRISTIAN S. CALUDE, LUDWIG STAIGER A Turing machine M running in ‘accelerated mode’ is denoted by AM. In other words, M and AM have the same description, but M runs in normal mode, i.e. each instruction is executed in a fixed unit of time, while AM runs in an accelerated mode. Observe that M(x) = ∞ iff timeM(x) = ∞ iff timeAM(x) = 1. There is a similarity between computational time and space; however, this parallel is not perfect. For example, it is not true that an accelerated Turing machine which uses unbounded space has to use an infinite space for some input (as it seems to be claimed in Ord [11, p. 24]). The reason is that every reasonable computable problem requires at least the input data x to be scanned, so it needs at least a space greater than the length of x. Let χM : X∗ → {0, 1} be the function defined by χM(x) = { 1, if M(x) < ∞, 0, otherwise. This function can always be computed by an accelerated Turing machine AM′ in finite time.3 If the computational space is finite for every input, then acceleration does not add computational power: Corollary 6. Let AM be an accelerated Turing machine with spaceAM(x) < ∞ for all inputs x. Then the function χM is Turing computable. Again, the Turing machine computing χM is not necessarily M. 3. COMPUTATIONAL POWER How can we use accelerated Turing machines to trespass the Turing barrier, more precisely, to accept languages other than computably enumerable ones? A proposal based on physical considerations to use accelerated Turing machines with an oracle provided by another accelerated Turing machine was made in [26]. Here we pursue a different approach dating back to the late 1970s where infinite acceptance processes for Turing machines were considered [5, 7, 20]. These processes consider acceptance conditions based on the set of states occurring or occurring infinitely often during the computation process. To this end we pair the machine M with one or two observer machines M′ and M′′. There are two ways to observe the computation of M and decide its output. In the first case the output is based on the set of states occurring during the computation. The machine M′ simply collects the (finite) set of states Sx occurring during M’s computation process on input x. In the second case the output is based on the set of states occurring occurring infinitely often during the computation. During the computation of M the first observer machine M′ writes into cell i of its output tape successively (a symbol denoting) the set of states Sx(i, t) the machine M runs through starting from step i up to step t. Thus, after finishing AM′ is not necessarily equal to AM. A NOTE ON ACCELERATED TURING MACHINES 5 its work, cell i contains (a symbol denoting) the set of states M has run through starting from moment i on. This sequence of sets is non-increasing, so the second observer machine M′′ can compute its limit Sx. In both cases, the input word x is accepted according to whether Sx satisfies a previously given condition. The processes considered here may stop or not after finitely many steps. To treat both cases in a uniform way we assume in the first case the last state is repeated indefinitely. In this way we don’t need to test whether the computation of M eventually stops or not, so we avoid paradoxes like the Thompson lamp, [23]. A detailed account of such acceptance processes is given in the survey papers [10, 19]. We denote by ran(M, x) ( in(M, x), respectively) the set of states Sx of M occurring (occurring infinitely often, respectively) in the computation process on input x. For an accelerated Turing machine M = (X, Γ, S, s0, , δ) and a subset S ⊆ 2S define the following languages ATran(M,S) := {x : ran(M, x) ∈ S} (1) ATin(M,S) := {x : in(M, x) ∈ S} (2) Let Σ1, Π1, Π2 and Σ2 be the first classes of the arithmetical hierarchy of languages (see [13, 24]). In particular, Σ1 is the class of computably enumerable languages and Π1 is the class of their complements. By Bool(M) we denote the closure of a set of setsM under Boolean operations. Based on [18], we have the following results: Theorem 7. For the classes of accepted languages the following identities hold true: {ATran(M,S) : M = (X, Γ, S, s0, , δ) ATM ∧ S ⊆ 2S} = Bool(Σ1), {ATin(M,S) : M = (X, Γ, S, s0, , δ) ATM ∧ S ⊆ 2S} = Bool(Σ2).