Lecture 3:

Immermann-Szelepcsenyi (1987)

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

Th: Immermann-Szelepcsenyi:

coNSPACE(f(n)) ⊆ NSPACE(f(n))

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.

Corollary: for $f = \log$:

coNL ⊆ NL

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

coNL = NL

And __

Conjecture:

coNL = NL ≠ L

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