Halting problem
In computability theory, the halting problem is the problem of determining, from a description of an arbitrary computer program and an input, whether the program will finish running, or continue to run forever. Alan Turing proved in 1936 that a general algorithm to solve the halting problem for all possible program-input pairs cannot exist. For any program "f" that might determine if programs halt, a "pathological" program "g", called with some input, can pass its own source and its input to "f" and then specifically do the opposite of what "f" predicts "g" will do. No  f can exist that handles this case. A key part of the proof is a mathematical definition of a computer and program, which is known as a Turing machine; the halting problem is "undecidable" over Turing machines. It is one of the first cases of decision problems proven to be unsolvable. This proof is significant to practical computing efforts, defining a class of applications which no programming invention can possibly perform perfectly. Jack Copeland attributes the introduction of the term "halting problem" to the work of Martin Davis in the 1950s. Background. The halting problem is a decision problem about  properties of computer programs on a fixed Turing-complete model of computation, i.e., all programs that can be written in some given programming language that is general enough to be equivalent to a Turing machine. The problem is to determine, given a program and an input to the program, whether the program will eventually halt when run with that input. In this abstract framework, there are no resource limitations on the amount of memory or time required for the program's execution; it can take arbitrarily long and use an arbitrary amount of storage space before halting. The question is  simply whether the given program will ever halt on a particular input. For example, in pseudocode, the program does not halt; rather, it goes on forever in an infinite loop. On the other hand, the program does halt. While deciding whether these programs halt is simple, more complex programs prove problematic. One approach to the problem might be to run the program for some number of steps and check if it halts. But if the program does not halt, it is unknown whether the program will eventually halt or run forever. Turing proved no algorithm exists that always correctly decides  whether, for a given arbitrary program and input, the program halts when run with that input. The essence of Turing's proof is that any such algorithm can be made to contradict itself and therefore cannot be correct. Programming consequences. Some infinite loops can be quite useful. For instance, event loops are typically coded as infinite loops. However, most subroutines are intended to finish. In particular, in hard real-time computing, programmers attempt to write subroutines that are not only guaranteed to finish, but are also guaranteed to finish before a given deadline. Sometimes these programmers use some general -purpose (Turing-complete) programming language, but attempt to write in a restricted style—such as MISRA C or SPARK—that makes it easy to prove that the resulting subroutines finish before the given deadline. Other times these programmers apply the rule of least power—they deliberately use a computer language that is not quite fully Turing-complete. Frequently, these are languages that guarantee all subroutines finish, such as Coq. Common pitfalls. The difficulty in the halting problem lies in the requirement that the decision procedure must work for all programs and inputs. A particular program either halts on a given  input or does not halt. Consider one algorithm that always answers "halts" and another that always answers "does not halt". For any specific program and input, one of these two algorithms answers correctly, even though nobody may know which one. Yet neither algorithm solves the halting problem generally. There are programs (interpreters) that simulate the execution of whatever source code they are given. Such programs can demonstrate that a program does halt if this is the case: the interpreter itself will eventually halt its simulation, which shows that the original program halted. However, an interpreter will not halt if its  input program does not halt, so this approach cannot solve the halting problem as stated; it does not successfully answer "does not halt" for programs that do not halt. The halting problem is theoretically decidable for linear bounded automata (LBAs) or deterministic machines with finite memory. A machine with finite memory has a finite number of configurations, and thus any deterministic program on it must eventually either halt or repeat a previous configuration: However, a computer with a million small parts, each with two states, would have at least 2 possible states: Although a machine may be finite, and  finite automata "have a number of theoretical limitations": It can also be decided automatically whether a nondeterministic machine with finite memory halts on none, some, or all of the possible sequences of nondeterministic decisions, by enumerating states after each possible decision. History. The halting problem is historically important because it was one of the first problems to be proved undecidable. In April 1936, Alonzo Church published his proof of the undecidability of a problem in the lambda calculus. Turing's proof was published later, in January 1937. Since then, many other undecidable problems have been described. Etymology of the phrase  halting problem. In none of his work did Turing use the word "halting" or "termination". Turing's biographer Hodges does not have the word "halting" or words "halting problem" in his index. The earliest recorded use of the words "halting problem" is in a proof by Davis in 1958: Davis adds no attribution for his proof, so one infers that it is original with him. But Davis has said that Kleene stated the proof informally. Copeland states that: Formalization. In his original proof Turing formalized the concept of "algorithm" by introducing Turing machines. However, the result is in no way  specific to them; it applies equally to any other model of computation that is equivalent in its computational power to Turing machines, such as Markov algorithms, Lambda calculus, Post systems, register machines, or tag systems. What is important is that the formalization allows a straightforward mapping of algorithms to some data type that the algorithm can operate upon. For example, if the formalism lets algorithms define functions over strings (such as Turing machines) then there should be a mapping of these algorithms to strings, and if the formalism lets algorithms define functions over natural numbers (such as computable functions) then  there should be a mapping of algorithms to natural numbers. The mapping to strings is usually the most straightforward, but strings over an alphabet with "n" characters can also be mapped to numbers by interpreting them as numbers in an "n"-ary numeral system. Representation as a set. The conventional representation of decision problems is the set of objects possessing the property in question. The "halting set" represents the halting problem. This set is recursively enumerable, which means there is a computable function that lists all of the pairs ("i", "x") it contains. However, the complement of this set is not  recursively enumerable. There are many equivalent formulations of the halting problem; any set whose Turing degree equals that of the halting problem is such a formulation. Examples of such sets include: Proof concept. Christopher Strachey outlined a proof by contradiction that the halting problem is not solvable. The proof proceeds as follows: Suppose that there exists a total computable function "halts(f)" that returns true if the subroutine "f" halts (when run with no inputs) and returns false otherwise. Now consider the following subroutine: def g(): "halts(g)" must either return true or false, because "halts" was assumed to be total. If  halts(g) returns true, then "g" will call "loop_forever" and never halt, which is a contradiction. If "halts(g)" returns false, then "g" will halt, because it will not call "loop_forever"; this is also a contradiction. Overall, "g" does the opposite of what "halts" says "g" should do, so "halts(g)" can not return a truth value that is consistent with whether "g" halts. Therefore, the initial assumption that "halts" is a total computable function must be false. Sketch of rigorous proof. The concept above shows the general method of the proof, but the computable function "halts" does not directly take a subroutine  as an argument; instead it takes the source code of a program. Moreover, the definition of "g" is self-referential. A rigorous proof addresses these issues. The overall goal is to show that there is no total computable function that decides whether an arbitrary program "i" halts on arbitrary input "x"; that is, the following function "h" (for "halts") is not computable: Here "program i" refers to the "i" th program in an enumeration of all the programs of a fixed Turing-complete model of computation. The proof proceeds by directly establishing that no total computable function with two arguments  can be the required function "h". As in the sketch of the concept, given any total computable binary function "f", the following partial function "g" is also computable by some program "e": The verification that "g" is computable relies on the following constructs (or their equivalents): The following pseudocode for "e" illustrates a straightforward way to compute "g": Because "g" is partial computable, there must be a program "e" that computes "g", by the assumption that the model of computation is Turing-complete. This program is one of all the programs on which the halting function "h" is defined. The  next step of the proof shows that "h"("e","e") will not have the same value as "f"("e","e"). It follows from the definition of "g" that exactly one of the following two cases must hold: In either case, "f" cannot be the same function as "h". Because "f" was an "arbitrary" total computable function with two arguments, all such functions must differ from "h". This proof is analogous to Cantor's diagonal argument. One may visualize a two-dimensional array with one column and one row for each natural number, as indicated in the table above. The value of "f"("i","j") is  placed at column "i", row "j". Because "f" is assumed to be a total computable function, any element of the array can be calculated using "f". The construction of the function "g" can be visualized using the main diagonal of this array. If the array has a 0 at position ("i","i"), then "g"("i") is 0. Otherwise, "g"("i") is undefined. The contradiction comes from the fact that there is some column "e" of the array corresponding to "g" itself. Now assume "f" was the halting function "h", if "g"("e") is defined ("g"("e") = 0 in this case), "g"("e") halts so "f"("e ,e") = 1. But "g"("e") = 0 only when "f"("e,e") = 0, contradicting "f"("e,e") = 1. Similarly, if "g"("e") is not defined, then halting function "f"("e,e") = 0, which leads to "g"("e") = 0 under "g"'s construction. This contradicts the assumption of "g"("e") not being defined. In both cases contradiction arises. Therefore any arbitrary computable function "f" cannot be the halting function "h". Computability theory. A typical method of proving a problem to be undecidable is to "reduce" it to the halting problem. For example, there cannot be a general algorithm that decides whether  a given statement about natural numbers is true or false. The reason for this is that the proposition stating that a certain program will halt given a certain input can be converted into an equivalent statement about natural numbers. If an algorithm could find the truth value of every statement about natural numbers, it could certainly find the truth value of this one; but that would determine whether the original program halts. Rice's theorem generalizes the theorem that the halting problem is unsolvable. It states that for "any" non-trivial property, there is no general decision procedure that, for  all programs, decides whether the partial function implemented by the input program has that property. (A partial function is a function which may not always produce a result, and so is used to model programs, which can either produce results or fail to halt.) For example, the property "halt for the input 0" is undecidable. Here, "non-trivial" means that the set of partial functions that satisfy the property is neither the empty set nor the set of all partial functions. For example, "halts or fails to halt on input 0" is clearly true of all partial functions, so it  is a trivial property, and can be decided by an algorithm that simply reports "true." Also, this theorem holds only for properties of the partial function implemented by the program; Rice's Theorem does not apply to properties of the program itself. For example, "halt on input 0 within 100 steps" is "not" a property of the partial function that is implemented by the program—it is a property of the program implementing the partial function and is very much decidable. Gregory Chaitin has defined a halting probability, represented by the symbol Ω, a type of real number that informally  is said to represent the probability that a randomly produced program halts. These numbers have the same Turing degree as the halting problem. It is a normal and transcendental number which can be defined but cannot be completely computed. This means one can prove that there is no algorithm which produces the digits of Ω, although its first few digits can be calculated in simple cases. While Turing's proof shows that there can be no general method or algorithm to determine whether algorithms halt, individual instances of that problem may very well be susceptible to attack. Given a  specific algorithm, one can often show that it must halt for any input, and in fact computer scientists often do just that as part of a correctness proof. But each proof has to be developed specifically for the algorithm at hand; there is no "mechanical, general way" to determine whether algorithms on a Turing machine halt. However, there are some heuristics that can be used in an automated fashion to attempt to construct a proof, which succeed frequently on typical programs. This field of research is known as automated termination analysis. Since the negative answer to the halting problem shows  that there are problems that cannot be solved by a Turing machine, the Church–Turing thesis limits what can be accomplished by any machine that implements effective methods. However, not all machines conceivable to human imagination are subject to the Church–Turing thesis (e.g. oracle machines). It is an open question whether there can be actual deterministic physical processes that, in the long run, elude simulation by a Turing machine, and in particular whether any such hypothetical process could usefully be harnessed in the form of a calculating machine (a hypercomputer) that could solve the halting problem for a  Turing machine amongst other things. It is also an open question whether any such unknown physical processes are involved in the working of the human brain, and whether humans can solve the halting problem. Generalization. Many variants of the halting problem can be found in computability textbooks. Typically, these problems are RE-complete and describe sets of complexity formula_3 in the arithmetical hierarchy, the same as the standard halting problem. The variants are thus undecidable, and the standard halting problem reduces to each variant and vice-versa. However, some variants have a higher degree of unsolvability and cannot be  reduced to the standard halting problem. The next two examples are common. Halting on all inputs. The "universal halting problem", also known (in recursion theory) as "totality", is the problem of determining, whether a given computer program will halt "for every input" (the name "totality" comes from the equivalent question of whether the computed function is total). This problem is not only undecidable, as the halting problem, but highly undecidable. In terms of the arithmetical hierarchy, it is formula_4-complete. This means, in particular, that it cannot be decided even with an oracle for the halting problem. Recognizing partial  solutions. There are many programs that, for some inputs, return a correct answer to the halting problem, while for other inputs they do not return an answer at all. However the problem "given program "p", is it a partial halting solver" (in the sense described) is at least as hard as the halting problem. To see this, assume that there is an algorithm PHSR ("partial halting solver recognizer") to do that. Then it can be used to solve the halting problem, as follows: To test whether input program "x" halts on "y", construct a program "p" that on input ("x","y ) reports true" and diverges on all other inputs. Then test "p" with PHSR. The above argument is a reduction of the halting problem to PHS recognition, and in the same manner, harder problems such as "halting on all inputs" can also be reduced, implying that PHS recognition is not only undecidable, but higher in the arithmetical hierarchy, specifically formula_4-complete. Lossy computation. A "lossy Turing machine" is a Turing machine in which part of the tape may non-deterministically disappear. The halting problem is decidable for a lossy Turing machine but non-primitive recursive. Oracle machines. A machine with an  oracle for the halting problem can determine whether particular Turing machines will halt on particular inputs, but they cannot determine, in general, if machines equivalent to themselves will halt.