Outline

• Cook's Theorem
• Quiz
• Variations on SAT

Introduction

• Last week, we defined an abstract problem as a collections of instances `I` and a set of solutions `S` for these instances.
• If we specify an encoding for instances and solutions as binary string, the problem becomes concrete.
• We said optimization problems are abstract problems where the solutions are always a biggest or smallest value.
• We said decision problems are abstract problems where the solutions are always yes (true or 1) or no (false or 0).
• We said an alphabet is any finite set, and a language is a set of strings over an alphabet.
• We then considered classes of languages whose strings could all be decided by an algorithm that runs in time polynomial in the length of the string, `P`.
• We also considered the class `NP`, where we said a language `L` is in `NP`, iff `L` can be written as
  `L= {x in {0,1}^star : exists y, |y| = O(|x|^c) mbox( and ) A(x,y)=1}`
  for some constant `c` and polynomial time algorithm `A`.
• We begin today by looking at a method for comparing the relative computational hardness of languages...

Polynomial-Time Reducibility

• There is some evidence to show that `P=NP` is unlikely.
• Further many problems have been shown to be in NP.
• So it is useful to be able to classify which NP problem are easy and which are hard.
• To do this, we say a language `L_1` is polynomial-time reducible to language `L_2`, written `L_1 le_P L_2`, if there exists a polynomial time computable function `f:{0,1}^star -> {0,1}^star` such that for all `x in {0,1}^star`, `x in L_1` iff `f(x) in L_2`.

Lemma. If `L_1`, `L_2` are languages such that `L_1 le_P L_2` and `L_2` is in `P`, then `L_1` is in `P`.

Proof. Let `A(y)` decide `L_2` in time `O(p(|y|))`. Let `f(x)` be a `O(q(|x|))`-time reduction from `L_1` to `L_2`. Here `p` and `q` are polynomials. Then `B(x)` which first computes `f(x)` then runs `A(f(x))`, runs in `O(p(q(|x|))`-time and decides `L_1`. So `B` runs in polynomial time.

Quiz

Which of the following statements is true?

1. There are languages in NP that can be decided in quadratic time.
2. RSA doesn't work in the case that the message is 0.
3. If there exists a nontrivial square root of 1 modulo n, then n is prime.

NP-completeness

• The `P` languages in `NP` are the easy languages.
• In contrast, a language `L` is called `NP`-complete if
  1. `L in NP`, and
  2. `L' le_P L` for every `L' in NP`.
• A language which satisfies (2) but not necessarily (1) is called `NP`-hard.
• Let `NPC` denote the class of `NP`-complete languages.

Theorem. If any `NP`-complete language is in `P`, then `P=NP`.

Proof. This follows from the lemma on the last slide.

A First NP-complete problem

Let CIRCUIT-SAT be the language:
`{langle C rangle | C` is an AND, OR, NOT circuit computing a 0-1 function which on some truth assignment to its input variables outputs 1`}`

Theorem. CIRCUIT-SAT is in NP.

Proof. Consider the following algorithm `A(langle C rangle, langle a rangle)`. First, `A` checks if `langle C rangle` is in the format of a circuit and `langle a rangle` is in the format for an assignment; if not, it rejects `A`. Otherwise, it then labels each of the inputs to `langle C rangle` with their value according to their values in `langle a rangle`. Then it loops over the combinational elements in `langle C rangle`, until there is no change doing the following:

1. Check if the current element is not assigned a value, but its children have been assigned a value.
2. Calculate the value of the node based on its gate type and its children.

By the `i`th iteration the nodes of depth `i` will have values. Each iteration involves less than quadratic work. So in `O((|langle C rangle|)^3)` this algorithm labels the root of the circuit with its output value on this assignment. Finally, CIRCUIT-SAT is the language `{langle C rangle in {0,1}^star : exists langle a rangle, |langle a rangle| le |langle C rangle| mbox( and ) A(langle C rangle, langle a rangle) = 1}`.