Alternating Time

It is possible to generalize NDTMs to give an alternative definition of PH.
An alternating TM is (ATM) is similar to an NDTM except every internal state is labelled as either `exists` or `forall`. We say `x` is accepted by an ATM `M` if when it is in an exists state then there is a one of the two transition function which when applied leads to the machine ending up in an accepting configuration; and if when it is in a universal state, both transition function when applied lead to an accepting configuration.

Definition. (Alternating Time) For every `T: NN -> NN`, we say that an alternating TM runs in time `T(n)` if for every input `x in {0,1}^star` and for every possible sequence of transition function choices, `M` halts after at most `T(|x|)` steps. We write `ATIME(T(n))` for the languages accepted by ATM's in `c cdot T(n)` steps.

`Sigma_i``TIME(T(n))` and `Pi_i``TIME(T(n))`

Given the definition of ATM it is natural to consider restrictions on the amount of non- and co-nondetermism it can exploit by bounding the number of switches it can make between `exists` and `forall` states.
That is the motivation behind the following definition:

Definition. For every `i in N`, we define `Sigma_i``TIME(T(n))` (resp. `Pi_i``TIME(T(n))`) to be the set of languages accepted by a `T(n)`-time ATM `M` whose initial state is labelled `exists` (resp. `forall`) and on which every (directed) path from the starting configuration in the configuration graph, `M` can alternate at most `i - 1` times froms states with one label to state with the other label.

Connecting Alternation with PH

Theorem. For every `i in N`, `Sigma_i^p = cup_c Sigma_i TIME(n^c)` and `Pi_i^p = cup_c Pi_i TIME(n^c)`

Proof Sketch. Suppose a language in `Sigma_i^p` is decided using some machine `M(x, y_1, ... y_i)` after the guess of the string `y_i`. This machines runs in some time `n^c`. So a `Sigma_i TIME(n^c)` machine could use its first alternation to existentially guess the string `y_1` then switch to a sequence of `forall` states to universal choose `y_2`, and continue alternating in this fashion `i-1` times till it has all the `y_i` and then finally just simulate `M`. This shows `Sigma_i^p` is contained in `cup_c Sigma_i TIME(n^c)`. For the reverse we can modify any `Sigma_i TIME(n^c)` machine `M'` so that on each path it always makes the same number of moves `q(n)` before switch between an `exists` to a `forall` state or vice-versa. So a string `y_j` can specify the choices between the two transition functions it made on the `q(n)` moves of a given alternation. With knowledge thus of these `y_1`, ... `y_i` a deterministic machine could simulate `M'` computation on a given path. The correctness of which paths are deemed accepting for the whole computation can be enforced by appropriates choosing exists or universal guesses for the `y_j`'s in a quantifier block before this machine's computation.

Space and Alternation

Let `AP = cup_c ATIME(n^c)`.

Theorem. `AP = PSPACE`.

Proof Sketch. `PSPACE subseteq AP` follows since `TQBF` is in `AP`: Just guess the quantifier blocks using an ATM and then verify the assignment one gets for the formula. Since TQBF is `PSPACE`-complete any other language in `PSPACE` is reducible to it in `pt`-time and so will be in `AP`. To show that `AP subseteq PSPACE` we look at the configuration graph of an `AP` machine `M` on input `x`. We again do a divide and conquer approach to see if an accept configuration is reachable from the start configuration.

Time-Space Tradeoffs for SAT

As an application of our notions of alternating time, we next prove lower bounds on the simultaneous space time requirements for any algorithm for SAT.

Theorem. For every two functions `S, T: NN -> NN`, define `TISP(T(n), S(n))` to be the set of languages decided by a TM `M` that on every input `x` takes at most `O(T(|x|))` steps and uses at most `O(S(|x|))` cells of its read-write tapes. Then, `SAT !in TISP(n^(1.1), n^(0.1))`.

Remark. Stronger results are known.

Proof.

We will show that `NTIME(n)` is not contained in `TISP(n^(1.2), n^(0.2))`. This implies the result for `SAT` by following the ideas of the proof of Cook-Levin, since an analysis of that proof yields a reduction from the task of deciding membership in an `NTIME(T(n))`-language to the task of deciding whether an `O(T(n) log T(n))`-sized formula is satisfiable, where output bit of this reduction can be computed in polylogarithmic time and space. Hence, if `SAT in TISP(n^(1.1), n^(0.1))` then `NTIME(n) subseteq TISP(n^(1.1)polylog(n), n^(0.1)polylog(n))`.

More Proof of Time-Space Tradeoffs

Towards our proof, the next claim is a particular case of a general tradeoff result known as Nepomnjasci's Theorem.

Claim. `TISP(n^(12), n^(2)) subseteq Sigma_2TIME(n^8)`

Proof. Suppose that `L` is decided by a machine `M` using `n^(12)` times and `n^2` space. For every `x in {0,1}^star`, consider the configuration `G_(M,x)` of `M` on input `x`. Each configuration in this graph can be described by a string of length `O(n^2)` and `x` is in `L` iff then is a path of length `n^(12)` in this graph starting at `C_(s\t\a\r\t)` to an accepting configuration. There is such a path iff there exists `n^6` configurations `C_1 ... C_(n^6)` such that if we let `C_0 = C_(s\t\a\r\t)` then `C_(n^6)` is accepting and for every `i in [n^6]` the configuration `C_i` is computed from `C_(i-1)` within `n^6` steps. This later condition can be verified in `O(n^7)` time, giving an `O(n^8)`-time `Sigma_2`-TM for deciding membership in `L`.

We will finish the proof Monday.

More Polynomial Hierarchy