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

2. 2 Definition Input –Program P Assume the input to program P is a single unsigned int –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

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

4. 4 Three key definitions

5. 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 int Consider strings in  P * that are not legal programs to be programs that always crash (and thus halt on all inputs)

6. 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 int 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

7. 7 bool main(unsigned int y) /* main for program D */ { program P = generate(y); if (P H (P,y)) while (1>0); else return (yes); } /* generate the yth string in  P * in enumeration order */ program generate(unsigned int y) /* code for extra credit program of slide 21 from lecture 5 did this for {a,b}* */ bool P H (program P, unsigned int x) /* how P H solves H is unknown */ Definition of program D

8. 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 –…–…

9. 9 Proof that H is not solvable

10. 10 Argument Overview * 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 pq is logically equivalent to (not q)(not p)

11. 11 Proving D is not on list L Use list L to specify a program behavior B that is distinct from all real program behaviors (for programs with one input of type unsigned int) –Diagonalization argument similar to the one for proving the number of languages over {a} is uncountably infinite –No program P exists that exhibits program behavior B Argue that D exhibits program behavior B –Thus D cannot exist and thus is not on list L

12. 12 Non-existent program behavior B

13. 13 Visualizing List L * P0P0 P1P1 P2P2 P3P3 P4P4...  1234 HHHHH NHHHH HH H H H HH #Rows is countably infinite  p * is countably infinite #Cols is countably infinite Set of n  nnegative integers is countably infinite Consider each number to be a feature –A program halts or doesn’t halt on each integer –We have a fixed L this time

14. 14 Diagonalization to specify B * P0P0 P1P1 P2P2 P3P3 P4P4...  1234 HHHHH NHHHH HH H H H HH We specify a non-existent program behavior B by using a unique feature (number) to differentiate B from P i NH H H H B

15. 15 Arguing D exhibits program behavior B

16. 16 bool main(unsigned int y) /* main for program D */ { program P = generate(y); if (P H (P,y)) while (1>0); else return (yes); } /* generate the yth string in  P * in enumeration order */ program generate(unsigned int y) /* code for extra credit program of slide 21 from lecture 5 did this for {a,b}* */ bool P H (program P, unsigned int x) /* how P H solves H is unknown */ Code for D

17. 17 Visualization of D in action on input y Program D with input y –(type for y: unsigned int) Given input y, generate the program (string) P y Run P H on P y and y Guaranteed to halt since P H solves H IF (P H (P y,y)) while (1>0); else return (yes); P0P0 P1P1 P2P2 PyPy...  12 HH HH NH H D...y HNH

18. 18 Alternate Proof

19. 19 Alternate Proof Overview For every program P y, there is a number y that we associate with it The number we use to distinguish program P y from D is this number y Using this idea, we can arrive at a contradiction without explicitly using the table L –The diagonalization is hidden

20. 20 H is not solvable, proof II Assume H is solvable –Let P H be the program which solves H –Use P H to construct program D which cannot exist Contradiction –This means program P H cannot exist. –This implies H is not solvable D is the same as before

21. 21 Arguing D cannot exist If D is a program, it must have an associated number y What does D do on this number y? 2 cases –D halts on y This means P H (D,y) = NO –Definition of D This means D does not halt on y –P H solves H Contradiction This case is not possible

22. 22 Continued –D does not halt on this number y This means P H (D,y) = YES –Definition of D This means D halts on y –P H solves H Contradiction This case is not possible –Both cases are not possible, but one must be for D to exist –Thus D cannot exist

23. 23 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

24. 24 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