Lecture 4: Alternating Turing Machines

Recap:

\[L ≝ SPACE(\log(n))\\ ⊆ NL ≝ NSPACE(\log(n)) = coNL \\ ⊆ P ≝ TIME(n^{O(1)}) \\ ⊆ NP ≝ NTIME(n^{O(1)}) \\ ⊆ PSPACE ≝ SPACE(n^{O(1)}) \overset{\text{Savitch}}{=} NPSPACE \overset{\text{Immermann}}{=} coNPSACE\]

Alternating Turing Machines

Kozen (1976)

An Alternating Turing Machine:

$ℳ ≝ (Q_∃, Q_∀, Γ, q_0, Δ, F, R)$ where $Q ≝ Q_∃ \sqcup Q_∀$

NB: ndT ⟺ $Q_∀ = ∅$

A configuration of ATM $ℳ$ on input $x$:

is a tree TM configurations s.t. if the trees $T_1, ⋯, T_n$ are children of $C$

• if $C$ is accepting/rejecting, then $n=0$ ($q∈ F, R$, the tree is a leaf)

• if $C$ is existential ($q ∈ Q_∃ \backslash (F ∪ R)$), then

  • $n ≤ 1$
  • $C \overset{Δ}{⟶} root(T)$ if $n=1$

• if $C$ is universal ($q∈ Q_∀ \backslash (F ∪ R)$), then:

  • for all $C \overset{Δ}{⟶} C’$ , there is a $T_i$ with root $C’$

A computation tree is accepting:

if all leaves are accepting

An input is accepted by $ℳ$:

if there’s an accepting tree rooted at $C_0(x)$

An ATM runs in $TIME(f)$ (resp. $SPACE(f)$):

every computation tree rooted in $C_0(x)$ has height/all branches of length $≤ f(\vert x \vert)$ (resp. all visited configurations (in the tree) of size $≤ g(\vert x \vert)$)

⟶ $ATIME(f), ASPACE(f)$

and

\[TIME(f) ⊆ NTIME(f) ⊆ ATIME(f) \\ SPACE(f) ⊆ NSPACE(f) ⊆ ASPACE(f)\]

(TM are special cases of NTM, which themselves are special cases of ATM)

\[QBF ∈ AP ≝ ATIME(n^{O(1)})\]

Input: formula of the form

\[∃ x_1, ∀ x_2, ⋯, ∃x_n. \bigwedge_i \bigwedge_j ± x_{i, j}\]

Existentially guess, universally check: for each

• existentially quantified variable $x_i$: one guesses a value $true$ or $false$
• universally quantified $x_j$: are given all possible values ($true$ and $false$: one in each copy/thread of the ATM)

then: formula evaluated

Corollary: \(PSPACE ⊆ AP\)

Because QBF is PSPACE-hard (since it is PSPACE-complete): for all $L ∈ PSPACE$:

\[L ≼_{\bf L} QBF ∈ AP\]

---

Th: \(PSPACE = AP\)

Proof: Only need to show $AP ⊆ PSPACE$

Let $L ∈ AP$, recognized by $ℳ$.

There is a PSPACE machine $ℳ’$ that recognizes $L$ (that recognizes $L$ (says if $ℳ$ accepts $x$))

$ℳ’$ simulates $ℳ$ as follows:

• define val(C) (value of a configuration)
• evaluate vale(C_0(x))

val(C) ≝ looks at q:
    if q ∈ F: return YES
    if q ∈ R: return NO
    if q ∈ Q_∃, evaluate
        val(C_1) ∨ ⋯ ∨ val(C_n)
        for all C_i s.t. C ⟶ C_i
    if q ∈ Q_∃, evaluate
        val(C_1) ∧ ⋯ ∧ val(C_n)
        for all C_i s.t. C ⟶ C_i```

The program terminates since the machine $ℳ$ terminates on any input. Stack of size $p(n)$ at most, comprised of configurations of size $p(n)$ ⟹ space bounded by $(p(n))^2$

Can be generalized to \(SPACE(poly(f(n))) = ATIME(poly(f(n)))\) for $f(n) ≥ n$

Logical problems

HornSAT:

Conjunction of clauses with at most one positive litteral

Circuit Value:

an acyclic directed graph with

• nodes labelled with $∨, ∧, \overline{∨}, \overline{∧}$
• a distinguished output node
• answer = YES if the output node evaluates to true.

  digraph {
    rankdir=LR;
    z1, z2[label=0, shape=none]
    u1[label=1, shape=none]
    or1, or2[label=∨, shape=square];
    and[label=∧, shape=square];
    bl[shape=none, label=""]
    z1 -> or1;
    u1 -> or1, and;
    z2 -> and;
    or1 -> or2[label=1];
    and -> or2[label=0];
    or2 -> bl[label=1];
  }

How is it different from evaluating a boolean expression?

⟶ value not kept on the stack, but in memory

Boolean formulas ≡ Circuit values for trees (not just a general acyclic DAG)

for example: in the previous example, the 1 on the left is shared.

In boolean formulas: subexpressions that are identical can thought of as shared ⟹ general circuit value

Monotone Circuit Value (MCV):

CV but only uses $∨, ∧$ (so the output cannot but increase when changed)

---

\[MCV ≼_{\bf L} CV ≼_{\bf L} HornSAT\]

(the first reduction is trivial (special case), we’ll focus on the second one)