1 / 50

Module 11

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

garrison-powers
Download Presentation

Module 11

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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. Primality Testing Problem * • Consider the following two problems • Halting Problem • Input: Program P, unsigned int x • Yes/No Question: Does P halt on x? • Primality Testing Problem (PTP) • Input: Program P, unsigned int x • Yes/No Question: Does P output correctly whether or not x is a prime number? • Which problem seems harder and why?

  4. Question * • Suppose we construct a program PH which solves the Halting problem H under the following conditions • All of PH is known to be correct with the exception of one procedure PL. • This procedure PL is being used to solve the Primality Testing Problem. • What can we conclude in this scenario?

  5. Formalizing Technique • 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 • Conclude that L is unsolvable • Otherwise PL would exist and then H would be solvable • L will be a problem about program behavior

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

  7. Constructing PH using PL Answer-preserving input transformations and Program PT

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

  9. PT(x) x PT Y/N Yes/No PL PH Pictoral Representation of PH *

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

  11. Why this works * yes input to H PT yes input to L yes PL no no input to H no input to L PH We have assumed that PL solves L

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

  13. Why this works * yes input to H PT no input to L no yes PL no no input to H yes input to L yes PH We have assumed that PL solves L

  14. x PT(x) Yes/No PL PT PH Yes->Yes and No->No No inputs for H Yes inputs for H Domain of H Yes inputs for L No inputs for L Domain of L

  15. Yes inputs No inputs Domain of H Yes inputs No inputs Domain of L 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 • Notation H <= L

  16. Examples not involving the Halting Problem

  17. Generalization • As noted earlier, 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

  18. Yes inputs No inputs Domain of L1 Yes inputs No inputs Domain of L2 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

  19. Program PT string main(string x) { return(x concatenate “0”); }

  20. Yes inputs No inputs Domain of L1 Yes inputs No inputs Domain of L2 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

  21. Program PT string main(string x) { return( “0”); }

  22. Yes inputs No inputs Domain of L1 Yes inputs No inputs Domain of L2 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

  23. Proving a program behavior problem L is unsolvable

  24. 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 Problem Definitions *

  25. PT(x) x PT Y/N Yes/No PL PH • We are building a program PH to solve the halting problem H • PH will use PL as a subroutine, and we have no idea • how PL accomplishes its task • PH will use PT as a subroutine, and we must explicitly • construct PT using specific properties of H and L Construction review

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

  27. 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? Two inputs for L *

  28. 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 int 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? Another input for L *

  29. Input of PT (Also Input of H) Program QH one input of type unsigned int Non-negative integer y Program QL that is the output of PT (Also input of L) bool main(string z) { QH(y); /* QH and y come left-hand side */ /* ignore return value */ return(QYL(z)); } bool QH(unsigned int x) { /* comes from left-hand side } bool QYL(string y) { if ((y.length( ) % 2) = = 0) return (yes); else return(no); } PT QH,y QL Input and Output of PT *

  30. PT QH,y QL Example 1 * Input to PT Program QH bool main(unsigned int y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {}; } Input y 5 Output of PT Program QL bool QH(unsigned int 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 int y = 5; QH(y); return (QYL(z)); }

  31. PT QH,y QL Example 2 Input to PT Program QH bool main(unsigned int y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {}; } Input y 3 Output of PT Program QL bool QH(unsigned int 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 int y = 3; QH(y); return (QYL(z)); }

  32. PT in more detail

  33. QH,y QL Declaration of PT * Yes/No PL PT PH • 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 int y)

  34. Code for PT QH,y QL Yes/No PL PT PH program1 main(program2 P, unsigned int y) { /* Will be viewing types program1 and program2 as STRINGS over the program alphabet SP */ program1 QL = replace-main-with-QH(P); /* 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 int 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 int y) /* Details hidden */

  35. QH,y QL Yes/No PL PT PH PT code for QYL Y/N QYL y start halt QH QL QH z QYL PT Y/N unsigned int y PT in action Program QH bool main(unsigned int y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {}; } Input y 5 Program QL bool QH(unsigned int 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 int y = 5; QH(y); return (QYL(z)); }

  36. Constructing QL (and thus PT)

  37. 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 int x) { /* comes from left-hand side } bool Q?L(string y) { } Start with no input for H • QHloops on y • Thus Y(QL) = {} • Determine if this makes QL a no or yes input instance to L

  38. If QH, y is a no input to the Halting problem • Now choose a QYL (or QNL) that is a yes (or no) input instance to L Answer-preserving input transformation • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • } • QHloops on y • Thus Y(QL) = {} • Determine if this makes QL a no or yes input instance to L

  39. If QH, y is a no input to the Halting problem • Now choose a QYL (or QNL) that is a yes (or no) input instance to L Make yes for H map to yes for L • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • if ((y.length( ) % 2) = = 0) return (yes); • else return (no); • } • QHloops on y • Thus Y(QL) = {} • Determine if this makes QL a no or yes input instance to L

  40. Possible shortcut • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • if ((y.length( ) % 2) = = 0) return (yes); • else return (no); • } • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • if ((z.length( ) % 2) = = 0) return (yes); • else return (no); • } • bool QH(unsigned int x) { • /* comes from left-hand side • }

  41. Another Example

  42. 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 Problem Definitions

  43. 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 int x) { /* comes from left-hand side } bool Q?L(string y) { } Start with no input for H • QHloops on y • Thus Y(QL) = {} • Determine if this makes QL a no or yes input instance to L

  44. 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 int x) { /* comes from left-hand side } bool QNL(string y) { } • Now choose a QYL (or QNL) that is a yes (or no) input instance to L Answer-reversing input transformation • QHloops on y • Thus Y(QL) = {} • Determine if this makes QL a no or yes input instance to L

  45. 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 int x) { /* comes from left-hand side } bool QNL(string y) { if ((y.length( ) % 2) = = 0) return(yes); else return(no); } • Now choose a QYL (or QNL) that is a yes (or no) input instance to L Make yes for H map to no for L • QHloops on y • Thus Y(QL) = {} • Determine if this makes QL a no or yes input instance to L

  46. Analyzing existing transformations Yes to No and No to Yes Violations

  47. Is Y(P) = {aa}? * • Problem L • Input: Program P • Yes/No Question: Is Y(P) = {aa}? • Analysis • No input to H creates a QL that is a no input for L • No maps to no • Yes input to H creates a QL that is ALSO a no input for L • Yes maps to no • Transformation does not work • Yes to No violation • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes or no */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • if ((y.length( ) % 2) = = 0) return (yes); • else return (no); • }

  48. Is Y(P) infinite? • Problem L • Input: Program P • Yes/No Question: Is Y(P) infinite? • Analysis • No input to H creates a QL that is a no input for L • No maps to no • Yes input to H creates a QL that is a yes input for L • Yes maps to yes • Transformation works • Answer-preserving • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes or no */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • if ((y.length( ) % 2) = = 0) return (yes); • else return (no); • }

  49. Is Y(P) finite? • Problem L • Input: Program P • Yes/No Question: Is Y(P) finite? • Analysis • No input to H creates a QL that is a yes input for L • No maps to yes • Yes input to H creates a QL that is a no input for L • Yes maps to no • Transformation works • Answer-reversing • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes or no */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • if ((y.length( ) % 2) = = 0) return (yes); • else return (no); • }

  50. Is Y(P) = {} or is Y(P) infinite? • Problem L • Input: Program P • Yes/No Question: Is Y(P) = {} or is Y(P) infinite? • Analysis • No input to H creates a QL that is a yes input for L • No maps to yes • Yes input to H creates a QL that is ALSO a yes input for L • Yes maps to yes • Transformation does not work • No to Yes violation • Program QL • bool main(string z) { • QH(y); /* ignore return value */ • return(QYL(z)); /* yes or no */ • } • bool QH(unsigned int x) { • /* comes from left-hand side • } • bool QYL(string y) { • if ((y.length( ) % 2) = = 0) return (yes); • else return (no); • }

More Related