Lecture 8

In-class notes: CS 505 Spring 2025 Lecture 8

NP-Intermediate Languages

So far, we’ve looked at many NP problems that also happen to be NP-complete. Thus, it is a natural question to ask whether all languages in NP are NP-complete. It turns out, under the widely believed conjecture that $\mathbf{P}\ne \mathbf{NP}$.

Theorem. If $\mathbf{P}\ne \mathbf{NP}$, then there exists $L\in \mathbf{NP}\setminus \mathbf{P}$ such that $L$ is not NP-complete.

In other words: if all languages $L\in \mathbf{NP}\setminus \mathbf{P}$ are NP-complete, then $\mathbf{P}=\mathbf{NP}$.

Oracle Machines

When we showed $\mathbf{DTIME}(f)⊊\mathbf{DTIME}(g)$, we utilized diagonalization. In the proof, we had a decider $D$ for some language $L\in \mathbf{DTIME}(g)$, and by contradiciton, we assumed we had a machine $M_A$ which decided $L$ in time $O(f)$. In the machine $D$, we received $M_A$ as input and simulated $M_A$ it.

At a high-level, diagonalization is possible because of two key properties.

1. Turing machines always have efficient representations as strings.
2. The universal simulation of any Turing machine given its efficient representation as a bit string does not examine the inner workings of the machine.

In the machines $D$ and $M_A$ above, the machine $D$ simulates $M_A$ obliviously: it does not even need to look at what $M_A$ is doing, it does not care about the internal mechanisms of $M_A$. Thus, $D$ is treating $M_A$ as a black-box: it gives $M_A$ some input and $M_A$ gives $D$ some output.

Oracle Turing Machines

We can abstract these two properties and define oracle Turing machines. These are special Turing machines with an additional oracle tape, and access to some oracle $\mathcal{O}$. We denote this as $M^{\mathcal{O}}$. The machine $M^{\mathcal{O}}$ can query $\mathcal{O}(x)$ for any input $x$ in a single computation step, and $\mathcal{O}(x)$ writes the output to the special oracle tape in this single computation step.

For a language $L$, we let $M^L$ denote an oracle Turing machine with an oracle to a decider for the language $L$. This allows us to define oracle complexity classes.

• ${\mathbf{P}}^L$ is the set of all languages decidable in deterministic polynomial time relative to the oracle/language $L$.
• ${\mathbf{NP}}^L$ is the set of all languages decidable in non-deterministic polynomial time relative to the oracle/language $L$.

As a concrete example, ${\mathbf{P}}^{\mathrm{SAT}}$ is the set of all languages decidable by a deterministic polynomial-time oracle Turing machine with oracle access to a decider for SAT. That is, $\mathrm{SAT}(\varphi )=1$ if and only if $\varphi$ is a satisfiable formula. Recall the complement language of SAT: $\overline{\mathrm{SAT}}$ is the set of all unsatisfiable formula $\varphi$.

Lemma. $\overline{\mathrm{SAT}}\in {\mathbf{P}}^{\mathrm{SAT}}$.

Proof. We build a deterministic polynomial time Turing machine $M$ that is given oracle access to $\mathrm{SAT}$ such that $M^{\mathrm{SAT}}(\varphi )=1$ if and only if $\varphi$ is not satisfiable. The machine $M^{\mathrm{SAT}}$ is simple. On input $\varphi$, $M$ queries $\mathrm{SAT}(\varphi )$ and outputs the opposite answer. Since $\mathrm{SAT}(\varphi )=1$ if and only if $\varphi$ is satisfiable, clearly $M^{\mathrm{SAT}}$ decides $\varphi$. Moreover, this is polynomial time. $\square$

Actually, we can show a stronger result.

Lemma. $\overline{\mathrm{SAT}}\in {\mathbf{P}}^L$ for any NP-complete language $L$.

At a high-level, given a formula $\varphi$ as input, we simply perform a polynomial-time reduction from $\varphi$ to the language $L$. For example, we can reduce $\varphi$ to a $3\mathrm{SAT}$ instance, then reduce the $3\mathrm{SAT}$ instance to $L$ (or simply do a direct reduction).

As another result, we know that oracles in $\mathbf{P}$ do not grant us more power for languages in $P$.

Theorem. For any $L\in \mathbf{P}$, we have ${\mathbf{P}}^L=\mathbf{P}$.

Proof. $\mathbf{P}\subseteq {\mathbf{P}}^L$ is immediate since every language in $\mathbf{P}$ is decidable in polynomial time without an oracle. For ${\mathbf{P}}^L\subseteq \mathbf{P}$, since $L\in \mathbf{P}$, we can convert any polynomial time Turing machine with oracle access to $L$ to another Turing machine which decides the same language but simply simulates $L$. This simulation is polynomial time, so the final time is polynomial. $\square$

Note there are powerful oracles for which $\mathbf{P}$ and $\mathbf{NP}$ are equal relative to this oracle. One such oracle is for the language $E=\mathrm{EXPCOM}$, which we define as the set of all tuples $(M,x,1^n)$ where $M(x)=1$ within $2^n$ steps.

Lemma. ${\mathbf{P}}^E={\mathbf{NP}}^E=\mathbf{EXP}$.

Proof. First, $\mathbf{EXP}\subseteq {\mathbf{P}}^E$ is immediate since any machine with oracle access to $E$ can check if an exponential time Turing machine $M$ outputs $M(x)=1$ in at most $2^n$ steps. So an exponential time computation can be done in constant time.

Second, ${\mathbf{P}}^E\subseteq {\mathbf{NP}}^E$ is trivially true since $\mathbf{P}\subseteq \mathbf{NP}$.

Third, we show that ${\mathbf{NP}}^E\subseteq \mathbf{EXP}$. Suppose that $L\in {\mathbf{NP}}^E$ and $L$ is decidable on NTM $M^E$ in time $n$. We construct machine $D$ that decides $L$ in at most $O(2^n)$ time. $D$ is given the description of $M$ and deterministically simulates $M$ on any input $x$ by simulating all possible computation paths. $D$ outputs accept if and only if there is at least one accepting computation path, and outputs reject otherwise. Since $M$ runs in non-deterministic time $n$, this simulation takes at most $O(2^n)$ time. Finally, whenever $M$ calls the oracle $E$ on input $(\hat{M},y,1^i)$ for some $i\le n$, the machine $D$ simply runs the machine $\hat{M}(y)$ for at most $2^i$ steps and returns the result.

Limits of Diagonalization

Oracle machines help us quantify the limits of diagonalization. Diagonalization is quite a powerful, and general technique, so naturally we’d like to resolve $\mathbf{P}$ vs. $\mathbf{NP}$ using it. Unfortunately, this is impossible.

Theorem. There exists oracle ${\mathcal{O}}_1$ and ${\mathcal{O}}_2$ such that

1. ${\mathbf{P}}^{{\mathcal{O}}_1}={\mathbf{NP}}^{{\mathcal{O}}_1}$; and
2. ${\mathbf{P}}^{{\mathcal{O}}_2}\ne {\mathbf{NP}}^{{\mathcal{O}}_2}$.

Proof. Setting ${\mathcal{O}}_1=E$ (the $\mathrm{EXPCOM}$ oracle), we have (1) of the theorem by our previous lemma.

Now we construct an oracle ${\mathcal{O}}_2$ to prove (2). Interestingly enough, we will use diagonalization to construct this oracle. First, let $L\subseteq \{0,1{\}}^{\ast }$ be any language. Define a new language $U_L$ as $$U_L=\{1^n|\exists x\in L\text{ s.t. }|x|=n\}.$$

Notice that $U_L\in {\mathbf{NP}}^L$ for any language $L$. To see this, define machine ${\hat{M}}^L(1^n)$ which (1) guesses $x\in \{0,1{\}}^n$; (2) outputs oracle query $L(x)$. By definition, $L(x)=1$ if and only if $x\in L$; otherwise it outputs $0$. Clearly, this non-deterministic machine decides $U_L$.

Now, we construct a new language $B$ such that $U_B\notin {\mathbf{P}}^B$. Then, we will set ${\mathcal{O}}_2=B$, completing the proof. We’ll define the language $B$ inductively, first by setting $B=\varnothing$. We’ll also have two helper sets (i.e., helper variables) $Q=\varnothing$ and $B^{\prime }=\varnothing$.

1. Step 1.
   1. Let $M_1$ be the deterministic oracle Turing machine defined by the bit string $⟨1{⟩}_2$. For simplicity, we assume that $M_1(|x|)$ runs in time $O(|x|)$.
   2. Choose $n$ such that $2^n>n$.
   3. Run $b=M_1^B(1^n)$.
      1. Whenever $M_1$ queries oracle $B$ at string $q$, reply with $0$/reject. Update $Q=Q\cup \{q\}$.
   4. If $b=1$:
      1. Update $B^{\prime }=B^{\prime }\cup \{0,1{\}}^n$. That is, add all $n$-bit strings to the set $B^{\prime }$. Here, $B^{\prime }$ is representing the set of all strings that are not in $B$.
   5. If $b=0$:
      1. Find $x^{\ast }\in \{0,1{\}}^n$ such that $x^{\ast }\notin Q$.
      2. Update $B=B\cup \{x^{\ast }\}$.
      3. Update $B^{\prime }=B^{\prime }\cup (\{0,1{\}}^n\setminus \{x^{\ast }\})$.
2. For $i=2,3,4,\dots$:
   1. Assume machine $M_i$ runs in time $n^i$ for inputs of length $n$.
   2. Choose $n$ such that $2^n>n^i$.
   3. Run $b=M_i^B(1^n)$.
      1. Whenever $M_i$ queries oracle $B$ at string $q$, update $Q=Q\cup \{q\}$.
      2. If $q\in B^{\prime }$, reply $0$/reject.
      3. If $q\in B$, reply $1$/accept.
   4. If $b=1$
      1. Update $B^{\prime }=B^{\prime }\cup \{0,1{\}}^n$.
   5. If $b=0$
      1. Find $x^{\ast }\in \{0,1{\}}^n$ such that $x^{\ast }\notin Q$.
      2. Update $B=B\cup \{x^{\ast }\}$.
      3. Update $B^{\prime }=B^{\prime }\cup (\{0,1{\}}^n\setminus \{x^{\ast }\})$.

Now, we claim that for this language $B$, we have $U_B\notin {\mathbf{P}}^B$. First, clearly $U_B\in {\mathbf{NP}}^B$ since an NTM can simply guess a correct string in the language $B$. Now, let $M$ be any deterministic oracle Turing machine and suppose by way of contradiction that $M$ decides $U_B$. Notice that for each $M_i$, there are an infinite number of equivalent descriptions for $M_i$. In particular, there exists some $i^{\ast }$ such that $M=M_{i^{\ast }}$. Now, consider $M^B(1^n)$. If $M^B(1^n)=1$, it is saying that there exists $x\in B$ such that $|x|=n$. However, in this case, by construction of $B$ (and, in particular, step 2.4.1), we know that all strings of length $n$ are in the set $B^{\prime }$ and are not in the set $B$. So $M^B(1^n)$ should output $0$ in this case. Similarly, if $M^B(1^n)=0$, then by construction of $B$, we know there exists some length $n$ string $x^{\ast }\in B$, so $M^B(1^n)$ should output $1$ in this case. Both cases lead to a contradiction, so $U_B\notin {\mathbf{P}}^B$. $\square$

Intuitively, in the above diagonalization proof, we are exploiting two key facts: (1) there are an infinite number of equivalent Turing machine descriptions; and (2) deterministic Turing machines cannot search an exponential space in polynomial time. (1) allows us to say that if we are given some decider, then there is some $i^{\ast }$ for which $M_{i^{\ast }}$ is the same machine, which means we have considered it in our construction of $B$. (2) allows us to diagonalize. In particular, $M_i^B(1^n)$ must produce an output by only making a polynomial number of queries (at most $n^i$). Since $n^i<2^n$ for large enough $n$, we know that $M_i^B$ could not have possibly queried the entire set of length $n$ bit strings. So, intuitively, the deterministic machine is making a decision with incomplete information.

We exploit this. If $M_i^B(1^n)=1$, we declare all length $n$ strings to not be in the language. Since $M_i$ could not have queried all length $n$ strings before outputting its decision, the lack of information leads it to make a wrong decision. Similarly, if $M_i^B(1^n)=0$, then again there is no way $M_i$ could have queries all length $n$ bit strings. So we explicitly find one that was not queried and add it to the set $B$. This again causes $M_i$ to output erroneously. Thus, we cannot decide the language $U_B$ in deterministic polynomial time when given an oracle to $B$.