Halting problem explained

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. The halting problem is undecidable, meaning that no general algorithm exists that solves the halting problem for all possible program–input pairs. The problem comes up often in discussions of computability since it demonstrates that some functions are mathematically definable but not computable.

A key part of the formal statement of the problem is a mathematical definition of a computer and program, usually via a Turing machine. The proof then shows, for any program that might determine whether programs halt, that a "pathological" program exists for which makes an incorrect determination. Specifically, is the program that, when called with some input, passes its own source and its input to f and does the opposite of what predicts will do. The behavior of on shows undecidability as it means no program will solve the halting problem in every possible case.

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

while (true) continue

does not halt; rather, it goes on forever in an infinite loop. On the other hand, the program

[["Hello, World!" program|print "Hello, world!"]]

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. However, as long as the program is running, it is unknown whether it 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 produce contradictory output and therefore cannot be correct.

Programming consequences

Some infinite loops can be quite useful. For instance, event loops are typically coded as infinite loops.^[1] However, most subroutines are intended to finish.^[2] 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.^[3]

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:^[4]

However, a computer with a million small parts, each with two states, would have at least 2^1,000,000 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

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, including the halting problem which emerged in the 1950s.

Timeline

• ^[5]
  • • • ^[6]
  • ^[7]
    • ^[8]
    • ^[9]

Origin of the halting problem

Many papers and textbooks refer the definition and proof of undecidability of the halting problem to Turing's 1936 paper. However, this is not correct. Turing did not use the terms "halt" or "halting" in any of his published works, including his 1936 paper.^[10] A search of the academic literature from 1936 to 1958 showed that the first published material using the term “halting problem” was . However, Rogers says he had a draft of available to him, and Martin Davis states in the introduction that "the expert will perhaps find some novelty in the arrangement and treatment of topics", so the terminology must be attributed to Davis. Davis stated in a letter that he had been referring to the halting problem since 1952.^[9] The usage in Davis's book is as follows:

A possible precursor to Davis's formulation is Kleene's 1952 statement, which differs only in wording:

The halting problem is Turing equivalent to both Davis's printing problem ("does a Turing machine starting from a given state ever print a given symbol?") and to the printing problem considered in Turing's 1936 paper ("does a Turing machine starting from a blank tape ever print a given symbol?"). However, Turing equivalence is rather loose and does not mean that the two problems are the same. There are machines which print but do not halt, and halt but not print. The printing and halting problems address different issues and exhibit important conceptual and technical differences. Thus, Davis was simply being modest when he said:

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

See main article: Decision problem.

The conventional representation of decision problems is the set of objects possessing the property in question. The halting set

K = 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.^{[11] [12]} 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: if halts(g): loop_forever

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:

h(i,x) = \begin{cases} 1 & if program i haltsoninput x, \\ 0 & otherwise. \end{cases} Here program i refers to the i th program in an enumeration of all the programs of a fixed Turing-complete model of computation.

f(i,j)		i
		1	2	3	4	5	6
j	1	1	0	0	1	0	1
2	0	0	0	1	0	0
3	0	1	0	1	0	1
4	1	0	0	1	0	0
5	0	0	0	1	1	1
6	1	1	0	0	1	0
	f(i,i)	1	0	0	1	1	0
	g(i)	U	0	0	U	U	0

Possible values for a total computable function f arranged in a 2D array. The orange cells are the diagonal. The values of f(i,i) and g(i) are shown at the bottom; U indicates that the function g is undefined for a particular input value.

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:

g(i) = \begin{cases} 0 & if f(i,i) = 0 ,\\ undefined & otherwise. \end{cases}

The verification that g is computable relies on the following constructs (or their equivalents):

• computable subprograms (the program that computes f is a subprogram in program e),
• duplication of values (program e computes the inputs i,i for f from the input i for g),
• conditional branching (program e selects between two results depending on the value it computes for f(i,i)),
• not producing a defined result (for example, by looping forever),
• returning a value of 0.

The following pseudocode for e illustrates a straightforward way to compute g:

procedure e(i): if f(i, i)

0 then return 0 else loop forever

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:

• f(e,e) = 0 and so g(e) = 0. In this case program e halts on input e, so h(e,e) = 1.
• f(e,e) ≠ 0 and so g(e) is undefined. In this case program e does not halt on input e, so h(e,e) = 0.

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 gs 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

See main article: Computability theory.

A typical method of proving a problem

P to be undecidable is to reduce the halting problem to P .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.

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.

Approximations

Turing's proof shows that there can be no mechanical, general method (i.e., a Turing machine or a program in some equivalent model of computation) to determine whether algorithms halt. However, each individual instance of the halting problem has a definitive answer, which may or may not be practically computable. Given a specific algorithm and input, one can often show that it halts or does not halt, and in fact computer scientists often do just that as part of a correctness proof. There are some heuristics that can be used in an automated fashion to attempt to construct a proof, which frequently succeed on typical programs. This field of research is known as automated termination analysis.

Some results have been established on the theoretical performance of halting problem heuristics, in particular the fraction of programs of a given size that may be correctly classified by a recursive algorithm. These results do not give precise numbers because the fractions are uncomputable and also highly dependent on the choice of program encoding used to determine "size". For example, consider classifying programs by their number of states and using a specific "Turing semi-infinite tape" model of computation that errors (without halting) if the program runs off the left side of the tape. Then

\lim _{n\toinfty} P(x haltsisdecidable \mid x has n states ) = 1 , over programs x chosen uniformly by number of states. But this result is in some sense "trivial" because these decidable programs are simply the ones that fall off the tape, and the heuristic is simply to predict not halting due to error. Thus a seemingly irrelevant detail, namely the treatment of programs with errors, can turn out to be the deciding factor in determining the fraction of programs.^[13]

To avoid these issues, several restricted notions of the "size" of a program have been developed. A dense Gödel numbering assigns numbers to programs such that each computable function occurs a positive fraction in each sequence of indices from 1 to n, i.e. a Gödelization φ is dense iff for all

i , there exists a c > 0 such that \liminf _{n\toinfty} \#\{j \in \N : 0 \leq j < n, \phi _{i} = \phi _{j\}/n\geq} c . For example, a numbering that assigns indices 2 ^{n} to nontrivial programs and all other indices the error state is not dense, but there exists a dense Gödel numbering of syntactically correct Brainfuck programs.^[14] A dense Gödel numbering is called optimal if, for any other Gödel numbering \alpha , there is a 1-1 total recursive function f and a constant c such that for all i , \alpha _{i=\phi} _{f(i)} and f(i) \leq c i . This condition ensures that all programs have indices not much larger than their indices in any other Gödel numbering. Optimal Gödel numberings are constructed by numbering the inputs of a universal Turing machine.^[15] A third notion of size uses universal machines operating on binary strings and measures the length of the string needed to describe the input program. A universal machine U is a machine for which every other machine V there exists a total computable function h such that V (x) = U (h(x)) . An optimal machine is a universal machine that achieves the Kolmogorov complexity invariance bound, i.e. for every machine V, there exists c such that for all outputs x, if a V-program of length n outputs x, then there exists a U-program of at most length n + c outputting x.^[16]

We consider partial computable functions (algorithms)

A . For each n we consider the fraction \epsilon _{n(A)} of errors among all programs of size metric at most n , counting each program x for which A fails to terminate, produces a "don't know" answer, or produces a wrong answer, i.e. x halts and A(x) outputs DOES_NOT_HALT, or x does not halt and A(x) outputs HALTS. The behavior may be described as follows, for dense Gödelizations and optimal machines:^{[14] [16]}

• For every algorithm

A , \liminf _{n\toinfty} \epsilon _{n(A)} > 0 . In words, any algorithm has a positive minimum error rate, even as the size of the problem becomes extremely large.

• There exists

\epsilon > 0 such that for every algorithm A , \limsup _{n\toinfty} \epsilon _{n(A)} \geq \epsilon . In words, there is a positive error rate for which any algorithm will do worse than that error rate arbitrarily often, even as the size of the problem grows indefinitely.inf _{A} \liminf _{n\toinfty} \epsilon _{n(A)} = 0 . In words, there is a sequence of algorithms such that the error rate gets arbitrarily close to zero for a specific sequence of increasing sizes. However, this result allows sequences of algorithms that produce wrong answers.

• If we consider only "honest" algorithms that may be undefined but never produce wrong answers, then depending on the metric,

inf _{Arm{honest} } \liminf_ \epsilon_n(A) may or may not be 0. In particular it is 0 for left-total universal machines, but for effectively optimal machines it is greater than 0.^[16]

The complex nature of these bounds is due to the oscillatory behavior of

\epsilon _{n(A)} . There are infrequently occurring new varieties of programs that come in arbitrarily large "blocks", and a constantly growing fraction of repeats. If the blocks of new varieties are fully included, the error rate is at least \epsilon , but between blocks the fraction of correctly categorized repeats can be arbitrarily high. In particular a "tally" heuristic that simply remembers the first N inputs and recognizes their equivalents allows reaching an arbitrarily low error rate infinitely often.^[14]

Gödel's incompleteness theorems

Generalization

Many variants of the halting problem can be found in computability textbooks.^[17] Typically, these problems are RE-complete and describe sets of complexity

\Sigma ^{0} _{1} 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 is, but highly undecidable. In terms of the arithmetical hierarchy, it is

\Pi ^{0} _{2} -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

\Pi ^{0} _{2} -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

See also: Turing jump. 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, whether machines equivalent to themselves will halt.

See also

• Busy beaver
• Gödel's incompleteness theorem
• Brouwer–Hilbert controversy
• Kolmogorov complexity
• P versus NP problem
• Termination analysis
• Worst-case execution time

References

• Church. Alonzo. 1936. An Unsolvable Problem of Elementary Number Theory. American Journal of Mathematics. 2. 345–363. 2371045. 58. 10.2307/2371045.
• Book: Copeland . B. Jack . The essential Turing : seminal writings in computing, logic, philosophy, artificial intelligence, and artificial life, plus the secrets of Enigma . 2004 . Clarendon Press . Oxford . 0-19-825079-7.
• Book: Davis, Martin. Martin Davis (mathematician). The Undecidable, Basic Papers on Undecidable Propositions, Unsolvable Problems And Computable Functions. registration. Raven Press. New York. 1965. . Turing's paper is #3 in this volume. Papers include those by Godel, Church, Rosser, Kleene, and Post.
• Book: Davis, Martin. Martin Davis (mathematician). Computability and Unsolvability. McGraw-Hill. New York. 1958. .
• Book: Rogers . Hartley (Jr.) . Theory of Recursive Functions and Effective Computability . 1957 . Massachusetts Institute of Technology . en.
• Book: Stephen Kleene . Kleene . Stephen Cole . Introduction to metamathematics . 1952 . North-Holland . 0923891579. . Chapter XIII ("Computable Functions") includes a discussion of the unsolvability of the halting problem for Turing machines. In a departure from Turing's terminology of circle-free nonhalting machines, Kleene refers instead to machines that "stop", i.e. halt.
• Lucas . Salvador . The origins of the halting problem . Journal of Logical and Algebraic Methods in Programming . June 2021 . 121 . 100687 . 10.1016/j.jlamp.2021.100687. 235396831 . 10251/189460 . free .
• Book: Marvin Minsky . Minsky . Marvin . Computation: finite and infinite machines . 1967 . Prentice-Hall . Englewood Cliffs, NJ . 0131655639. . See chapter 8, Section 8.2 "Unsolvability of the Halting Problem."
• Book: Moore. Cristopher. Cristopher Moore. The Nature of Computation. Mertens. Stephan. Oxford University Press. 2011. 978-0-19-923321-2. 10.1093/acprof:oso/9780199233212.001.0001.
• Book: Constance Reid . Reid . Constance . Hilbert . 1996 . Copernicus . New York . 0387946748. . First published in 1970, a fascinating history of German mathematics and physics from 1880s through 1930s. Hundreds of names familiar to mathematicians, physicists and engineers appear in its pages. Perhaps marred by no overt references and few footnotes: Reid states her sources were numerous interviews with those who personally knew Hilbert, and Hilbert's letters and papers.
• Book: Sipser, Michael . Michael Sipser . 2006 . Introduction to the Theory of Computation . Second . PWS Publishing . 0-534-94728-X . Section 4.2: The Halting Problem . 173–182 . registration . https://archive.org/details/introductiontoth00sips/page/173 .
• Turing . A. M. . Alan Turing . On Computable Numbers, with an Application to the Entscheidungsproblem . Proceedings of the London Mathematical Society . Wiley . s2-42 . 1 . 1937 . 0024-6115 . 10.1112/plms/s2-42.1.230 . 230–265 . 73712 ., Turing . A. M. . On Computable Numbers, with an Application to the Entscheidungsproblem. A Correction . Proceedings of the London Mathematical Society . Wiley . s2-43 . 1 . 1938 . 0024-6115 . 10.1112/plms/s2-43.6.544 . 544–546 . This is the epochal paper where Turing defines Turing machines, formulates the halting problem, and shows that it (as well as the Entscheidungsproblem) is unsolvable.
• Book: Roger Penrose . Penrose . Roger . The emperor's new mind: concerning computers, minds, and the laws of physics . 1989 . Oxford University Press . Oxford . 0192861980 . 1990 corrected reprint. . Cf. Chapter 2, "Algorithms and Turing Machines". An over-complicated presentation (see Davis's paper for a better model), but a thorough presentation of Turing machines and the halting problem, and Church's Lambda Calculus.
• Book: Hopcroft. John E.. John Hopcroft. Ullman. Jeffrey D.. Jeffrey Ullman. Introduction to Automata Theory, Languages, and Computation. registration. Addison-Wesley. 1st. 1979. 81-7808-347-7. . See Chapter 7 "Turing Machines." A book centered around the machine-interpretation of "languages", NP-Completeness, etc.
• Book: Andrew Hodges. Hodges . Andrew . Alan Turing: the enigma. Alan Turing: The Enigma . 1983 . Simon and Schuster . New York . 0-671-49207-1. . Cf. Chapter "The Spirit of Truth" for a history leading to, and a discussion of, his proof.
• Book: Börger . Egon . Computability, complexity, logic . 1989 . North-Holland . Amsterdam . 008088704X.
• Abdulla . Parosh Aziz. Jonsson. Bengt . Verifying Programs with Unreliable Channels. Information and Computation . 1996 . 127 . 2 . 91–101 . 10.1006/inco.1996.0053. free .
• Collected works of A.M. Turing
  • Book: Good . Irving John . Pure Mathematics . 1992 . North-Holland . 978-0-444-88059-8 . en.
  • Book: Gandy . R. O. . Yates . C. E. M. . Mathematical Logic . 5 December 2001 . Elsevier . 978-0-08-053592-0 . en.
  • Book: Ince . D.C. . Mechanical Intelligence . 1992 . North-Holland . 978-0-444-88058-1 . en.
  • Book: Saunders . P. T. . Morphogenesis . 26 November 1992 . Elsevier . 978-0-08-093405-1 . en.

Further reading

• • Alfred North Whitehead and Bertrand Russell, Principia Mathematica to *56, Cambridge at the University Press, 1962. Re: the problem of paradoxes, the authors discuss the problem of a set not be an object in any of its "determining functions", in particular "Introduction, Chap. 1 p. 24 "...difficulties which arise in formal logic", and Chap. 2.I. "The Vicious-Circle Principle" p. 37ff, and Chap. 2.VIII. "The Contradictions" p. 60ff.
• Martin Davis, "What is a computation", in Mathematics Today, Lynn Arthur Steen, Vintage Books (Random House), 1980. A wonderful little paper, perhaps the best ever written about Turing Machines for the non-specialist. Davis reduces the Turing Machine to a far-simpler model based on Post's model of a computation. Discusses Chaitin proof. Includes little biographies of Emil Post, Julia Robinson.
• Edward Beltrami, What is Random? Chance and order in mathematics and life, Copernicus: Springer-Verlag, New York, 1999. Nice, gentle read for the mathematically inclined non-specialist, puts tougher stuff at the end. Has a Turing-machine model in it. Discusses the Chaitin contributions.
• Ernest Nagel and James R. Newman, Godel’s Proof, New York University Press, 1958. Wonderful writing about a very difficult subject. For the mathematically inclined non-specialist. Discusses Gentzen's proof on pages 96–97 and footnotes. Appendices discuss the Peano Axioms briefly, gently introduce readers to formal logic.
• Book: Nicholas J.. Daras. Themistocles M. Rassias. Themistocles M.. Rassias . Modern discrete mathematics and analysis: with applications in cryptography, information systems and modeling . 2018 . Cham, Switzerland . 978-3319743240. . Chapter 3 Section 1 contains a quality description of the halting problem, a proof by contradiction, and a helpful graphic representation of the Halting Problem.
• Taylor Booth, Sequential Machines and Automata Theory, Wiley, New York, 1967. Cf. Chapter 9, Turing Machines. Difficult book, meant for electrical engineers and technical specialists. Discusses recursion, partial-recursion with reference to Turing Machines, halting problem. Has a Turing Machine model in it. References at end of Chapter 9 catch most of the older books (i.e. 1952 until 1967 including authors Martin Davis, F. C. Hennie, H. Hermes, S. C. Kleene, M. Minsky, T. Rado) and various technical papers. See note under Busy-Beaver Programs.
• Busy Beaver Programs are described in Scientific American, August 1984, also March 1985 p. 23. A reference in Booth attributes them to Rado, T.(1962), On non-computable functions, Bell Systems Tech. J. 41. Booth also defines Rado's Busy Beaver Problem in problems 3, 4, 5, 6 of Chapter 9, p. 396.
• David Bolter, Turing’s Man: Western Culture in the Computer Age, The University of North Carolina Press, Chapel Hill, 1984. For the general reader. May be dated. Has yet another (very simple) Turing Machine model in it.
• Sven Köhler, Christian Schindelhauer, Martin Ziegler, On approximating real-world halting problems, pp.454-466 (2005) Springer Lecture Notes in Computer Science volume 3623: Undecidability of the Halting Problem means that not all instances can be answered correctly; but maybe "some", "many" or "most" can? On the one hand the constant answer "yes" will be correct infinitely often, and wrong also infinitely often. To make the question reasonable, consider the density of the instances that can be solved. This turns out to depend significantly on the Programming System under consideration.
• Logical Limitations to Machine Ethics, with Consequences to Lethal Autonomous Weapons - paper discussed in: Does the Halting Problem Mean No Moral Robots?

External links

• Scooping the loop snooper - a poetic proof of undecidability of the halting problem
• animated movie - an animation explaining the proof of the undecidability of the halting problem
• A 2-Minute Proof of the 2nd-Most Important Theorem of the 2nd Millennium - a proof in only 13 lines
• haltingproblem.org - popular videos and documents explaining the Halting Problem.

Notes and References

1. Book: McConnell, Steve . Code Complete . 2nd . Pearson Education . 2004 . 9780735636972 . 374 .
2. Book: Huang, Han-Way . [{{GBurl|5atwJG7D_HMC}} The HCS12 / 9S12: An Introduction to Software and Hardware Interfacing ]. 197 . "... if the program gets stuck in a certain loop, ... figure out what's wrong." . 2009.
3. Book: Simon, David E. . [{{GBurl|xG2ZD55_BJAC}} An Embedded Software Primer ]. 1999 . 253 . "For hard real-time systems, therefore, it is important to write subroutines that always execute in the same amount of time or that have a clearly identifiable worst case.".
4. . italics in original

5. Davis' commentary in

6. reprinted in
7. A Note on the Entscheidungsproblem, reprinted in
8. Rosser, "Informal Exposition of Proofs of Gödel's Theorem and Church's Theorem", reprinted in
9. letter from Davis to Copeland, 12 December 2001, Footnote 61 in
10. Textual search of Turing's collected works:,,, . Similarly does not have the word "halting" or words "halting problem" in his index.
11. Strachey . C. . An impossible program . The Computer Journal . 1 January 1965 . 7 . 4 . 313 . 10.1093/comjnl/7.4.313 . free .
12. Daylight . Edgar G. . The halting problem and security's language-theoretic approach: Praise and criticism from a technical historian . Computability . 16 April 2021 . 10 . 2 . 141–158 . 10.3233/COM-180217 . 233329507 . 26 August 2021.
13. Hamkins . Joel David . Miasnikov . Alexei . The Halting Problem Is Decidable on a Set of Asymptotic Probability One . Notre Dame Journal of Formal Logic . 1 October 2006 . 47 . 4 . 10.1305/ndjfl/1168352664 . 15005164 . 5 November 2022.
14. Book: Köhler . Sven . Schindelhauer . Christian . Ziegler . Martin . Fundamentals of Computation Theory . On Approximating Real-World Halting Problems . Lecture Notes in Computer Science . 2005 . 3623 . 454–466 . 10.1007/11537311_40 . 978-3-540-28193-1 . https://www.researchgate.net/publication/221150369.
15. Lynch . Nancy . Approximations to the halting problem . Journal of Computer and System Sciences . October 1974 . 9 . 2 . 143–150 . 10.1016/S0022-0000(74)80003-6 .
16. Bienvenu . Laurent . Desfontaines . Damien . Shen . Alexander . Generic algorithms for halting problem and optimal machines revisited . Logical Methods in Computer Science . 5 April 2016 . 12 . 2 . 1 . 10.2168/LMCS-12(2:1)2016. 1505.00731. 14763862 .
17. for example,,,,,