Combinatorics Techniques For Proving Lower Bounds In Complexity Theory

The P vs. NP Problem

The most fundamental question in theoretical computer science is whether the complexity classes P and NP are equal. P represents the set of problems that can be solved in polynomial time by a deterministic Turing machine. NP represents problems where solutions can be verified in polynomial time by a non-deterministic Turing machine. It remains unknown whether problems whose solutions are easy to check must also have efficient algorithms to find those solutions.

Thousands of computational problems in areas like optimization, logic, graph theory, and number theory are known to be in NP. Many of these problems arise in practical domains and have major industrial applications if efficient solutions exist. However, despite extensive efforts by computer scientists, essentially no progress has been made on finding polynomial time algorithms for these problems. This suggests, but does not definitively prove, that P does not equal NP.

Techniques Used to Prove Lower Bounds

While we do not know if P = NP or not, complexity theorists have developed combinatorics tools for proving unconditional lower bounds on the run time of specific computational problems. By doing so, these tools demonstrate problems require super-polynomial time in the worst case. Three key techniques used are diagonalization arguments, adversarial arguments, and counting arguments. These methods leverage the pigeonhole principle, permutations, problem encoding schemes, and other tools from discrete math to formally rule out polynomial time solutions.

Diagonalization

Diagonalization is a technique where an algorithm is created to differ from every possible algorithm of a certain runtime bound. This proves there cannot exist any algorithm within that bound for the target problem. It was developed by complexity theorists to demonstrate problems that require super-polynomial running time.

Formally, diagonalization relies on the fact there are a countable number of Turing machines with a runtime bounded by any polynomial p(n). We construct a machine D that solves some problem Q such that D differs from the i-th machine Di on input i for every i. Therefore, D solves Q yet differs from every Di, proving Q requires more than p(n) time. Consider this Python code demonstrating diagonalization for a simple problem:

def D(i):
  Run Di on input i for p(|i|) steps  
  if Di accepts i within p(|i|) steps:
     return 0
  else 
     return 1

def Q(i):
  return D(i)  

Here Q solves a decision problem by leveraging diagonalization machine D. Since D differs from every machine Di bounded by p(n), this shows Q requires more than p(n) time. Diagonalization arguments of this form can prove unconditional super-polynomial lower bounds on decision problems.

Adversarial Arguments

Adversarial arguments aim to demonstrate a problem cannot have an efficient algorithm by using an adversarial strategy. We assume such an efficient algorithm A exists for the problem. An adversary then develops a strategy to construct hard inputs that seemingly break our assumption on A’s efficiency. This contradiction implies A cannot exist.

For example, consider the MAJORITY function on n boolean inputs. An adversary can force any deterministic algorithm to fail in worst case O(n) time. On each query, the adversary replies FALSE if b is still a possible output, else replies TRUE. This forces 2n queries to determine the output, proving no O(n)-time algorithm exists.

Adversary MAJORITY(A, n):
   Set B = [True, False]  
   While |B| > 1:
      Query input i from A
      If B contains only True or only False:
         Reply(True) 
      Else:
         Reply(False)
      Remove from B outcomes inconsistent with replies
   Return

Similar adversarial strategies can construct hard instances and derive lower bounds for problems in areas like game theory, learning theory, data structures, and cryptography security.

Counting and Encoding Arguments

Counting arguments analyze the number of possible outputs a problem can have versus the maximum number of outputs an efficient algorithm can generate. A difference in these quantities proves no efficient solution exists. Similarly, encoding arguments take a problem with known lower bounds and reduce it to another problem to transfer hardness.

As an example, consider the CLIQUE decision problem of determining if a graph has a k-clique subgraph. There are 2^(n choose 2) possible undirected graphs on n vertices. However, any algorithm running in O(n^k) time can only uniquely encode at most O(n^(2k)) possible outputs. For large enough k, these quantities differ exponentially, implying no polynomial-time algorithm for CLIQUE exists.

We can extend this via encoding schemes. SET-COVER reduces to CLIQUE, inheriting SET-COVER’s known polynomial lower bound. This demonstrates by a counting argument and encoding reduction that CLIQUE requires super-polynomial time.

Open Problems Using These Techniques

While diagonalization, adversarial arguments, and counting arguments cannot resolve P vs. NP on their own, they have been extensively used to prove lower bounds on natural and important problems across many domains. Further progress using these techniques and encodings could continue demonstrating more unconditional hardness results.

Specific open problems where these methods may successfully prove new lower bounds include graph isomorphism testing, ranking search results by relevance, protein structure prediction, breaking certain cryptography schemes, and solving games like Go strategically. Any progress on formally reducing the solution space for these problems could have major theoretical and practical implications in computer science.

Limitations

While the combinatorics tools discussed prove unconditional lower bounds and possibility results on what cannot be efficiently computed, they have limitations. These techniques generally apply only to decision and functional problems. Often gaps exist between proven lower bounds and the fastest known algorithms. These methods also rely on reductions and problem encodings that simplify real-world complexity.

Additionally, these techniques are unable to resolve fundamental questions about non-determinism and probabilistic algorithms. New frameworks incorporating probability, interactive proofs, and quantum computing may be required before significant progress can be made on problems like P vs. NP. Nonetheless, combinatorics arguments establish hardness baselines useful across complexity theory.

Closing Thoughts

Techniques like diagonalization, adversarial arguments, and counting transforms leverage discrete math and logic to prove unconditional lower bounds on computational problems. They formalize the minimum level of algorithmic resources needed for broad classes of problems. While not resolving whether P = NP, these combinatorics methods demonstrate many important problems require super-polynomial running time.

Ongoing work translating practical problems into formal frameworks where these techniques apply could continue advancing knowledge around algorithmic tractability. As computer scientists develop new mathematical and statistical tools for understanding complexity, we move closer toward definitive resolutions even on questions as far-reaching as P vs. NP.