Improving The Log Factor In The Time Hierarchy Theorem

The Fundamental Challenge

Hierarchy theorems are fundamental results in computational complexity theory that formalize the intuitive notion that more complex computational problems require more resources to solve. These theorems characterize broad complexity classes such as P and NP in terms of the number of steps required for a Turing machine or circuit family to solve problems in those classes.

A key component of hierarchy theorems is the presence of logarithmic factors in the bounds relating problem complexity and computational resources. For example, the classic time hierarchy theorem shows that problems solvable in O(n^k) time are strictly harder than those solvable in O(n^{k-1}) time. The logarithmic factor in these bounds is necessary to prove separation.

Removing or improving these logarithmic factors has remained an elusive goal for the theory community. Doing so would bring hierarchy theorems more in line with the intuitive growth rates for complexity classes while also having profound implications for major open questions like P vs NP.

The Role of Logarithmic Factors

To understand the challenges around improving logarithmic factors in hierarchy theorems, we must examine their origin. Most hierarchy theorems rely on diagonalization arguments, which allow separating two complexity classes C and D by using a machine for C to solve a problem just outside D.

For example, given a machine M that runs in n^{k-1} time, we can diagonalize to construct a problem that requires n^k time, thus separating the classes. The logarithmic overhead in the separation appears because diagonalization relies on simulations of Turing machines or circuits, which incur logarithmic slowdowns.

Why Removing Logs is Difficult

Eliminating these logarithmic overheads would require a radically new technique that avoids reliance on simulations. All known proofs intrinsically use simulation and thus accrue logarithmic factors. Removing logs likely requires proving hierarchy theorems using completely different arguments.

In addition, hierarchy theorems have deep connections to fundamental circuit lower bounds. Improving hierarchy theorem bounds could imply breakthroughs on longstanding open problems about minimum circuit sizes.

For these reasons, removing all logarithmic factors has remained elusive despite much effort from leading researchers. But incremental improvements remain an important goal for both practical and philosophical reasons.

Techniques for Removing Log Factors

Diagonalization Arguments

The most commonly used approach for proving hierarchy theorems is diagonalization. As originally laid out by Cantor, a diagonal argument allows proving that for any purported enumeration of elements of a set S, we can always construct another element not in the enumeration.

Computational complexity adopted this technique to separate complexity classes. For functions f and g, if g eventually dominates f, then diagonalization against g can construct problems not computable in the bounds for f. Adding another logarithmic factor to g ensures its eventual domination even in the face of constant overhead from simulating steps of g.

Relationship to Circuit Lower Bounds

Hierarchy theorems are deeply connected to boolean circuit lower bounds. For example, the time hierarchy theorem is equivalent to lower bounds on what problems are solvable by circuits with a limited number of gates.

Techniques that improve hierarchy theorems could thus imply circuit lower bound breakthroughs. This connection runs both ways however – unconditional circuit lower bound progress might also suggest approaches for removing logs.

Example Diagonalization Code

function diagonalize(machine M, time_constructible t) {

  run M on input n for t(n) steps
  
  if M halts in time t(n) 
    return a problem diagonally different from M's output 

  else 
    return a problem solvable in c*t(n) time for constant c
}

This code demonstrates how diagonalization relies on simulating machines for constructing problems requiring more resources. The logarithmic simulation overheads motivate including extra log factors in hierarchy theorems.

Obstacles to Removing All Log Factors

Connecting Logs to Circuit Lower Bounds

Hierarchy theorems are deeply connected to longstanding open problems regarding Boolean circuit size complexity. For example, proving problems require ω(n^k) circuit size would imply an improved time hierarchy theorem without any logarithmic factors.

Some of the obstacles around improving hierarchy theorems are intrinsically tied to fundamental limitations around proving circuit lower bounds. Techniques that make progress may have to contend with these barriers.

Relativization and Oracle Results

Relativization and oracle results present another barrier around removing logarithmic factors unconditionally. These techniques show that for any candidate time hierarchy theorem proof, we can construct oracle worlds where logs still appear.

This suggests that overcoming logs likely requires non-relativizing proof techniques, unlike most results in complexity theory. Coming up with fundamentally new proof approaches is highly challenging.

Role of Simulations

As highlighted earlier, known proofs rely heavily on simulating Turing machines or circuit families to enable diagonalization. These simulations impose intrinsic logarithmic slowdowns that propagate to the final theorems.

Removing these factors may necessitate formulating alternative proof strategies that do not use simulation. All current proof techniques lean on simulation, so radical new ideas are needed.

Potential Approaches

Algebraic Proof Techniques

One speculative direction is using algebraic proof approaches instead of relying only on simulations. Early ideas along these lines attempt to characterize complexity classes in terms of algebraic analogues and group theory properties.

By avoiding cumbersome mechanisms simulating sequential computations, proofs in this framework might manage to eliminate logarithmic overheads inherent to diagonalization. However making algebraic techniques work at the same scale as simulation-based arguments has remained elusive.

Example Code Using Algebraic Techniques

group P {
  generators: (primitive operations) 
  relations: (constraints about equivalence)
}

group NP {
  generators: (verifiers for NP problems)
  relations: (constraints about accepting/rejecting) 
}

theorem: P and NP have divergent algebraic structure, so cannot be equivalent groups even without logarithmic separations between them

This code sketches how complexity classes can be expressed as algebraic objects capturing their essential structure. Proving hierarchy theorems could then involve separating structural properties rather than accrued simulation overheads. The feasibility of such an approach remains unclear though.

Non-Standard Models of Computation

Another outside-the-box idea is formulating hierarchy theorems using non-standard models of computation instead of standard multiparty Turing machines. For example, by using models like cellular automata that have very uniform transition steps, the need for simulation may be reduced.

However recasting all existing hierarchy theorems in terms of exotic models is highly nontrivial. Ultimately standard models have proved most elegant for developing complexity theory. Still, non-standard computations offer food for thought around improved hierarchies.

Open Questions

Summary of Progress So Far

Hierarchy theorems stand as landmark results formally separating key complexity classes using logarithmic separations. But despite longstanding interest, eliminating or even substantially improving these logarithmic factors via new techniques has remained elusive over decades of research.

Small incremental gains have been made through advanced analysis of specific machine models and cost measures. But unconditionally removing all logarithmic overheads has stubbornly resisted attack. Still this objective remains an important open direction.Path Forward for the Community

To make progress on this challenge, researchers should expand the toolbox of proof techniques beyond standard diagonalization arguments. For example, borrowing ideas from proof methods in algebra, logic or other formal systems could suggest approaches less reliant on simulation.

In addition, building connections between hierarchy theorems and other major open problems like circuit lower bounds may yield mutual benefits. A creative new idea that yields hierarchies without logarithms could have widespread implications in complexity theory.

With sufficient collective imagination and technical depth, perhaps the longstanding goal of no-logs hierarchy theorems may yet come within reach and unlock further insights about the nature of efficient computation.