1
Module 11
• Proving more specific problems are not solvable
• Input transformation technique– Use subroutine theme to show that if one
problem is unsolvable, so is a second problem– Need to clearly differentiate between
• use of program as a subroutine and
• a program being an input to another program
2
Basic Idea/Technique
3
Proving a problem L is unsolvable
• Assume PL is a procedure that solves problem L– We have no idea how PL solves L
• Construct a program PH that solves H using PL as a subroutine– We use PL as a black box– (We could use any unsolvable problem in place of H)
• Argue PH solves H– But we know H is unsolvable
• Conclude that L is unsolvable– Otherwise PL would exist and then H would be solvable– L will be a problem about program behavior
4
Focusing on H
• In this module, we will typically use H, the Halting Problem, as our known unsolvable problem
• The technique generalizes to using any unsolvable problem L’ in place of H.– You would need to change the proofs to work with L’
instead of H, but in general it can be done
• The technique also can be applied to solvable problems to derive alternative consequences
• We focus on H to simplify the explanation
5
Constructing PH using PL
Answer-preserving input transformations and Program PT
6
PH has two subroutines
• There are many ways to construct PH using program PL that solves L
• We focus on one method in which PH consists of two subroutines– Procedure PL that solves L– Procedure PT which computes a function f that I
call an answer-preserving (or answer-reversing) input transformation
• More about this in a moment
7
Two Representations of PH *
PH
P,y Yes/NoPLY/NPT
PT(P,y)
bool PH (Program P, unsigned y) { return PL (PT (P,y));}
8
Answer-preserving input transformation PT
• Input– An input to H
• Output– An input to L such that
• yes inputs of H map to yes inputs of L• no inputs of H map to no inputs of L
• Note, PT must not loop when given any legal input to H
9
Why this works *
PH
PLPT
yes input to H yes input to L yes
no input to H no input to L no
We have assumed that PL solves L
bool PH (Program P, unsigned y) { return PL (PT (P,y));}
10
Answer-reversing input transformation PT
• Input– An input to H
• Output– An input to L such that
• yes inputs of H map to no inputs of L• no inputs of H map to yes inputs of L
• Note, PT must not loop when given any legal input to H
11
Why this works
PH
PLPT
yes input to H no input to L yes
no input to H yes input to L no
We have assumed that PL solves L
no
yes
bool PH (unsigned x) { return complement(PL (PT (P,y)));}
12
Yes→Yes and No→No
Domain of H
Yes inputsfor H
No inputsfor H
Yes inputsfor L
No inputsfor L
Domain of L
PLPT
PH
x PT(x) Yes/No
13
Notation and Terminology
• If there is such an answer-preserving (or answer-reversing) input transformation f (and the corresponding program PT), we say that H transforms to (many-one reduces to) L
• NotationH ≤ L
Domain of H
Yes inputs No inputs
Yes inputs No inputsDomain of L
14
Examples not involving the Halting Problem
15
Generalization
• While we focus on transforming H to other problems, the concept of transformation generalizes beyond H and beyond unsolvable program behavior problems
• We work with some solvable, language recognition problems to illustrate some aspects of the transformation process in the next few slides
16
Example 1
• L1 is the set of even length strings over {0,1}– What are the set of legal input instances and no inputs for
the L1 LRP?
• L2 is the set of odd length strings over {0,1}– Same question as above
• Tasks– Give an answer-preserving input transformation f that
shows that L1 LRP ≤ L2 LRP
– Give a corresponding program PT that computes f
Domain of L1
Yes inputs No inputs
Yes inputs No inputsDomain of L2
17
Program PT
string main(string x)
{
return(x concatenate “0”);
}
18
Example 2
• L1 is the set of all strings over {0,1}
– What is the set of all inputs, yes inputs, no inputs for the L1 LRP?
• L2 is {0}– Same question as above
• Tasks– Give an answer-preserving input transformation f which
shows that the L1 LRP ≤ L2 LRP
– Give a corresponding program PT which computes f
Domain of L1
Yes inputs No inputs
Yes inputs No inputsDomain of L2
19
Program PT
string main(string x)
{
return( “0”);
}
20
Example 3
• L1 – Input: Java program P that takes as input an unsigned int– Yes/No Question: Does P halt on all legal inputs
• L2
– Input: C++ program P that takes as input an unsigned int– Yes/No Question: Does P halt on all legal inputs
• Tasks– Describe what an answer-preserving input transformation f
that shows that L1 ≤ L2 would be/do?
Domain of L1
Yes inputs No inputs
Yes inputs No inputsDomain of L2
21
Proving a program behavior problem L is unsolvable
22
Problem Definitions *
• Halting Problem H– Input
• Program QH that has one input of type unsigned int
• non-negative integer y that is input to program QH
– Yes/No Question• Does QH halt on y?
• Target Problem L– Input
• Program QL that has one input of type string
– Yes/No question• Does Y(QL) = the set of
even length strings?
• Assume program PL solves L
23
Construction review
PH
x Yes/No
•We are building a program PH to solve H
bool PH (unsigned x) { return}
PTPT(x)
•PH will use PT as a subroutine, and we must explicitly construct PT using specific properties of H and L
PT (P,y)
PLY/N
•PH will use PL as a subroutine
PL ( );
24
P’s and Q’s• Programs which are PART of program PH and
thus “executed” when PH executes– Program PT, an actual program we construct– Program PL, an assumed program which solves
problem L
• Programs which are INPUTS/OUTPUTS of programs PH, PL, and PT and which are not “executed” when PH executes– Programs QH, QL, and QYL
• code for QYL is available to PT
25
Two inputs for L *
• Target Problem L– Input
• Program Q that has one input of type string
– Yes/No question• Does Y(Q) = the set of
even length strings?
• Program PL
– Solves L– We don’t know how
• Consider the following program Q1
bool main(string z)
{while (1>0) ;}
– What does PL output when given Q1 as input?
• Consider the following program Q2
bool main(string z)
{ if ((z.length %2) = = 0) return (yes)
else return (no); }
– What does PL output when given Q2 as input?
26
Another input for L *
• Target Problem L– Input
• Program Q that has one input of type string
– Yes/No question• Does Y(Q) = the set of
even length strings?
• Program PL
– Solves L– We don’t know how
• Consider the following program QL with 2 procedures Q1 and QYL
bool main(string z) {
Q1(5); /* ignore return value */
return(QYL(z));}
bool Q1(unsigned x) {if (x > 3) return (no); else loop;
}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);
else return(no);}
• What does PL output when given QL as input?
27
Input and Output of PT *
• Input of PT (and H)
– Program QH
• one input of type unsigned int
– Non-negative integer y
• Program QL that is the output of PT
and input of Lbool main(string z) {
QH(y); /* QH and y come left-hand side */
/* ignore return value */
return(QYL(z));
}
bool QH(unsigned x) {
/* comes from left-hand side
}
bool QYL(string y) {
if ((y.length( ) % 2) = = 0) return (yes); else return(no);
}
QH,y PT QL
28
Example 1 *
Input to PT
Program QH
bool main(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}
Non-negative integer y5
Output of PT
Program QL
bool QH(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}bool QYL(string z) { if ((z.length % 2) == 0) return (yes) else return (no);}bool main(string z) { unsigned y = 5; QH(y); return (QYL(z));}
QH,y PT QL
29
Example 2
Input to PT
Program QH
bool main(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}
Non-negative integer y3
Output of PT
Program QL
bool QH(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}bool QYL(string z) { if ((z.length % 2) == 0) return (yes) else return (no);}bool main(string z) { unsigned y = 3; QH(y); return (QYL(z));}
QH,y PT QL
30
PT in more detail
31
Declaration of PT
• What is the return type of PT?– Type program1 (with one input of type string)
• What are the input parameters of PT?– The same as the input parameters to H; in this case,
• type program2 (with one input of type unsigned int)• unsigned int (input type to program2)
program1 main(program2 QH, unsigned y)
PLPT
PH
QH,y QL Yes/No
32
program1 main(program2 QH, unsigned y) {/* Will be viewing types program1 and program2 as STRINGS over the
program alphabet P */
program1 QL = replace-main-with-QH(QH);/* Insert line break */
QL += “\n”;
/* Insert QYL */
QL += “bool QYL(string z) {\n \t if ((z.length % 2) == 0) return (yes) else return (no);\n }”;
/* Add main routine of QL */
QL += “bool main(string z) {\n\t”; /* determined by L */
QL += “unsigned y =”
QL += convert-to-string(y);
QL += “;\n\t QH(y)\n\t return(QYL(z));\n}”;
return(QL);}
program1 replace-main-with-QH(program2 P) /* Details hidden */string convert-to-string(unsigned y) /* Details hidden */
Code for PT PLPT
PH
QH,y QL Yes/No
33
PT in action
PT
code for QYL
Program QHbool main(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}
Input y5
Program QLbool QH(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}bool QYL(string z) { if ((z.length % 2) == 0) return (yes) else return (no);}bool main(string z) { unsigned y = 5; QH(y); return (QYL(z));}
PLPT
PH
QH,y QL Yes/No
34
Constructing QL (and thus PT)
How to choose QYL or QNL
35
Start with no input for H
• If QH, y is a no input to the Halting problem
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(Q?L(z)); /* yes or no? */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool Q?L(string y) {
}
– Thus Y(QL) = {}
– QH loops on y
– Determine if this makes QL a no or yes input instance to L
36
Answer-preserving input transformation
• If QH, y is a no input to the Halting problem
– Thus Y(QL) = {}
– QH loops on y
– Determine if this makes QL a no or yes input instance to L
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool QYL(string y) {
}
– Now choose a QYL (or QNL) that is a yes (or no) input instance to L
37
Make yes for H map to yes for L
• If QH, y is a no input to the Halting problem
– Thus Y(QL) = {}
– QH loops on y
– Determine if this makes QL a no or yes input instance to L
– Now choose a QYL (or QNL) that is a yes (or no) input instance to L
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
38
Possible shortcutProgram QL bool main(string z) {
QH(y); /* ignore return value */if ((z.length( ) % 2) = = 0) return (yes);else return (no);
}
bool QH(unsigned x) {/* comes from left-hand side
}
Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
39
Another Example
40
Problem Definitions
• Halting Problem H– Input
• Program QH that has one input of type unsigned int
• non-negative integer y that is input to program QH
– Yes/No Question• Does QH halt on y?
• Target Problem L– Input
• Program QL that has one input of type string
– Yes/No question• Is Y(QL) finite?
• Assume program PL solves L
41
Start with no input for H
• If QH, y is a no input to the Halting problem
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(Q?L(z)); /* yes or no? */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool Q?L(string y) {
}
– Thus Y(QL) = {}
– QH loops on y
– Determine if this makes QL a no or yes input instance to L
42
Answer-reversing input transformation
• If QH, y is a no input to the Halting problem
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QNL(z)); /* no */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool QNL(string y) {
}
– Thus Y(QL) = {}
– QH loops on y
– Determine if this makes QL a no or yes input instance to L
– Now choose a QYL (or QNL) that is a yes (or no) input instance to L
43
Make yes for H map to no for L
• If QH, y is a no input to the Halting problem
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QNL(z)); /* no */}
bool QH(unsigned x) {/* comes from left-hand side
}
bool QNL(string y) {if ((y.length( ) % 2) = = 0) return(yes);else return(no);
}
– Thus Y(QL) = {}
– QH loops on y
– Determine if this makes QL a no or yes input instance to L
– Now choose a QYL (or QNL) that is a yes (or no) input instance to L
44
Analyzing proposed transformations
4 possibilities
45
Problem Setup• Input of Transformation
• Program QH, unsigned x• Output of Transformation
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
• Problem L• Input: Program P• Yes/No Question: Is Y(P) =
{aa}?
• Question: Is the transformation on the left an answer-preserving or answer-reversing input transformation from H to problem L?
46
Key Step• Input of Transformation
• Program QH, unsigned x• Output of Transformation
• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
• Problem L• Input: Program P• Yes/No Question: Is Y(P) =
{aa}?
• The output of the transformation is the input to the problem.• Plug QL in for
program P above• Is Y(QL) = {aa}?
47
Is Y(QL) = {aa}?• Problem L
• Input: Program P• Yes/No Question: Is Y(P) =
{aa}?• Analysis
• If QH loops on x, Y(QL)={}• No input to H creates a QL that
is a no input for L• If QH halts on x, Y(QL) =
{even length strings}• Yes input to H creates a QL
that is a no input for L• Transformation does not work
• All inputs map to no inputs
• Input of Transformation• Program QH, unsigned x
• Output of Transformation• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
48
Three other problems• Problem L1
• Input: Program P• Yes/No Question: Is Y(P)
infinite?
• Problem L2• Input: Program P• Yes/No Question: Is Y(P)
finite?
• Problem L3• Input: Program P• Yes/No Question: Is Y(P) =
{} or is Y(P) infinite?
• Input of Transformation• Program QH, unsigned x
• Output of Transformation• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
49
Is Y(QL) infinite?• Problem L1
• Input: Program P• Yes/No Question: Is Y(P)
infinite?• Analysis
• If QH loops on x, Y(QL)={}• No input to H creates a QL
that is a no input for L• If QH halts on x, Y(QL) =
{even length strings}• Yes input to H creates a QL
that is a yes input for L• Transformation works
• Answer-preserving
• Input of Transformation• Program QH, unsigned x
• Output of Transformation• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
50
Is Y(QL) finite?• Problem L2
• Input: Program P• Yes/No Question: Is Y(P)
finite?• Analysis
• If QH loops on x, Y(QL)={}• No input to H creates a QL
that is a yes input for L• If QH halts on x, Y(QL) =
{even length strings}• Yes input to H creates a QL
that is a no input for L• Transformation works
• Answer-reversing
• Input of Transformation• Program QH, unsigned x
• Output of Transformation• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}
51
Is Y(QL) = {} or is Y(QL) infinite?• Problem L3
• Input: Program P• Yes/No Question: Is Y(P) =
{} or is Y(P) infinite?• Analysis
• If QH loops on x, Y(QL)={}• No input to H creates a QL
that is a yes input for L• If QH halts on x, Y(QL) =
{even length strings}• Yes input to H creates a QL
that is a yes input for L• Transformation does not work
• All inputs map to yes inputs
• Input of Transformation• Program QH, unsigned x
• Output of Transformation• Program QL bool main(string z) {
QH(y); /* ignore return value */
return(QYL(z)); /* yes or no */}
bool QH(unsigned x) {}
bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);
}