Module 7

1
Module 7

• Halting Problem
• Fundamental program behavior problem
• A specific unsolvable problem
• Diagonalization technique revisited
• Proof more complex

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
Example Input

• Program with one input of type unsigned int
• bool main(unsigned int Q)
• int i2
• if ((Q 0) (Q 1)) return false
• while (iltQ)
• if (Qi 0) return (false)
• i
• return (true)
• Input x
• 4

4
Three key definitions
5
Definition of list L

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

6
Definition of PH

• If H is solvable, some program must solve H
• Let PH be a procedure which solves H
• We declare it as a procedure because we will use
  PH as a subroutine
• Declaration of PH
• bool PH(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 PH works
• However, if H is solvable, we can build programs
  which call PH as a subroutine

7
Definition of program D

• bool main(unsigned int y) / main for program D
  /
• program P generate(y)
• if (PH(P,y)) while (1gt0) else return (yes)
• / generate the yth string in SP 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 PH(program P, unsigned int x)
• / how PH solves H is unknown /

8
Generating Py from y

• We wont 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 SP).
• 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 l
• 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
Proof that H is not solvable
10
Argument Overview
H is solvable
D is NOT on list L
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
Non-existent program behavior B
13
Visualizing List L
0
1
2
3
4
...

• Rows is countably infinite
• Sp is countably infinite
• Cols is countably infinite
• Set of nonnegative integers is countably infinite

P0
P1
P2
P3
P4
...

• Consider each number to be a feature
• A program halts or doesnt halt on each integer
• We have a fixed L this time

14
Diagonalization to specify B

• We specify a non-existent program behavior B by
  using a unique feature
• (number) to differentiate B from Pi

0
1
2
3
4
...
B
P0
NH
H
H
H
H
H
P1
NH
H
H
H
NH
H
P2
NH
NH
NH
NH
NH
H
P3
H
H
NH
NH
NH
H
P4
NH
H
H
H
H
H
...
15
Arguing D exhibits program behavior B
16
Code for D

• bool main(unsigned int y) / main for program D
  /
• program P generate(y)
• if (PH(P,y)) while (1gt0) else return (yes)
• / generate the yth string in SP 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 PH(program P, unsigned int x)
• / how PH solves H is unknown /

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) Py
• Run PH on Py and y
• Guaranteed to halt since PH solves H
• IF (PH(Py,y)) while (1gt0) else return (yes)

0
1
2
...
D
...
y
P0
H
H
H
P1
H
H
NH
P2
NH
NH
NH
...
Py
H
NH
...
18
Alternate Proof
19
Alternate Proof Overview

• For every program Py, there is a number y that we
  associate with it
• The number we use to distinguish program Py 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
H is not solvable, proof II

• Assume H is solvable
• Let PH be the program which solves H
• Use PH to construct program D which cannot exist
• Contradiction
• This means program PH cannot exist.
• This implies H is not solvable
• D is the same as before

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 PH(D,y) NO
• Definition of D
• This means D does not halt on y
• PH solves H
• Contradiction
• This case is not possible

22
Continued

• D does not halt on this number y
• This means PH(D,y) YES
• Definition of D
• This means D halts on y
• PH 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
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
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