[Note: this webpage last modified Friday, 04-Feb-2011 19:44:51 EST]
Today's attendance.
Collect the homework, hand out the new one after class.
Note: showing examples does not prove something holds always!
Last time - tried to justify using Turing Machines as a basic model of computation, and proof that there exist uncomputable problems. That proof was basically (i) there is a TM for each computable problem (by definition), and the TM's are countable, so the computable problems are countable, (ii) the set of all functions from binary strings to 0/1 is in 1-1 correspondence with the real numbers between 0 and 1, which is not countable, so the set of functions from binary strings to 0/1 is not computable, (iii) so there are "more" functions than there are computable functions. Also, we started to prove the halting problem is not computable.
Today: finish proof that halting problem is not computable, definitions of P and NP, examples of those, "search" versus "decision" and why we can normally just talk about decision problems.
Decision problems versus search/functions. Many of the things we want to compute are actually functions - e.g., what is the product of two numbers, what is a path between two vertices on a graph. But we can turn those into yes/no questions as well - what is the 1st bit of the product, what is the second bit, etc. and is the first edge on a path between the vertices going to vertex v1, or is it to v2, and similarly for the second edge and so on. If we have answers to these yes/no questions, we can easily determine what the answer is to the function we wanted. And yes/no questions are simpler to talk about because there are only two choices, so that is what we will often talk about. We will say more about this next time.
"Efficient computation" - what can be done in polynomial time on a TM (or any other "reasonable" type of computer).
Dtime(t(n)) - deterministic (standard) TM solves the problem in time t(n). solves the problem means gives the correct answer for all inputs (and always halts), in time t(n) means takes at most t(n) steps (applications of the transition function, or execution of an instruction on a normal computer) for all inputs of length n (of n bits).
By default, we are talking about yes/no problems, like "is a given integer prime", or "is a given list in sorted order". We will talk in a minute about why this is reasonable, and will talk about more general functions/search problems.
P = ∪constant c nc, P is our intuition for "efficient".
Example: is a given list in sorted order?
Example: is there a path from u to v in a given graph?
Example: is the most-significant bit of a multiplication equal to 1 or 0?
EXP = ∪constant c 2nc, we will see that there are problems in EXP that are not in P, so cannot be computed efficiently.
"Efficiently checkable/provable" - what can be verified in polynomial time on a TM.
Ntime(t) = yes/no problems with Dtime(t) verification procedure V such that (i) if correct answer for x is yes, then there is a "proof" y of length t(|x|), so V(x, y) says "yes", (ii) if correct answer for x is no, then for any "purpurted proof" y of length t(|x|), V(x, y) says "no".
NP = ∪c Ntime(nc).
Example: any problem that is in P.
Example: is a given integer composite?
Example: vertex cover.
Example: satisfiability.
In general, any type of problem easily stated as "does there exist _____ where it is easy to check a candidate solution".
Reading and what we will do next time - talk about search/functions versus decision problems, what NP-completeness means, and maybe prove one problem is NP-complete given that another is NP-complete.