On the Halting Problem of Finite-State Programs

Transcription

1 On the Halting Problem of Finite-State Programs Raimund Kirner Vienna University of Technology, Austria, Abstract. The undecidability of the halting problem is a well-known research result of theoretical computer science, dating back to Turing s work in Nevertheless, it is commonly known that the halting problem on finite-state computer systems is decidable. Thus, any undecidability proof given for the halting problem must imply that it does not apply to finite-state computer systems. The aim of this paper is to deepen the understanding of why the undecidability proofs of the halting problem cannot be instantiated as finite-state programs. To bridge the gap between theory and practice, the arguments are based on simple mathematics rather than an extensive use of abstract formalisms. 1 Introduction Knowing whether a program eventually terminates is of outmost importance in several practical field of computer engineering. For example, in case of safetycritical real-time systems it is even important that one can bound the time interval from program start to its termination. The verification of program termination has become known as the halting problem. The halting problem of Turing machines in general is known to be undecidable, while it also known that the halting problem for all finite-state systems is decideable. There are several impossibility proofs available of the halting problem [1, 2] where it is not obvious why they do not apply to finitestate systems. Within this paper we give some insights of why such impossibility proofs do not apply to the problems faced in practice, i.e., the analysis of finite-state systems. Section 2 presents the halting problem and its algorithmic calculation (im)possibility results. In Section 3 we show why the impossibility results of the halting problem cannot be instantiated as finite-state programs, thus giving the practitioner some insights about the analyzability of programs with finite state space. This work has been partially supported by the Austrian Science Fund (Fonds zur Förderung der wissenschaftlichen Forschung) within the research project Compiler- Support for Timing Analysis (COSTA) under contract P18925-N13 and the ARTIST2 Network of Excellence (

2 2 The Halting Problem The halting problem is about the question of whether we can specify an algorithm that is able to determine whether a given program p will eventually terminate on its input i. For example, we would like to have to a program halt(p, i) as given schematically in Figure 1, that returns true if the program will terminate, and otherwise returns false. 1 h a l t ( p, i ) 2 { 3 i f ( program p h a l t s on i n p u t i ) 4 return t r u e ; // p h a l t s 5 e l s e 6 return f a l s e ; // p doesn t h a l t 7 } Fig. 1. Pseudocode of the Halting Function 2.1 Impossibility Results Within this section we describe two different impossibility proofs of the halting problem. In fact, both variants are basically equivalent. The second variant of disproof may be more intuitive for the reader unfamiliar with the analysis of the halting problem. Actually, in case of the first disproof it is obvious that in its original formulation it does not apply to realistic computers having an absolute upper bound of the possible state space, since the disproof is based on an infinite number of different machines (programs) and input data. However, we will show why both disproofs of the halting problem do no apply to any system of finite state space. It should be noted that all the disproofs of the halting problem do not imply that the halting of a concrete program cannot be determined. Instead, they imply that no universal halting function can exist that can determine the termination of all programs. That means, any halting function cannot be total, but only partial. Turing s Diagonalization Result Turing introduced in 1936 a generic computing model (know known as Turing machine) and showed that the universal halting problem is undecidable [3]. The proof relies on the diagonalization technique, applied to an unbounded array where all possible Turing machines are listed applied with all the different input data. Turing s original impossibility result was constructed based on infinite different Turing maschines and infinite different input data. Instead of the different Turing maschines one could also construct the impossibility result by using a universal Turing maschine together with an enumeration of all possible programs. It has to mentioned, that Turing has applied the diagonalization technique on an infinite number of machines (programs) and input data, thus it is obvious why this disproof technique does not apply to finite-state systems with a concrete 2

3 upper bound of state space. But we will also show why this disproof cannot be applied to any finite-state system. Strachey s Impossible Program Strachey proposed a program based on the result of an assumed halting function [2]. The way Strachey s construction and other similar constructions are used to show the impossibility of a decideable halting function is quite similar to Turing s original disproof. But the relevant difference we want to emphasize is that they do not explicitly assume an infinite number of possible machines (programs) or input data, because they directly use reductio ad absurdum to prove that both, Strachey s construction and the universal halting function cannot exist. 1 s t r a c h e y ( p ) 2 { 3 i f ( h a l t ( p, p ) == t r u e ) 4 { 5 L1 : goto L1 ; // loop f o r e v e r 6 } 7 e l s e 8 return ; 9 } Fig. 2. Strachey s Impossible Program The impossibility of Strachey s construction given in Figure 2 becomes obvious if one tries to apply the halting function as follows: halt(strachey, strachey) Since in this case strachey() itself calls halt(strachey, strachey), it is required that the direct call of halt() and the nested call provide the same result. However, this leads to a contradiction, whatever result halt() returns. Within this disproof there seems to be no indication why not it could be even applied to finite-state systems having a concrete upper bound of state space. 2.2 Possibility Result on Finite-State Systems That the halting problem can be at least theoretically solved for finite-state systems has been already argued by Minsky in 1967 [4]:...any finite-state machine, if left completely to itself, will fall eventually into a perfectly periodic repetitive pattern. The duration of this repeating pattern cannot exceed the number of internal states of the machine... It is easy to construct a simple brute-force search algorithm to solve the halting problem for any program that could be executed on a given machine. Thus, the halting problem is computable (decidable) for any finite-state program. The motivation of this article is to present some intuition about why these disproofs of the halting problem do not apply to finite-state systems. 3

4 3 Why the Impossibility Results do not Apply to Finite-State Systems In this section we will provide a constructive insight why a construction like Strachey s can t be instantiated as a finite state program. The same argument also applies for Turing s construction since they are based on the same type of self-reflection. We just use Strachey s construction because we believe that its pseudo-code representation is more convenient. 3.1 Adequate Models of Computation There are different possibilities to model computation of finite state space: Parametric state bound: Theoretical models of finite-state computation do not impose a concrete upper limit of the state space. For example, a linear bounded automaton (LBA) is basically a Turing machine with a finite tape, where the length of the tape is a linear function of the input s length. An LBA is of finite state, but there is no upper bound on the length of the input tape and on the size of the alphabet. Absolute state bound: The specialty of realistic computers is that they have a state space that is bounded to a concrete value. To give an example, Ylikoski proposed the Realistic Linear Bounded Automaton (RLBA) as an adequate model of realistic computers [5]. Modeling Resources To reason about the finiteness of the state space, we present some notation of resources that abstracts from the respresentation of any concrete computation model. The memory needed to execute a program on a finite-state system can be classified as given in Figure 3. Basically, each program consists of a static part that will not be changed during execution of the program, and a dynamic part (state space) that may be modified during execution of the program. The least upper bound of memory needed to hold the static part of a program p on a machine M 1 is denoted as size(p M1 ). The least upper bound of memory needed to hold the dynamic part of p on a machine M 1 is denoted as sp(p M1 ). The overall memory a program p requires on a machine M 1 is mem(p M1 ) = size(p M1 ) + sp(p M1 ) (1) Program Semantics vs. Machine Semantics According to the formal semantics a program may have an infinite state space. But after the program is transformed by the compiler into a program to be executed on a concrete machine M 1 with N bits of memory, it is definite that the state space of the executed program can be at maximum N bits (2 N different states). Such an enforced mapping from an infinite state space to a finite state space implies that certain states on the concrete machine have to be categorized as erroneous. As the platform-specific semantics for a real computer implies that the state space of the program is finite, the halting problem can principally be allways calculated. 4

5 dynamic part (state space) data variables modifiable code sp(p) static part data constants non modifiable code size(p) mem(p) Fig. 3. Classification of Memory Needed to Execute a Program p on a Real Computer 3.2 Analyzing a Universal Variant of halt() for Finite-State Systems Within this section we show why Strachey s construction cannot be instantiated as a finite-state program. We do not assume any specific implementation variant or specialization of the halting function halt(p, i). Lets first analyze the minimal memory requirement of a finite-space halting function fhalt(p M1, i) M2 running on machine M 2 to analyze a program p M1 running on machine M 1, given in Equation 2. sp(fhalt M2 ) size(p M1 ) + sp(p M1 ) (2) Equation 2 states that the halting function fhalt M2 at least has to allocate memory to hold the program code of p M1 and to build up the state space of p M1. Using this minimal memory resources, fhalt M2 is at least able to simulate the program p M1. More sophisticated program analysis techniques like symbolic model checking [6] even demand much more state space sp(fhalt M2 ) by constructing a Kripke structure of the analyzed program that describes the powerset of the analyzed program s state space (2 sp(p M ) 1 different states). One may argue that the minimal required resources required for fhalt M2 are lower, for example, if p M1 has a simple structure that regardless of the concrete input data always ends up in a halting state. In such a case it would not be required to build up the state space of p M1. This argument is valid, but only for a restricted class of programs. In the general case, programs have input-data dependent control flow, which at least requires to model also the state space sp(p M1 ). Applying Equation 2 to Strachey s construction, we get the following equation: sp(fhalt M2 ) size(strachey M1 ) + size(fhalt M1 ) + sp(strachey M1 ) + sp(fhalt M1 ) (3) Given the result of Equation 3 there are two possible cases: M 1 M 2 : In this case we assume that the halting function that analyzes strachey M1 () runs on a separate machine M 2 that has a sufficiently higher 5

6 state space than M 1. However, this differentiation of M 1 and M 2 is not valid, since Strachey s construction requires the halting function fhalt to be within the state space of strachey(), because strachey() calls fhalt. M 1 = M 2 : In this case we get equation Equation 4. Furthermore, for any equation a = k + a k>0 the only solution is a = ω, as it holds ω = k + ω. sp(fhalt M1 ) = k + sp(fhalt M1 ), (4) 0 < k = size(strachey M1 ) + size(fhalt M1 ) + sp(strachey M1 ) Consequently, Equation 4 has the only one solution where the state space of fhalt is infinite: sp(fhalt M1 ) = ω. Thus, we have shown that Strachey s construction (as well as Turing s construction) is of infinite state space. From above analysis we have got a constructive insight why Strachey s construction can t be instantiated as a program with finite state space. 4 Summary and Conclusion Within this paper we addressed the halting problem on finite-state programs. As an example of an impossibility proof of the halting problem we used Strachey s construction of an impossible program. This construction, as well as Turing s construction, and other similar disproofs at the first glance have no obvious indication why they would not apply to finite-state systems. Within this work we showed why the instantiation of the impossibility proofs on them cannot address finite-state systems. As a consequence, the given disproofs of the halting problem do not prohibit the existence of a total halting function for finite-state systems. The results of this paper are aimed to provide a more intuitive understanding of the halting problem. Acknowledgments The author would like to thank Christian Fermüller and Christian El Salloum for their constructive feedback on earlier versions of the document. References 1. Schneider, H.J.: Computability in an introductory course on programming. Bulletin of the European Association for Theoretical Computer Science (EATCS) 73 (2001) Strachey, C.: An impossible program. The Computer Journal 7 (1065) 313 Letter to the Editor. 3. Turing, A.M.: On computable numbers, with an application to the Entscheidungsproblem. Proc. London Mathematical Society 42 (1936) Minsky, M.: Computation, Finite and Infinite Machines. Prentice-Hall, New Jersey (1967) 5. Ylikoski, A.: The Halting Problem on finite and infinite computers. Journal of Advanced Computing Machinery 36 (2005) Clarke, E.M., Grumberg, O., Peled, D.A.: Model Checking. MIT Press (1999) ISBN: