# Lecture 3:

# Immermann-Szelepcsenyi (1987)

got the Gödel Prize in 1995! ⟶ solved many problems in the aftermath

\[coNSPACE(f(n)) ⊆ NSPACE(f(n))\]

Th: Immermann-Szelepcsenyi:for $f(n)≥ \log (n)$

*Reminder*: GAP is a.k.a REACH

First step: \(coGAP ∈ NL\)

is there NO path between $s$ and $t$?

We will guess the set of reachable states, but we can’t remember them (too large: doesn’t fit in Logspace) ⟶ instead, one remembers their number

```
d = 0; N = 1
repeat
pN = N # previous value of N
N = 0
for all nodes n in G:
new = false # is it a new one ?
cpt = 0
for all nodes n' in G:
guess if s ⟶_≤d n' # the NL algo for GAP
if yes:
cpt += 1
if n' ⟶_≤1 n:
-> if n == t: reject
N += 1
new = true
if cpt < pN:
reject # the machine has forgotten some paths s ⟶_≤d n'
d = d+1 # N is the new value
until N = pN
-> now accept
```

The run which always guesses right gives the correct computation.

What about $t$? ⟶ the $→$ at the beginning of the lines

Now when it comes to our $f$:

Let $L ∈ coNSPACE(f(n))$

⟹ there exists a non-deterministic TM $ℳ$ recognizing $L$

Given $x ∈ A^\ast$, let’s build a non-deterministic (in space $f(n)$) TM $ℳ’$ which decides “$ℳ$ rejects $x$”.

⟹ Now the graph is the configurations of $ℳ$ on $x$.

$ℳ’$ runs algo for coGAP on this graph, with $s$ being the initial configuration on $x$, $t$ being a final one.

But one has to add those instructions:

```
(at the beginning)
size seen so far = size of |x|
(after the initial repeat)
configuration of size ≤ size seen so far + O(1)
# to go from one node to another, without testing all the possible configurations (it would require that f is computable)
```

**NB**: $f ≥ \log n$ because of the pointer in the input ⟶ not bounded by $f$, bu the need to store it in the configurations.

\[coNL ⊆ NL\]

Corollary: for $f = \log$:

And as $co(coNL) = NL$, we have the other inclusion:

\[coNL = NL\]And
**__**

*Conjecture*:

# QBF: Quantified Boolean Formulae

*Ex*: $∃x. ∀y. (x ∧ ∃z.(y ∧ z))$

\[QBF ∈ PSPACE\]

Recursive algorithm:

```
eval(φ):
if φ = ∃x. ψ:
eval(ψ[x←true]) or eval(ψ[x←false])
if φ = ∀x. ψ:
eval(ψ[x←true]) and eval(ψ[x←false])
if φ = ψ ∨ χ:
eval(ψ) or eval(χ)
if φ = ψ ∧ χ:
eval(ψ) and eval(χ)
if φ = true:
return true
else:
return false
```

Stack of size $\vert φ \vert$, each level being of size $\vert φ \vert$ ⟶ overall space memory = $\vert φ \vert^2$

$QBF$ is $PSPACE$-complete

*Proof*: we will reuse the same ideas than when we showed that $NP \ni L ≼ SAT$

$L$ recognized by $ℳ$ in time $t(n)$, space $f(n)$.

We will assume, wlog, that the machine writes on the input tape, in space $≤ f(n)$.

As the space is now in $f(n)$, the time is exponential in $f(n)$, so we use the quantifiers of the QBF formula to resort to dichotomy on the time.

The problem is that the formulas “going from $x$ to $y$ in $2^d$ steps” use exponential space ⟶ trick: we use universal quantifiers not to copy them twice at each recursive step.

## Leave a comment