The Cook-Levin Theorem (1971, 1973)

Recall from last day we stated the Cook-Levin Theorem as:

Theorem.
(1) SAT is `NP`-complete.
(2) 3SAT is `NP`-complete.

Proof. Last day, we showed both of these problems are in `NP`. We also showed that for any `l` variable Boolean function we can represent it with a `l cdot 2^l` size CNF formula. We now show SAT is `NP`-hard.

Proof that SAT is `NP`-hard

Suppose `L` is in `NP`. Then there is a polynomial time TM `M = langle Gamma, Q, delta rangle` such that for every `x in {0, 1}^star`, `x in L` iff `M(x, u) =1 ` for some `u in {0, 1}^(p(|x|))`, where `p:NN -> NN` is some polynomial.
We show `L` is polynomial time reducible to SAT by describing a p-time transformation `x -> phi_x` from strings to CNF formulas such that `x in L` iff `phi_x` is satisfiable.
Without loss of generality, we assume `M` has only two tapes: an input tape and a work/output tape. We also assume that `M` is an oblivious TM. These assumptions involve at most a `O(T log T)` slowdown in `M` so would not affect whether we were in `NP` or not.
A snapshot of M's execution on some input `y` at a particular step `i` is the triple `langle a, b, q rangle in Gamma times Gamma times Q` such that `a` and `b` are the symbols read by `M`'s heads and `q` is the state `M` is in at step `i`.
For every `y in {0, 1}^star` the snapshot of `M`'s execution on `y` at the `i`th step depends on (a) its state at the `(i-1)`st step and (b) the contents of the current cells of its input and work tapes.
We would like somehow to check with a boolean formula whether or not some sequence of snapshots represents a valid computation of `M` on `x,u`.

Checking Snapshots

To check a sequence of snapshots, it suffices to check for each `i le T(n)`, the snapshot `z_i` is correct given the snapshot for the previous `i -1` steps.
However, since the TM can only read/modify one bit at a time, to check the correctness of `z_i` we need to only look a two previous snapshots.
Specifically, we need to look at `z_(i-1)`, `y_(mbox(inputpos)(i))`, `z_(mbox(prev)(i))`. Here `y` is short for `x,u`; `mbox(inputpos)(i)` denotes the location of `M`'s input tape head at the `i`th step; and `prev(i)` is the last step before `i` when `M`'s head was in the same cell on its work tape that it is in step `i` (for base case, we define `mbox(prev)(i) = 1`).
For every triple `z_(i-1)`, `y_(mbox(inputpos)(i))`, `z_(mbox(prev)(i))`, there is at most one value of `z_i` that is correct.
Let `c` be the length of an encoding of a snapshot. So there is some Boolean function `F:{0,1}^(2c+1) -> {0,1}^c` such that a correct `z_i` satisfies:
`z_i = F(z_{i-1}, z_(mbox(prev)(i)), y_(mbox(inputpos)(i)) )`
Because `M` is oblivious, the values `mbox(inputpos)(i)` and `mbox(prev)(i)` do not depend on the particular input `y`. Also, these indices can be computed in polynomial time by simulating `M` on some trivial input.
...

More Checking Snapshots

So `x in L` iff `M(x, u) =1` for some `u in {0, 1}^(p(n))`.
The latter occurs iff there exists a string `y in {0, 1}^(n+p(n))` and a sequence of strings `z_1, ..., z_(T(n)) in {0, 1}^c` satisfying the following four conditions:
1. The first `n` bits of `y` equal `x`.
2. The string `z_1` encodes the triple `langle Delta, square, q_mbox(start) rangle`.
3. For every `i in {2, ... T(n)}`, `z_i = F(z_(i-1), z_(mbox(prev)(i)), y_(mbox(inputpos)(i)) )`
4. The last string `z_(T(n))` encodes a snapshot in which the machine halts with a `1`.
The formula `phi_x` will take `y in {0, 1}^(n+p(n))` and `z in {0, 1}^(cT(n))` and will verify the AND of these four conditions.
Condition 1 can be checked with a CNF of of size 4n, Condition (2) and (4) can be check with a circuit of size `c2^c`
So one can check the size of this whole CNF is less than `4n + 2c2^c + T(n)(3c+1)2^(3c+1)`, which is `O(n+T(n))` so is polynomial in the running time of `M` and also can be computed in time polynomial in this running time.

Quiz

Which of the following statements is known to be true (by most Theory CS people)?

A certificate that is verified by a verifier in an NP problem can be exponentially long.
`EXP subseteq NP`.
All Boolean functions from `f:{0,1}^n -> {0,1}` can be represented as conjunctive normal form formulas.

3SAT is `NP`-HARD

Lemma. `mbox(SAT) le_p mbox(3SAT)`.

Given an instance `Psi` of SAT, we first scan it to determine the largest index `i` or a variable `u_i` used in the formula. We then scan each clause in `Psi` looking at clauses. If the clause is less than or equal to length 3 we copy it to the output tape. On one of our work tapes we have a counter `j` that starts at the value `i+1` where `i` is the largest index we just found. If a clause is `l_(i_1) vv .. vv l_(i_m)` where `m > 3`, we output the sequence of clauses `l_(i_1) vv l_(i_2) vv u_j`, `bar u_j vv l_(i_3) vv u_(j+1),` ...`, bar u_(j+w) vvl_(i_(m-1)) vv l_(i_m)` where `w` will be around `m/3`. The resulting clauses on the output tape is the value of our reduction on `Psi`. It is easy to check the original clauses will be satisfiable iff only the output clauses are sastifiable. Further the output clauses all have length less than or equal to 3.

Some Remarks on Cook-Levin

Our proof of Cook Levin, using our efficient `O(T log T )` simulation of a TM by a UTM, yield for every `x in L` a formula `phi_x` of size `O(T log T)`.
This reduction also produces a quick way to map from certificates for `x` in `L` to a satisfying assignment for `phi_x`. So the reduction is a so-called Levin reduction.
One can modify the proof slightly in fact so that the set of certificates for `x` and satisfying assignments for `phi_x` are in one to one correspondence. So it is a parsimonious reduction.

Finish Cook-Levin