No Harder Than. We want these transformations to effectively be a problem-hardness version of #, which we will call No Harder Than.

Transcription

1 No Harder Than We want these transformations to effectively be a problem-hardness version of #, which we will call No Harder Than. If we can reduce problem B to problem A appropriately, then we say that B is no harder than A (since we can use A to solve B). To do this, our transformations have to be computable in polynomial time, as well as preserve the yes / no results. Note that the answers are not known for the instances, however.

2 Essentially what we are doing is this: 1. Assume A has a polynomial time algorithm. 2. Show how a polynomial time algorithm for A can be used to solve B in polynomial time. (note that you do not have such an algorithm, so you must convert the instances instead of modifying an algorithm.) 3. Conclude that solving B in polynomial time is no harder than solving A in polynomial time, so if A has a polynomial time algorithm, so does B.

3 Note that not all instances of A need to be used problem B may be a special case of problem A. Certainly a general problem cannot be easier than its special cases. Also, a reduction is blind, in that it does not know which instances are true (have answer yes ) and which are false (have answer no ), but must convert all of them in the same way. These reductions are transitive, since you can compose two polynomial-time transformation functions and the result is also a polynomial-time transformation function.

4 The difficulty most people have working with reductions is that in most cases, problem A (to be shown as hard) is a new problem, and often a problem that you were previously trying to solve. If you are trying to show that A is hard to solve, you need to stop trying to solve it, and start trying to solve other problems using it -- essentially investigating the consequences of having a polynomial time algorithm for it. This technique has a lot in common with a proof by contradiction the difference is that we derive an unknown rather than a contradiction.

5 Example Reduction Consider the 0/1 Knapsack and Subset Sum problems. We will reduce Subset Sum to 0/1 Knapsack in order to show that 0/1 Knapsack is at least as hard as Subset Sum (and that a poly-time algorithm existing for 0/1 Knapsack means one also exists for Subset Sum). Construct the 0/1 Knapsack instance from the SS instance by: For each S[i], let W[i]=B[i]=S[i] Let W(weight limit)=b(goal benefit)=k. So if (and only if) the instance of 0/1 Knapsack is true (there is a subset within weight W=k with benefit B=k), then there is a subset of S with sum k.

6 Back to NP-hardness So now we have all 3 things that we needed for our complexity class. What does this mean? If there is a problem X such that every problem in NP reduces to X, then X is at least as hard as every problem in NP. We say that X is hard for NP, or NP-hard. Once we have one problem that is NP-hard, we can use it to find others by, eg. reducing X to Y to show that Y is also NP-hard.

7 NP-completeness If X is NP-hard and is also in NP, then we say that X is complete for NP, or NP-complete. If any NP-hard problem is in P (has a polynomial time algorithm), then Every problem that reduces to it (which is all of NP) is also in P. There are problems that are NP-hard but not known to be in NP, so we usually restrict ourselves to NPcomplete problems for this. All NPcomplete problems have the same hardness. If any NP-complete problem is in P, then P=NP.

8 Consequences of being in P Return to our question about problem A: what are the consequences of A being solvable in polynomial time? If we can show that a known NPhard problem reduces to A in polynomial time, then we know A is NP-hard. So if A is solvable in polynomial time, then P=NP. We still don t know if P=NP. Nobody does, but this has been looked at very heavily, and is conjectured by most experts to be false.

9 Reduction Source Problems To show that our problem A is NPhard, we can pick any known NPhard problem B to reduce from. However, we usually reduce from a known NP-complete problem (NPhard and also in NP) since if a problem is not known to be in NP, it may actually be more difficult than our problem A (hence there will be no reduction). In order to start off the set of NPhard problems, we need to have one problem that all problems in NP reduce to. Then we can find other NP-hard problems by reducing from it.

10 The Circuit Satisfiability Problem Input: a circuit (acyclic) with a single output bit?: Is there an input assignment that produces an output of 1? We cannot reduce from each problem in NP individually, so we will do this in bulk by describing how any P-checking algorithm can be transformed into a circuit in polynomial time. Basic idea: each step of the algorithm can be simulated by a level of the circuit, and there will be only polynomial such levels. The input will be the certificate.

11 Other Known NP-hard Problems Acyclic circuits correspond to boolean formulae, so the Satisfiability problem (Sat), of determining if there is a truth assignment for the variables of a boolean formula that produces a result of true, is also NP-hard. Theorems have also proven that this problem remains NP-hard even for the special case when the formula is expressed as a conjunction of 3- literal disjunctions (3Sat). These problems are also NPcomplete since they are in NP (use a truth assignment as the certificate, check it with the formula/circuit).