1. Module 7 Halting Problem –Fundamental program behavior problem –A specific unsolvable problem –Diagonalization technique revisited Proof more complex 1

2. Definition Input –Program P Assume the input to program P is a single nonnegative integer –This assumption is not necessary, but it simplifies the following unsolvability proof –To see the full generality of the halting problem, remove this assumption –Nonnegative integer x, an input for program P Yes/No Question –Does P halt when run on x? Notation –Use H as shorthand for halting problem when space is a constraint 2

3. Example Input * Program with one input of type unsigned bool main(unsigned Q) { int i=3; if ((Q = = 0) || (Q= = 1)) return false; while (i<Q) { if ((Q-i) = = 1) return (false); i--; } return (true); } Input x 5 3

4. Three key definitions 4

5. Definition of list L *  P * is countably infinite where  P = {characters, digits, white space, punctuation} Type program will be type string with  P as the alphabet Define L to be the strings in  P * listed in enumeration order –length 0 strings first –length 1 strings next –…–… Every program is a string in  P –For simplicity, consider only programs that have one input the type of this input is an unsigned Consider strings in  P * that are not legal programs to be programs that always crash (and thus halt on all inputs) 5

6. Definition of P H * If H is solvable, some program must solve H Let P H be a procedure which solves H –We declare it as a procedure because we will use P H as a subroutine Declaration of P H –bool P H (program P, unsigned x) In general, the type of x should be the type of the input to P Comments –We do not know how P H works –However, if H is solvable, we can build programs which call P H as a subroutine 6

7. Definition of program D bool main(unsigned y) /* main for program D */ { program P = generate(y); if (P H (P,y)) while (1>0); // Infinite loop else return (yes); // Termination } /* generate the yth string in  P * in enumeration order */ program generate(unsigned y) bool P H (program P, unsigned x) /* how P H solves H is unknown */ 7

8. Generating P y from y * We won’t go into this in detail here –This was the basis of the question at the bottom of slide 21 of lecture 5 (alphabet for that problem was {a,b} instead of  P ). –This is the main place where our assumption about the input type for program P is important for other input types, how to do this would vary Specification –0 maps to program –1 maps to program a –2 maps to program b –3 maps to program c –…–… –26 maps to program z –27 maps to program A –…–… 8

9. Properties of D Takes One input y –Treats y as an encoding of program P –Runs P on input y –(Observe that y is being used in two ways) –If P halts on y then D goes into an infinite loop –If P does not halt on y then D stops Note that because we assumed that H is solvable, P H is guaranteed to halt and say that P does not halt on y. Next, we want to evaluate what happens if D (encoding of D as an integer) is provided as an input to D –We will show that this creates a contradiction proving that D cannot exist 9

10. Argument Overview * 10 H is solvable D is NOT on list L P H exists Definition of Solvability D exists D’s code D is on list L L is list of all programs D does NOT exist P H does NOT exist H is NOT solvable p → q is logically equivalent to (not q) → (not p)

11. Trace Program D with input (encoding of D) bool main(unsigned y) /* main for program D */ { program P = generate(y); if (P H (P,y)) while (1>0); else return (yes); } 11 Generated program is D Input y = encoding of D Does D halt on D? Yes No But Code of D says that it does not But Code of D says that it does Thus, program P H must not exist

12. Placing the Halting Problem 12 Solvable  ll Problems H

13. Implications * The Halting Problem is one of the simplest problems we can formulate about program behavior We can use the fact that it is unsolvable to show that other problems about program behavior are also unsolvable This has important implications restricting what we can do in the field of software engineering –In particular, “perfect” debuggers/testers do not exist –We are forced to “test” programs for correctness even though this approach has many flaws 13

14. Summary Halting Problem definition –Basic problem about program behavior Halting Problem is unsolvable –We have identified a specific unsolvable problem –Diagonalization technique Proof more complicated because we actually need to construct D, not just give a specification B 14