proving non-computability
- 1. 12.4 Proving Non-Computability We can show that a problem is computable by describing a procedure and proving that the procedure always terminates and always produces the correct answer. It is enough to provide a convincing argument that such a procedure exists; finding the actual procedure is not necessary (but often helps to make the argument more convincing). To show that a problem is not computable, we need to show that *no& algorithm exists that solves the problem. Since there are an infinite number of possible procedures, we cannot just list all possible procedures and show why each one does not solve the problem. Instead, we need to construct an argument showing that if there were such an algorithm it would lead to a contradiction. The core of our argument is based on knowing the Halting Problem is noncomputable. If a solution to some new problem PP could be used to solve the Halting Problem, then we know that PP is also noncomputable. That is, no algorithm exists that can solve PP since if such an algorithm exists it could be used to also solve the Halting Problem which we already know is impossible.
- 2. Reduction Proofs. The proof technique where we show that a solution for some problem PP can be used to solve a different problem QQ is known as a reduction. A problem QQ is reducible to a problem PP if a solution to PP could be used to solveQQ. This means that problem QQ is no harder than problem PP, since a solution to problem QQ leads to a solution to problem PP. Example 12.1: Prints-Three Problem Consider the problem of determining if an application of a procedure would ever print 3: Prints-ThreePrints-Three Input: A string representing a Python program. Output: If evaluating the input program would print 3, output True; otherwise, output False. We show the Prints-Three Problem is noncomputable by showing that it is as hard as the Halting Problem, which we already know is noncomputable. Suppose we had an algorithm printsThree that solves the Prints-Three Problem. Then, we could define halts as: defhalts(p): return printsThree(p + '; print(3)')
- 3. The printsThree application would evaluate to True if evaluating the Python program specified by p would halt since that means the print(3) statement appended to p would be evaluated. On the other hand, if evaluating p would not halt, the added print statement never evaluated. As long as the program specified by p would never print 3, the application of printsThree should evaluate toFalse. Hence, if a printsThree algorithm exists, we would use it to implement an algorithm that solves the Halting Problem. The one wrinkle is that the specified input program might print 3 itself. We can avoid this problem by transforming the input program so it would never print 3itself, without otherwise altering its behavior. One way to do this would be to replace all occurrences of print (or any other built-in procedure that prints) in the string with a new procedure, dontprint that behaves like print but doesn't actually print out anything. Suppose the replacePrints procedure use printsThree to define halts: is defined to do this. Then, we could def halts(p): return printsThree(replacePrints(p) + '; print(3)')