Impossible problems

Semidecidable problems Question: Given this input data, will Program P ever halt, or will it run forever? Solution: Try running it If it halts, we know the answer If it hasn’t halted yet, we don’t know the answer How long do we have to wait? This problem is semidecidable—if it halts, we know the answer, but if it doesn’t, we don’t Can we do better? Program P Data for Program P

The Halting Problem Let’s write a program HaltChecker that accepts two inputs: A program, and The data for that program and determines whether the program (with that data) will halt This program will have one of two outputs: halts, and loops Program P Data for Program P HaltChecker halts loops (forever) HaltChecker reads another program as one of its inputs This is not unusual--compilers do it all the time

A modified HaltChecker We’ll make a slight change to HaltChecker--we will replace the halts output with an infinite loop Program P Data for Program P HaltChecker2 halts loops (forever) We call this new program HaltChecker2 HaltChecker2 behaves like this: If Program P would halt on its input data, HaltChecker2 goes into an infinite loop If Program P would go into an infinite loop on its data, HaltChecker2 halts (and reports its result) Thus, HaltChecker2 does the opposite of what Program P does

A problem HaltChecker2 has as input both a program and the input to that program What happens if we apply HaltChecker2 to itself (with itself as input)? HaltChecker2 halts loops (forever) A little thought (or maybe a lot of thought) should convince you that HaltChecker2 halts when applied to itself if and only if it doesn’t halt when applied to itself This is a contradiction Therefore, a program such as HaltChecker2 cannot exist However, we can easily modify HaltChecker to get HaltChecker2 Therefore, HaltChecker cannot exist

What have we proved? Clearly, for most programs we can determine whether or not they will halt We can write a HaltChecker-type program that can determine, for most programs, whether or not they will halt What we have proved is that we cannot write such a program that always works, for every program, for every input More generally, we have proved that some problems cannot be solved There are only a few such problems known (the Halting Problem is the most famous), but they are important

Consequences Can we prove that a certain statement in a program will never be executed? Replace the statement with an infinite loop The problem is now a Halting Problem Conclusion: You can’t always prove that a certain statement will or will not be executed But as usual, you can sometimes prove that it will or will not be executed Familiar consequence: Java warns you if you use a variable before it has been initialized Its algorithm for doing this is not perfect Could the algorithm be made 100% effective?

Why you should care Someday you may be asked to solve a problem that is equivalent to the Halting Problem It’s not too likely, but... ...it has happened to me If it happens, you can write a program that mostly works, but you cannot write one that always works Before you spend a lot of company money on the project, you need to educate your manager about what can be expected--or you’ll get blamed when it doesn’t work In my case, my manager decided the task wasn’t worth the effort :)

The End