Outline

• The Polynomial Hierarchy
• Quiz
• Alternating Time

The Polynomial Hierarchy

• We next look at some problems that seem not to be captured by `NP`-completeness, but seem to be weaker than all of `PSPACE`.
• Recall the problem `INDSET = {(G,k) | mbox(graph G has an independent set of size ) ge k }`. We already showed this problem is `NP`-complete.
• Consider now the following natural variant on this problem: `EXACT` `INDSET`, the set of ordered pairs `(G, k)` such that the largest independent set in `G` has `k` elements.
• `INDSET` had a short certificate for membership, but the latter does not.
• Instead `(G,k)` is in `EXACT` `INDSET` iff there exists an independent set of size `k` in `G` such that for every other independent `S` the size of `S` is less than or equal to `k`.

The Polynomial Hierarchy - Definition 1

Definition. For `i ge 1`, a language `L` is in `Sigma_i^p` if there exists a `p`-time TM M and a polynomial `q` such that
`x in L \iff exists u_1 \in {0,1}^(q(|x|))forall u_2 \in {0,1}^(q(|x|)) ... Q_iu_i\in {0,1}^(q(|x|)) M(x, u_1 ..., u_i) = 1`.
where `Q_i` is either `exists` or `forall` depending on whether `i` is even or odd. We write `\Pi_i^p` for the languages which have the rolls of `exists` and `forall` interchanged in the above. Alternatively, it consists of the class of complements of `Sigma_i^p` languages. Lastly, we define `PH = cup_i Sigma_i^p`.

It should be reasonably clear that `Sigma_i^p subseteq Pi_(i+1)^p subseteq Sigma_(i+2)^p`. Also, `NP = Sigma_1^p` and `coNP = Pi_1^p`

Theorem. `PH` is contained in `PSPACE`.

(Sketch). Use auxiliary tapes to cycle over possibilities for `u_i`'s.

Quiz

Which of the following statements is true?

1. SPACE(n) might equal EXP.
2. PSPACE is contained in EXP.
3. NL is different from coNL.

On Collapse

Theorem.
(1) For every `i ge 1`, if `Sigma_i^p = Pi_i^p` then `PH = Sigma_i^p`.
(2) If `P = NP` then `PH =P`; that is, the hierarchy collapses to `P`.

Proof. (1) The idea is a basically a proof by induction on `j ge i`. We show `Sigma_j^p = Pi_i^p`. The base case `j=i` is by assumption. So consider some `j > i`. Let `L` be a language in `Pi_(j+1)^p`, it can be defined as a formula consisting of a `forall` followed by a `Sigma_j^p` formula. Rewrite the `Sigma_j^p` formula as a `Pi_i^p` formula using the induction hypothesis, then collapse the adjacent `forall` quantifiers to make the whole thing `Pi_i^p`. This shows `Pi_(j+1)^p` is in `Pi_i^p`. As we are assuming `Pi_i^p =Sigma_i^p`, we are closed under complement so we also get `Sigma_(j+1)^p = Pi_i^p`. (2) Follows by (1) noting that `P` is closed under complement.

On Collapse II

Theorem. If there exists a language `L` that is `PH`-complete, then there exists an `i` such that `PH = Sigma_i^p`.

Proof. Since `L in PH`, `L` is in `Sigma_i^p` for some `i`. Since `L` is PH-complete we can reduce any problem in `PH` to `L`. But every language `p`-reducible to `Sigma_i^p` is itself `Sigma_i^p`.

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 `p`-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.