1 module 7 halting problem –fundamental program behavior problem –a specific unsolvable problem...
Post on 20-Dec-2015
220 views
TRANSCRIPT
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 i=2;
if ((Q = = 0) || (Q= = 1)) return false;
while (i<Q) {
if (Q%i = = 0) return (false);
i++;
}
return (true);
}
• Input x4
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
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
bool main(unsigned int y) /* main for program D */{ program P = generate(y);
if (PH(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 PH(program P, unsigned int x)/* how PH solves H is unknown */
Definition of program D
8
Generating Py 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– …
10
Argument Overview *
H is solvable
D is NOT on list L
PH exists
Definition ofSolvability
D exists
D’s code
D is on list L
L is list ofall programs
D does NOT exist
PH does NOT exist
H is NOT solvable
p q is logically equivalent to (not q) (not p)
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
13
Visualizing List L *
P0
P1
P2
P3
P4...
1 2 3 4 ...
H HHHH
NHH H HNH
NH NH NH NH NH
H H H H H
HHNH NHNH
•#Rows is countably infinite
• p* is countably infinite
•#Cols is countably infinite
• Set of nnnegative 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
Diagonalization to specify B *
P0
P1
P2
P3
P4...
1 2 3 4 ...
H HHHH
NHH H HNH
NH NH NH NH NH
H H H H H
HHNH NHNH
•We specify a non-existent program behavior B by using a unique feature (number) to differentiate B from Pi
NH
H
H
H
NH
B
16
bool main(unsigned int y) /* main for program D */{ program P = generate(y);
if (PH(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 PH(program P, unsigned int x)/* how PH solves H is unknown */
Code for D
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 (1>0); else return (yes);
P0
P1
P2
Py...
1 2 ...
HH
H H
NH NH
H
NH
NH
D ... y
...
HNH
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