12.5.2-PolynmRdctn

12.5.2 Polynomial Reductions

Much of the knowledge we would like to have about the inherent complexity of important problems is currently beyond our reach. However, mathematicians and computer scientists have made good progress in establishing information about the relative complexity of many important problems.

One important way to relate the complexity of problem A to problem B is to show that problem A can be done efficiently if an algorithm that solves B can be used as a sub-algorithm.

DEFINITION: Problem A is polynomially Turing reducible to problem B ([A] <=^PT [B]) if there exists an algorithm for solving A in a time that *would* be polynomial if we could solve instances of problem B at unit cost.

(This assumes that the solution to problem B will be called O(p(N)) times and that the maximum size instance of problem B solved will be O(t(N)), where p and t are polynomials and N is the size of the instance of problem A to be solved.

For example, if there were an algorithm Al that determines whether a graph with N nodes has a Hamiltonian path, and if Al worked by calling an algorithm Bo N³ times to sort several lists of size no more than size N⁵ then the problem solved by Al would be polynomially Turing reducible to the problem solved by Bo.

On the other hand it would not be "fair" for Al to call Bo 2^N times, or to give an instance of size 2^N to Bo.

It's easy to show that the relationship <=^PT is reflexive and transitive.

EXAMPLE:

THEOREM: HAM and HAMD are polynomially Turing reducible to one another.

(HAM is the problem of finding a Hamiltonian cycle in an undirected graph, if one exists. HAMD is the problem of deciding (finding out) whether or not an undirected graph contains a Hamiltonian cycle.)

PROOF:

Suppose that HAM(G) is a function that is guaranteed to return a Hamiltonian cycle of the graph G if one exists. If no Hamiltonian cycle exists in G, it just returns something -- anything.

The following function demonstrates that [HAMD] <=^PT [HAM]:

function HamD(G : graph)
  s <-- Ham(G) ;
  IF   s defines a Hamiltonian 
       cycle in G
  THEN return true
  ELSE return false

Note that the algorithm gives the correct result, and that it is simple to make it run in polynomial time if Ham is assumed to be of unit cost. Part of what makes this feasible is that it is easy to check "s" in O(N) time to see if it is a Hamiltonian path.

This function demonstrates that [HAM] <=^PT [HAMD]:

function Ham(G=(N,A): graph)
    /* N is the node set, and A is the edge set. */
  IF   HamD(G)=false
  THEN return "there is no solution"
  FOR each edge e in the edge set A of G
  DO  IF    HamD(N,A-{e})
      THEN  A <-- A-{e}
  s <-- sequence of nodes obtained by following
           the unique cycle remaining in G.

Note that an edge is removed only if the resulting graph will still be Hamiltonian. It follows that the edges that remain comprise a single Hamiltonian cycle. The number of edges that will be examined will be O(N²), so HamD will be called only O(N²) times. Each instance of the problem called will be of size no larger than the size of G. QED

The example above illustrates that a decision problem can be equivalent to a problem that is not a decision problem. This is quite common. It shows that information we gain about P and NP can shed light on many other problems besides decision problems.

THEOREM: If X is polynomially Turing reducible to Y, and if Y can be solved in polynomial time, then X can be solved in polynomial time.

PROOF: By the definition of polynomially Turing reducible, if X is polynomially Turing reducible to Y, then there is an algorithm AL_X and two polynomials p and q with the following properties:

AL_X solves arbitrary problems of type X by, in part, calling a hypothetical algorithm AL_Y as a subroutine.
To solve a problem of type X and size N, AL_X performs no more than p(N) steps, some of which may be calls to AL_Y.
When AL_X solves a problem of size N, the problems of type Y that it passes to AL_Y are of size no greater than q(N).

Suppose that t(M) is an eventually non-decreasing work function for AL_Y. Typically, t(M) represents a bound on how much work is done by AL_Y on a problem of size M (or smaller) in the worst case.

Because of the facts listed above, each time AL_X calls AL_Y while working on a problem of size N, AL_Y does work at most t(q(N)). Also AL_X calls AL_Y at most p(N) times. Therefore the total amount of work done in the calls to AL_Y is at most p(N)*t(q(N)).

If Y can be solved in polynomial time, then we may assume that t(M) is a polynomial in M. It is not hard to show that therefore p(N)*t(q(N))+p(N) is a polynomial in N. This latter function is a bound on the total amount of work done by AL_X on a problem of size N. Therefore X can be done in polynomial time if Y can. QED.

DEFINITION: A Decision problem X defined on instance set I is polynomially many-one reducible to problem Y defined on instance set J ([X] <=^MP [Y]) if there exists a function f:I-->J computable in polynomial time such that x is in X if and only if y=f(x) is in Y for any instance x in I of problem X.

THEOREM: If X and Y are decision problems such that [X] <=^MP [Y], then also [X] <=^PT [Y].

PROOF: Suppose that [X] <=^MP [Y].

Let I, J, and f be as in the definition of <=^MP.

Suppose that DecideY is an algorithm for solving Y. Consider:

Function DecideX(x)
  y <-- f(x);
  IF   DecideY(f(x))
  THEN return true
  ELSE return false

Clearly DecideX would be a polynomial time algorithm if the call to DecideY could be executed at unit cost.

Because f is computable in polynomial time, we know that the size of the storage taken up by y is bounded by some polynomial in the size of x. Thus the argument to the call to DecideY is not "too large".

We can conclude then that [X] <=^PT [Y]. QED

THEOREM: [HAMD] <=^MP [TSPD] and [HAMD] <=^PT [TSPD]

(Here TSPD is the "travelling salesperson problem decision" -- the problem of determining if a given undirected graph has a Hamiltonian cycle of total cost no greater than some limit L.)

PROOF: Let G=<N,A> be a graph with N nodes. Define f(G) to be the instance of TSPD consisting of <H, c, L> where: H is the complete graph <N, NxN>; The cost function c is defined by c(u,v)=1 if {u,v} is an edge of G, and c(u,v)=2 otherwise; and The cost limit L is equal to N.

Any Hamiltonian cycle in G translates into a tour in H that has cost exactly N. If there is no Hamiltonian cycle in G, then H will have no Hamiltonian of cost less than N+1. Therefore G is a yes-instance of HAMD if and only if f(G) is a yes-instance of TSPD. Function f is easy to compute in polynomial time. Basically the work involved is just to create an NxN cost matrix. This proves that [HAMD] <=^MP [TSPD], and [HAMD] <=^PT [TSPD] follows immediately from the theorem.