1 NP Completeness

1.1 Encodings
An encoding is a mapping from abstract objects to character strings over
some finite alphabet.
A concrete problem is a problem whose instances are sets of binary
strings.
An algorithm solves a concrete problem in time O(T (n)) if, given an
input of length n, produces the (encoding of the) solution in at most O(T (n))
time.

1.2 Complexity Classes

Polynomial time solvability: O(nk ) some k.
Complexity class P : decision problems solvable in polynomial time.
This definition is independent of encoding as long as one only considers
encodings that are polynomially related.
Unary-binary as non-polynomially related encodings.

1.3 Formal language framework

• Alphabets (finite)

• Languages over an alphabet Σ

• A decision problem as the set of strings with a yes answer

• An algorithm accepts (rejects) a string (or loops)

• A language is decided by an algorithm

• Acceptance in polynomial time

• Decidability in polynomial time

• Definition of complexity class

1
1.4 Polynomial time verification
Checking (verifying) versus solving

Example: Existence of a path between vertices s and t

Verification algorithm A(x, y)

Certificates y
Example – a path between two vertices verifies that they are connected.
Thus x could be the connectedness question and y could be a path that
verifies that two vertices are connected.
Language verified by A

1.5 The class NP

NP is the set of languages L such that there is a polynomial time verification
algorithm A such that

x ∈ L iff there exists “short” y : A(x, y) = 1

We say A verifies L in polynomial time.

Example – a coloring y verifies that a graph x can be colored with 4
colors. But it may be hard to find such a coloring y.

1.6 The P = NP question

P ⊆ NP: A can ignore y
Closure under complementation is also unknown – would imply that there
is always a verification of non-solutions i.e. verification of non-4 colorability
for problems in NP

1.7 NP-Completeness
NP-complete problems: If any one of them has a polynomial time solution
then all do, and P = NP. But no one has found such a solution, nor has anyone
proven that it does not exist. Many problems of practical importance are
NP-complete.
These are in a sense the hardest problems in NP.

2
1.8 Examples
• Graph isomorphism is in NP (but maybe not NP complete); a verifica-
tion is an isomorphism

• The hamiltonian cycle problem is in NP (and NP complete); a verifi-

cation is a cycle

• The tautology problem is in co-NP.

In practice when trying to find an algorithm for a problem, one either

finds a polynomial time algorithm, or shows the problem to be NP complete;
sometimes neither is possible. It is important to be able to show a problem
NP complete because it means that one is very unlikely to find a polynomial
time algorithm for it.

1.9 Reducibility
A language L1 is polynomial-time reducible to L2 (L1 ≤P L2 ) if there is
a polynomial time computable function f from languages to languages such
that for all x, x ∈ L1 iff f (x) ∈ L2 .
If L1 is polynomial time reducible to L2 , then an algorithm to solve L2
can be used to obtain an algorithm to solve L1 . Also, the time required will
be the same to within a polynomial. That is, L1 cannot be much harder than
L2 .
Lemma 36.3 If L1 and L2 are languages such that L1 ≤P L2 , then
L2 ∈ P implies L1 ∈ P .
Proof.

1.10 NP-completeness
A language L is NP-compete if

1. L ∈ NP , and

2. L′ ≤P L for every L′ ∈ NP

Thus every other language in NP is polynomial reducible to L. We say

L is NP-hard if it satisfies property 2.

3
 Theorem 36.4 If any NP complete problem is in P, then P = NP. If any
NP complete problem is not in P, then no NP complete problem is in P, and
P 6= NP.
Thus the whole P = NP question boils down to the complexity of a single
NP-complete problem (any one of them).

1.11 Cooks’s Proof

Cook [1971] found the first NP-complete problem and became famous for it.
He showed that the satisfiability problem was NP complete. The book shows
a slightly different problem to be NP-complete, that is, circuit satisfiabil-
ity.
A circuit has AND, OR, NOT, and possibly other gates, with outputs
of some gates connected to inputs of others in a directed acyclic graph (no
cycles). The circuit satisfiability problem is to determine whether there is an
input to the circuit leading to an output of 1 (true). The book shows this to
be NP-complete using a slightly informal argument.
Review the argument.
Another way to do this is to construct a Boolean formula which is satis-
fiable iff a nondeterministic Turing machine accepts an input in polynomial
time.
For this the variables are: C(i, j, t), 1 ≤ i ≤ p(n), 1 ≤ j ≤ m, 0 ≤ t ≤
p(n).
The interpretation is that C(i, j, t) = 1 (true) iff the contents of ith tape
cell of M is Xj at time t.
S(k, t), 1 ≤ k ≤ s, 0 ≤ t ≤ p(n).
The interpretation is that S(k, t) = 1 (true) iff M is in state qk at time t.
H(i, t), 1 ≤ i ≤ p(n), 0 ≤ t ≤ p(n).
The interpretation is that H(i, t) = 1 (true) iff the tape head points to
cell i at time t.
The Boolean formula expresses the constraints on a nondeterministic Tur-
ing machine computation and also states that the computation does not reject
the input. This formula is satisfiable iff there is a sequence of configurations
leading to acceptance in polynomial time.

4
1.12 Showing Other Problems NP Complete
Once we have one NP-complete problem we can obtain more using the fol-
lowing lemma:
Lemma 36.8 If L′ is NP-complete and L′ ≤P L, then L is NP-hard. If
L is also in NP, then L is NP-complete.
Proof.
Five-step recipe for showing NP-completeness of L:
1. Prove L ∈ NP

2. Select NP-complete L′

3. Find a reduction f from L′ to L

4. Prove x ∈ L′ iff f (x) ∈ L

5. Prove that f is polynomial time computable

Other problems shown to be NP-complete
• Formula satisfiability
Example: A formula is (p ⊃ q) ⊃ ((¬q) ⊃ (¬p)) This is a tautology;
whether you replace p and q by true or f alse the formula evaluates to
true. The tautology problem is to determine if a formula is a tautology.
The tautology problem is actually co-NP complete.
Example: A formula is (p ∧ q) ∨ p. This formula is satisfiable because
if you replace p by true and q by anything, the formula evaluates to
true. The formula satisfiability problem is to determine if a Boolean
formula is satisfiable. This problem is NP-complete.
• 3-CNF satisfiability
A formula is in 3-CNF if it is a disjunction of conjunctions of three
literals, where a literal is a Boolean variable or its negation. So an
example is the formula (p ∨ q ∨ ¬r) ∧ (¬p ∨ ¬r ∨ s). The 3-CNF
satisfiability problem is to determine whether a formula in 3-CNF is
satisfiable. This problem is NP-complete.

5
 • The clique problem

• The vertex cover problem (minimize size of cover)

• The subset sum problem

• The hamiltonian cycle problem

• The traveling salesman problem

• Graph coloring

and many, many more ...

In fact, some journals no longer accept NP completeness proofs, since
there are so many of them and they are now becoming routine and uninter-
esting – of course, it still helps a lot to know how hard a problem is!
Many of the reductions are uninteresting, too.
Proof that formula satisfiability is NP complete (follow the 5 step recipe).
Reduce from circuit satisfiability.
Idea for avoiding duplication of subformulas
Suppose we have the circuit
|
NOT
|
|
OR .
. . .
. . .
. . .
AND AND AND
/ \ / \ / \
/ \ / \ / \
X1 X2 X3 X4 X5 X6
The reduction to NOT(OR(AND(X1, X2), AND(X3, X4), AND(X5, X6)))
won’t always work because we can have exponential size increase due to du-
plicated subformulas, making the reduction non polynomial time, as in this
example:

6
 OR
/ \
AND AND
| \/ |
| /\ |
OR OR
| \/ |
| /\ |
AND AND
| \/ |
| /\ |
OR OR
| \/ |
| /\ |
AND AND
| \/ |
| /\ |

...

So we have to add new variables for the wires, as follows:

Z5|
NOT
Z4|
|
OR .
. . .
Z1 . Z2. .Z3
. . .
AND AND AND
/ \ / \ / \
/ \ / \ / \
X1 X2 X3 X4 X5 X6

7
 Then we create formulas relating the values of the variables, as follows:

Z1 ≡ AND(X1, X2)

Z2 ≡ AND(X3, X4)
Z3 ≡ AND(X5, X6)
Z4 ≡ OR(Z1, Z2, Z3)
Z5 ≡ NOT (Z4)
We then concatenate them all together, with Z5, as follows:
(Z1 ≡ AND(X1, X2))∧(Z2 ≡ AND(X3, X4))∧(Z3 ≡ AND(X5, X6))∧
(Z4 ≡ OR(Z1, Z2, Z3)) ∧ (Z5 ≡ NOT (Z4)) ∧ Z5
Note that Z5 is added on, too. In this way, a circuit C is mapped on to
a formula F . This is the reduction. We need to show it is polynomial time
(easy), and preserves solvability. (Also not difficult.)
We now show that 3 CNF is NP complete by reducing from formula
satisfiability. An example of a formula in 3 CNF is the following:

(x1 ∨ x2 ∨ ¬x3 ) ∧ (x4 ∨ ¬x2 ∨ x1 )

The general steps in the reduction are as follows:

• All Boolean connectives as binary

• New variables for subformulas
• Reduce to conjunctive normal form
• Add variables to clauses that are too small

We illustrate these steps on the formula obtained above: (Z1 ≡ AND(X1, X2))∧
(Z2 ≡ AND(X3, X4)) ∧ (Z3 ≡ AND(X5, X6)) ∧ (Z4 ≡ OR(Z1, Z2, Z3)) ∧
(Z5 ≡ NOT (Z4)) ∧ Z5
First we make all connectives binary:
(Z1 ≡ AND(X1, X2)) ∧ (Z2 ≡ AND(X3, X4)) ∧ (Z3 ≡ AND(X5, X6))
∧
(Z4 ≡ OR(Z1, OR(Z2, Z3))) ∧ (Z5 ≡ NOT (Z4)) ∧ Z5
Then we add new variables for subformulas so that the number of vari-
ables in each conjunct is 3 or less. For our formula that is already true for
each conjunct except one, so we obtain this formula:

8
 (Z1 ≡ AND(X1, X2))∧(Z2 ≡ AND(X3, X4))∧(Z3 ≡ AND(X5, X6))∧
(Z4 ≡ OR(Z1, Y 1)) ∧ (Y 1 ≡ OR(Z2, Z3)) ∧ (Z5 ≡ NOT (Z4)) ∧ Z5
Next we put each subformula in conjunctive normal form, obtaining:
(Z1 ⊃ AND(X1, X2))∧(Z1 ⊂ AND(X1, X2))∧(Z2 ⊃ AND(X3, X4))∧
(Z2 ⊂ AND(X3, X4)) ∧ (Z3 ⊃ AND(X5, X6)) ∧ (Z3 ⊂ AND(X5, X6)) ∧
(Z4 ⊃ OR(Z1, Y 1)) ∧ (Z4 ⊂ OR(Z1, Y 1)) ∧ (Y 1 ⊃ OR(Z2, Z3)) ∧ (Y 1 ⊂
OR(Z2, Z3)) ∧ (Z5 ⊃ NOT (Z4)) ∧ (Z5 ⊂ NOT (Z4)) ∧ Z5
Continuing, we obtain:
(¬Z1 ∨ X1) ∧ (¬Z1 ∨ X2) ∧ (¬X1 ∨ ¬X2 ∨ Z1)∧ (¬Z2 ∨ X3) ∧ (¬Z2 ∨
X4) ∧ (¬X3 ∨ ¬X4 ∨ Z2)∧ . . . ∧Z5
The problem now is that some of the disjunctions have too few variables.
So we add extra variables to them; for example, we replace (¬Z1 ∨ X1) by
(¬Z1 ∨ X1 ∨ W ) ∧ (¬Z1 ∨ X1 ∨ ¬W ) for a new variable W . This has to be
done twice if we start with just one variable.
After all these steps, we obtain a 3 CNF formula that is satisfiable iff the
original formula was satisfiable. Also, the transformation is polynomial time.
Proof that the clique problem is NP complete:
Reduce from 3 CNF; suppose there are k clauses C1 , . . . , Ck . Create a
graph G for the clique problem, as follows:

• Three vertices for each clause, one for each literal

• Edges between vertices in different clauses if the literals are not com-
plementary

• A k clique exists iff S is satisfiable

Proof that the vertex cover problem is NP complete.

Reduce from the clique problem, using graph complement.
Suppose G has a clique of size k. Let G be the complementary graph,
with an edge between (u, v) iff G does not have this edge. Then G has a
clique of size k iff G has a vertex cover of size V − k.
Example of vertex cover reduction:

G: a---b
|\ /|\
| | \
|/ \| e
c---d

9
G has a clique of size 4

G complement:

a b
’ .
’ e
. ’.’
c d

G complement has a vertex cover of size 1

Proof that the subset sum problem is NP complete:

Reduce from the vertex cover problem.
Create base 4 numbers, with a digit position for each edge in the graph.
Each vertex has ones for digits of its incident edges. Each edge has a one in
its own position. Then we want to sum so that there is a 2 in every position.
Thus every position has to appear twice. This cannot come only from the
edge digits, so there must be an incident vertex. But if there is only one
incident vertex, then the edge has to be included, too; otherwise it is not.
Also, the total number of vertices is controlled by a significant digit.
Example of the subset sum construction:

e1
v1--v2
| |
e2| |e3
v3--v4
e4

This has a vertex cover of {v1,v4}. The subset sum instance:

4^4 4^2 4^0

4^3 4^1

e4 e3 e2 e1 Value
v1: 1 0 0 1 1 4^4 + 4^1 + 4^0
v2: 1 0 1 0 1 4^4 + 4^2 + 4^0

10
v3: 1 1 0 1 0 4^4 + 4^3 + 4^1
v4: 1 1 1 0 0 4^4 + 4^3 + 4^2
e1: 0 0 0 0 1 4^0
e2: 0 0 0 1 0 4^1
e3: 0 0 1 0 0 4^2
e4: 0 1 0 0 0 4^3
---------------------
(2) 2 2 2 2 2*4^4 + 2*4^3
+ 2*4^2 + 2*4^1
+ 2*4^0

So we obtain the following subset sum problem: Is there a subset of the

integers {44 + 41 + 40 , 44 + 42 + 40 , 44 + 43 + 41 , 44 + 43 + 42 , 40 , 41 , 42 , 43 } that
adds to 2∗44 +2∗43 +2∗42 +2∗41 +2∗40? Or, is there a subset of the integers
{261, 273, 324, 336, 1, 4, 16, 64} that sums to 682? And the answer is yes, the
subset corresponding to {v1, v4, e4, e3, e2, e1}, that is, {261, 336, 1, 4, 16, 64},
and one can verify that 261 + 336 + 1 + 4 + 16 + 64 = 682. We add enough
edges (one or two in each column) to insure that each column has two ones
altogether.
NP completeness of the Hamiltonian circuit problem:
Very involved.
The idea is that one constructs A-widgets, that permit exactly one of
two edges to be traversed, and B widgets, that permit any proper subset
of three edges (but not all of them) to be traversed in a Hamiltonian cycle.
Using these, we can convert a 3 satisfiability problem into a graph that has
a Hamiltonian cycle iff the set of clauses is satisfiable.
NP completeness of the traveling salesman problem:
Reduce from the Hamiltonian circuit problem. Convert a graph G to a
graph G′ with edge costs c(i, j). G′ is a complete graph. Let the cost be
zero if edge (i, j) is in G, one otherwise. Then it is easily seen that G′ has a
traveling salesman tour of cost 0 iff G has a Hamiltonian circuit.

1.13 The Turing Machine Approach

The class NP is often defined in terms of nondeterministic Turing machines
instead of polynomial time verifiers, so you should be familiar with this ap-
proach, too. A Turing machine has an infinite tape on which the input is

11
written. It has a finite set of states, and can read, write, and move to the
left or right, while changing state. It can also be nondeterministic.
The class NP is defined as the class of problems that can be accepted by
nondeterministic Turing machines in polynomial time. That is, there is some
sequence of transitions that leads to an accepting state. One can show that
this is equivalent to the verifier definition given in the text.

1.14 Quantum Computation

This permits an exponential number of states and all states are processed
in parallel. For example, if there are 10 electrons and each are in 2 states
simultaneously, then the whole system has 210 states. It is known that inte-
gers can be factored in polynomial time on quantum computers (which have
never been built), but this is not known for conventional computers. It could
even be that problems in NP are solvable in polynomial time on quantum
computers, though this hasn’t been shown. If this were true, it might make
the P = NP question of secondary importance.

1.15 Approximation Algorithms

Even if a problem is NP complete, we can find solutions that are close to
optimal in polynomial time in many cases. Sometimes one can prove that
even this is impossible if P 6= NP.
One can bound the ratio of the cost of a solution to the cost of an optimal
solution, or the relative error, as a function of n, the size of the input. One
looks for an approximation algorithm that runs in polynomial time and has
a specified ratio, for example.
A polynomial-time approximation scheme is an algorithm that ac-
cepts as an input a problem instance and a relative error ǫ and runs in
polynomial time and produces a solution within ǫ of optimal. (May not
exist.)
A fully polynomial-time approximation scheme has a running time
that is polynomial both in n and in 1/ǫ. This guarantees that one can improve
the accuracy of the approximation without too much extra work. (May not
exist, too.)

The Vertex Cover Problem

12
 For this we can obtain a ratio of two to an optimal solution in polynomial
time by a very simple algorithm.
APPROX-VERTEX-COVER(G)
C <- 0
E’ <- E[G]
while E’ .ne. 0
do let (u,v) be an arbitrary edge of E’
C’ <- C U {u,v}
remove from E’ every edge incident
on either u or v
return C
Example.
Proof of approximation.
The Traveling Salesman Problem
We obtain a ratio of two to an optimal solution in polynomial time as-
suming the triangle inequality:
c(u, w) ≤ c(u, v) + c(v, w).
The approximation algorithm makes use of minimum spanning trees.
APPROX-TSP-TOUR(G,c)
select a vertex r in V[G] as a root
grow a MST T for G from r using
Prim’s algorithm
Let L be the list of vertices of T
visited in preorder
return the Hamiltonian cycle that
visits the vertices in the order L
Example and proof of approximation.
Without the triangle inequality, no polynomial time approximation algo-
rithm is possible unless P = NP:
The idea is to take a graph G and produce another graph G′ in which the
costs of the edges in G are 1 but the costs of edges not in G are very large.
Then an approximation algorithm for the TSP G′ can be used to test if G
has a Hamiltonian circuit.
Example.

13
 The Set Covering Problem

Here we obtain an approximation algorithm with a logarithmic bound.

An instance (X, F ) of the set covering problem consists of a finite set X
and a family F of subsets of X such that every element of X belongs to at
least one subset in F . We want to find a minimum size subset {S1 , S2 , . . . , Sk }
of elements of F such that S1 ∪ S2 ∪ . . . Sk = X. That is, k should be as
small as possible.
The approximation algorithm is greedy:

GREEDY-SET-COVER(X,F)
U <- X
C <- 0
while U .ne. 0
do select an S in F that
maximizes |S /\ U|
U <- U - S
C <- C U {S}
return(C)

The ratio obtained is H(max{|S| : S ∈ F }) where H(d) = 1 + 1/2 +

1/3 + . . . + 1/d.
Example.
Proof of ratio.

The Subset Sum Problem

This is interesting because a fully polynomial approximation scheme is

known. For this we want to find a subset of a set S of integers which sums
to t (or as close as possible to t), where S and t are given as input. However,
it is not permitted for the sum to exceed t.
First we give an exact (exponential) algorithm:

EXACT-SUBSET-SUM(S,t)
n <- |S|
L_0 <- <0>
for i <- 1 to n
do L_i <-
MERGE-LISTS(L_(i-1),L_(i-1)+x_i)

14
 remove from L_i all elements
larger than t
return the largest element in L_n

This returns a sum as large as possible but not larger than t.

The idea of the approximation algorithm is to remove from the lists ele-
ments that are close to one another in value:

APPROX-SUBSET-SUM(S,t,epsilon)
n <- |S|
L_0 <- <0>
for i <- 1 to n
do L_i <-
MERGE-LISTS(L_(i-1),L_(i-1)+x_i)
L_i <- Trim(L_i,epsilon/n)
remove from L_i all elements
larger than t
return the largest element in L_n

Here we use TRIM defined as follows:

TRIM(L, delta)
m <- |L|
L’ <- <y_1>
last <- y_1
for i <- 2 to m
do if last < (1 - delta)y_i
then append y_i onto
the end of L’
last <- y_i
return L’

Example.
Proof of approximation.

15