Computational Complexity Theory, Fall 2008
September 5
Lecture 4: Alternation, Polynomial Time Hierarchy
Lecturer: Kristoffer Arnsfelt Hansen
1
Scribe: Jakob Truelsen
Alternating Turing Machines
An Alternating Turing Machine (ATM) is a generalization of the nondeterministic TM. It is like a
nondeterministic TM but with the states divided into types.
Definition 1 (ATM) M is called an ATM if it has the following form:
M = (Q, Σ, Γ, q0 , δ, type), where
|Q| < ∞
Finite set of states
|Σ| < ∞
Finite set of input symbols
|Γ| < ∞ ∧ Σ ⊆ Γ
Finite set of tape symbols
q0 ∈ Q
The starting state
δ : Q × Γ → 2Q∪{Ha ,Hr }×{L,R,S}×Γ The transition function
type : Q → {∧, ∨, ¬}
The type function.
For any configuration c, let Q(c) be the state of c and S(c) the set of all possible successor
configurations.
We further require that for any configuration c, type(c) = ”¬” ⇒ |S(c)| = 1.
We define the predicate “eventually accepting” EA(c) on a configuration c to be true iff any of
the following conditions are met:
• Q(c) = Ha
• type(Q(c)) = ” ∨ ” ∧ ∃c0 ∈ S(c) : EA(c0 )
• type(Q(c)) = ” ∧ ” ∧ ∀c0 ∈ S(c) : EA(c0 )
• type(Q(c)) = ”¬” ∧ {c0 } = S(c) ∧ ER(c0 )
where ER(c) is the predicate “eventually rejecting” which is true iff any of the following conditions are met:
• Q(c) = Hr
• type(Q(c)) = ” ∨ ” ∧ ∀c0 ∈ S(c) : ER(c0 )
• type(Q(c)) = ” ∧ ” ∧ ∃c0 ∈ S(c) : ER(c0 )
• type(Q(c)) = ”¬” ∧ {c0 } = S(c) ∧ EA(c0 )
We define L(M ) = {x ∈ Σ∗ |ER(initial configuration(x))}.
The definition of multi-tape, time consumption and space consumption is the same as always.
1
Definition 2 We will now define language classes for the ATMs.
ATIME(T (n)) is the class of languages accepted by an ATM in time O(T (n))
ASPACE(S(n)) is the class of languages accepted by an ATM in space O(S(n))
Lemma 3 All ¬-states can be eliminated at no cost.
Proof Let M = (Q, Σ, Γ, q0 , δ, t) be an ATM. Construct the dual machine M 0 = (Q0 , Σ, Γ, q00 , δ 0 , t0 ),
where Q0 ∩ Q = ∅, and we have a a bijective mapping from Q0 to Q; for q ∈ Q let q 0 ∈ Q0 be the
image of q in this mapping.
δ 0 is as δ but every state q has been replaced with q 0 , and Ha and Hr are swapped.

 ” ∧ ” if t(q) = ” ∨ ”
” ∨ ” if t(q) = ” ∧ ”
t0 (q 0 ) =

”¬” if t(q) = ”¬”
Now we define M̂ = (Q ∪ Q0 , Σ, Γ, q0 , δ̂, t̂)

 t(q) if q ∈ Q ∧ t(q) 6= ”¬”
t0 (q) if q ∈ Q0 ∧ t0 (q) 6= ”¬”
t̂(q) =

” ∧ ” otherwise

δ(q, γ) if q ∈ Q ∧ t(q) 6= ”¬”


 0
δ (q, γ) if q ∈ Q0 ∧ t0 (q) 6= ”¬”
δ̂(q, γ) =
δ 0 (q 0 , γ) if q ∈ Q ∧ t(q) = ”¬”



δ(q 0 , γ) if q ∈ Q0 ∧ t0 (q) = ”¬”
Figure 1: ¬ Elimination
Then, L(M̂ ) = L(M ). All that is needed for the proof is DeMorgan’s laws.
Thus, we do not gain anything using negation states.
Theorem 4 Assuming T (n) ≥ n, and S(n) ≥ n, we will show the following inclusions for complexity classes:
a) AT IM E(T (n)) ⊆ DSP ACE(T (n))
b) N SP ACE(S(n)) ⊆ AT IM E(S(n)2 )
c) ASP ACE(S(n)) ⊆ DT IM E(2O(S(n)) )
2
d) DT IM E(T (n)) ⊆ ASP ACE(log T (n))
Proof
a) We can afford to store a path in the computation tree as the outdegree of each node is a constant
(the constant depends on the machine). We can also afford to store an extra bit for each node
on the path.
We will do a DFS traversal computing the “eventually accepting” predicate for every node in
the computation tree, ending up with the root, which holds the answer. For each node on the
current path, we will store the partial result of the predicate (we can evaluate a ∨ b ∨ .. ∨ z as
((a ∨ b) ∨ ..) ∨ z, the same goes for ∧).
To do this, we need T (n) to be space-constructible. However, we can avoid this assumption by
trying with increasing depth (starting from 0 and incrementing by 1) until the predicate of the
root can be calculated.
b) For configurations u, v, we define Reach(u, v, i) to be true iff there is a path from u to v in the
configuration graph of length ≤ 2i .
We want to compute Reach(s, t, O(S(n))) for all accepting configurations t.
Let E be the edges of the configuration graph, Reach can be defined as follows
Reach(u, v, i) ⇐⇒ (u, v) ∈ E ∨ ∃w : Reach(u, w, i − 1) ∧ Reach(w, v, i − 1)
Build alternating machine, branch using ∨-type states over all configurations w (standard nondeterminism), branch in two for the ∧ using ∧-type state.
Guessing w takes time O(S(n)) time, and we do O(S(n)) levels. Total time is thus as promised.
c) Construct the configuration graph. Its size is 2O(S(n)) . We will compute the “eventually accepting” predicate for each state. First we mark (Ha , ∗) as “eventually accepting”. Then we
do closure by rounds. In every round, we check for each configuration if it leads to a state
marked as “eventually accepting”, and mark it if that is the case. We will need at most
2O(S(n)) rounds to complete the closure, each taking time 2O(S(n)) . The total time is thus
2O(S(n)) · 2O(S(n)) = 2O(S(n)) .
d) We know that DT IM E(T (n)) ⊆ UL -SIZE(O(T (n)2 )). So it is enough to show that
UL -SIZE(O(T (n)2 )) ⊆ ASP ACE(log T (n)).
That is given a machine that M outputs a circuit in O(log T (n)) space, we must construct a
ATM that evaluates the circuit.
First the terminal gate can be calculated by running M (|x|),
An or-gate can be evaluated by finding all of it input gates by running M (|x|). And using
” ∨ ”-type states, evaluating the the input gates. We do only need to remember two gates to do
this.
An and-gate can be evaluated by finding all of it it input gates by running M (|x|). And using
” ∧ ”-type states, evaluating the input gates.
3
Corollary 5 As a corollary we see that combining a) and b) yields:
AT IM E(T (n)O(1) ) = DSP ACE(T (n)O(1) )
combining c) and d) yields:
ASP ACE(S(n)) = DT IM E(2O(S(n)) )
By defining:
AL = ASP ACE(log n)
AP
= AT IM E(nO(1) )
AP SP ACE = ASP ACE(nO(1) )
AEXP
O(1)
= AT IM E(2n
)
We have that
AL = P
AP
= P SP ACE
ASP ACE = EXP
AEXP
2
= EXP SP ACE
The Polynomial Time Hierachy (PH)
Definition 6 We recall the definiton of N P
N P = {L ⊆ Σ∗ |∃p ∈ R[x] ∧ R ∈ P : x ∈ L ⇐⇒ (∃y : |y| ≤ p(|x|) ∧ (x, y) ∈ R)}
We will now look at the language MIN-CNF. The language of CNF formulas that are minimal
in size.
D ∈ MIN-CNF ⇐⇒ ∀W ∃x : |W | < |D| → D(x) 6= W (x)
It is not at all obvious if MIN-CNF ∈ N P . So we define the polynomial time hierarchy, and this
contains classes where membership of MIN-CNF is obvious.
Definition 7 First for notational convenience we define:
∃p y := ∃y : |y| ≤ p(|x|)
∀p y := ∀y : |y| ≤ p(|x|)
4
Then we define the two sets of hierarchy classes
ΣPK = {L ⊆ Σ∗ |
∃p ∈ R[x], R ∈ P : x ∈ L
⇐⇒ ∃p y1 ∀p y2 ∃p y3 . . . Qp yk : (x, y1 , . . . , yk ) ∈ R}
ΠPK = {L ⊆ Σ∗ |
∃p ∈ R[x], R ∈ P : x ∈ L
⇐⇒ ∀p y1 ∃p y2 ∀p y3 . . . Qp yk : (x, y1 , . . . , yk ) ∈ R}
Definition 8 Next we define some appropriate subsets of ATMs:
Σk machine: ATM where for all inputs and for all computation paths, the configurations are in
k intervals. All configurations in the same intervals are of the same type, and the starting interval
is of type ∨.
Πk the same, but initial type is ∧.
Proposition 9 It follows that
Σpk = {L(M )|M is polytime Σk machine }
Πpk = {L(M )|M is polytime Πk machine }
It is easy to see that N P = ΣP1 and P = ΣP0 = ΠP0
Proof First assume L in Σpk , then it is easy to construct a ATM on the Σk form. First it uses
” ∨ ”-type states to guess y1 , then ” ∧ ”-type states to check y2 and so forth. Finally it runs the
polytime machine given by the definition.
Assume M is a Σk machine and that x is accepted by M . Then there must exists a sequence
of nondeterministic choices y1 taken in the first interval, s.t. for any sequence of nondeterministic
choices of y2 taken in the second interval, and so furth. We can check in deterministic polytime
that the given sequence of choices will lead to an accept state.
A similar argument works for Π.
Lemma 10 And we see that
co-Πpk = Σpk
Πpk ∪ Σpk = Σpk+1 ∩ Σpk+1
Proof Complement swaps quantifiers and, P is closed under negation.
Definition 11 Finally we define the polynomial hierarchy to be
[ p [ p
PH =
Σk =
Πk ⊆ P SP ACE
k
k
5