So far we’ve seen problems that can be solved (decided) efficiently (in polynomial time).

Next we’ll look at problems that we do not know how to solve efficiently, but we can efficiently verify a potential solution.

These belong to the complexity class NP (“nondeterministic polynomial time”).

We’ll use a more natural characterization using polynomial-time verifiers.

Let’s see some examples!

Is \(\probHamPath \in \P\)? We don’t know of any polynomial-time algorithm for it!

However, we can efficiently verify a “potential solution” that is given to us: \[ \verifier{\probHamPath} = \setbuild{\encoding{G, p}}{ G \text{ is a directed graph with the Hamiltonian path } p } \]

from typing import TypeVar
from collections.abc import Hashable
Node = TypeVar('Node', bound=Hashable) # needed to put nodes in set
type Graph[Node] = tuple[list[Node], list[tuple[Node, Node]]]

def ham_path_verify(G: Graph[Node], p: list[Node]) -> bool:
   V, E = G
   # verify each pair of adjacent nodes in p is connected by an edge in `E`
   for i in range(len(p) - 1): # O(|p|) = O(n) iterations
       if (p[i], p[i+1]) not in E: # O(m) time to search E each iteration
           return False
   # verify p and V have same number of nodes
   if len(p) != len(V): # O(1) time
       return False
   # verify each node appears at most once in p
   if len(set(p)) != len(p): # O(n log n) to build set, removing duplicates
       return False
   return True

Is \(\probComposites \in \P\)?
Surprisingly, yes! But this is not obvious (AKS primality test discovered in 2002)

But it’s easy to prove that \(\probComposites \in \NP\).

What is the verification language? \[ \verifier{\probComposites} = \left\{\fragment{\encoding{n, d} \; \big| \; n, d \in \N^+,} \; \fragment{d \text{ divides } n,} \; \fragment{\text{ and } \; 1 < d < n}\right\} \]

What’s an algorithm for deciding \(\verifier{\probComposites}\)?

def composite_verify(n: int, d: int) -> bool:
    return n % d == 0 and 1 < d < n

What’s the time complexity in terms of the number of bits \(k = \encoding{n,d}\)?

• \(O(k)\) for the comparison
• \(O(k^2)\) for the division using the standard grade-school algorithm

• Yes, but in exponential time!

def composites_decide_slow(n: int) -> bool:
    for d in range(2, n):
        if composite_verify(n, d):
            return True
    return False

• Running time: \(\Omega(n) = \Omega(2^{|\encoding{n}|})\) since \(|\encoding{n}| = O(\log n)\)

• Since \(|w| = O(|x|^k)\), these only differ in length by a polynomial.
• Therefore \(V\) runs in polynomial time with respect to \(|x|\)
  if and only if it runs in polynomial time with respect to \(|\encoding{x, w}|\).

• For example, find the minimum-cost path between two nodes in a weighted graph.
  (“What is the cheapest way to fly from Sacramento to Rome”)
• Find the maximum clique in a graph.

• Pick a threshold \(k\) and ask if there is a solution at least as good as \(k\).
• For example, “Is there a flight from Sacramento to Rome that fits within my budget of \(k\)?”
  This decision problem is clearly in \(\NP\)!

• For example, for \(\probHamPath\), we search for a Hamiltonian path \(p\).
• While the search problem sounds harder (it needs to exhibit \(w\) rather than answer yes/no),
  it is not actually harder.
• If \(\P = \NP\), then every search problem corresponding to a decision problem in \(\NP\) can be solved in polynomial time.