CS 517: Complexity
PH in terms of Oracle Classes
Winter 2017
CS 517: PH in terms of Oracle Classes
Writeup by Mike Rosulek
Theorem 1
Proof
For k ≥ 1, Σ k = NPΣ k −1
(⊆) Suppose we are given an arbitrary language L ∈ Σ k . That is, L can be written as
L = {x | ∃w 1∀w 2 · · · Qw k : M (x,w 1 , . . . ,w k ) = 1}
for some polytime M. We want to show that L can be written as an NPΣ k −1 language.
Define the related language:
L 0 = {(x,w 1 ) | ∃w 2∀w 3 · · · Qw k : M (x,w 1 , . . . ,w k ) = 0}
This language is clearly in Σ k −1 . Now observe:
x ∈ L ⇐⇒ ∃w 1∀w 2 · · · Qw k : M (x,w 1 , . . . ,w k ) = 1
⇐⇒ ∃w 1 ¬[∃w 2∀w 3 · · · Qw k : M (x,w 1 , . . . ,w k ) = 0]
⇐⇒ ∃w 1 : (x,w 1 ) < L 0
Hence we can rewrite L in an equivalent way, L = {x | ∃w 1 : (x,w 1 ) < L 0 }. We have
written L in terms of an existential quantifier followed by a condition that can be verified
0
in polynomial time with an L 0-oracle. Hence, L ∈ NP L ⊆ NPΣ k −1 .
(⊇) Suppose we are given an arbitrary language L ∈ NPΣ k −1 . That is, L can be written as
L = {x | ∃w ∗ : M A (x,w ∗ ) = 1}, where
A = {q | ∃w 1∀w 2 · · · Qw k −1 : T (q,w 1 , . . . ,w k −1 ) = 1}
for some poly-time M and T . We want to show that L can be written as a Σ k language.
We first introduce some helpful terminology. Let C be some oracle TM and let O
be some oracle. We can think of the computation of C O (x ) as an interaction, where C
repeatedly sends a query q to O, and O sends a response r ∈ {0, 1} back to C. Let t =
(q 1 ,r 1 , . . . ,q n ,r n ) denote the transcript of such an interaction. We say that t is:
I consistent with caller C (x ) accepting if, when running on input x, the oracle TM
C will indeed make the sequence of queries q 1 , . . . ,q n and finally accept, as long as
it receives responses r 1 , . . . ,r n from those queries.
I consistent with oracle O if for all i: r i = 1 ⇒ q i ∈ O and r i = 0 ⇒ q i < O.
Using this terminology, we can restate what it means for an oracle machine to accept a
string:
C O (x ) = 1 ⇐⇒ ∃t : t is consistent with caller C (x ) accepting
and t is consistent with oracle O
1
CS 517: Complexity
PH in terms of Oracle Classes
Winter 2017
We can now rewrite the language L in terms of this definition, and expand:
x ∈ L ⇐⇒ ∃w ∗ : M A (x,w ∗ ) = 1
⇐⇒ ∃w ∗ ,t : t is consistent with caller M (x,w ∗ ) accepting
and t is consistent with oracle A
⇐⇒ ∃w ,t = (q 1 ,r 1 , . . . ,q n ,r n ) :
∗
t is consistent with caller M (x,w ∗ ) accepting
and [r 1 = 1 ⇒ q 1 ∈ A] and [r 1 = 0 ⇒ q 1 < A]
..
.
and [r n = 1 ⇒ q n ∈ A] and [r n = 0 ⇒ q n < A]
⇐⇒ ∃w ,t = (q 1 ,r 1 , . . . ,q n ,r n ) :
∗
t is consistent with caller M (x,w ∗ ) accepting
and r 1 = 1 ⇒ [∃w 1,1∀w 1,2 · · · Qw 1,k −1 : T (q 1 ,w 1,1 , . . . ,w 1,k −1 ) = 1]
0
0
0
0
0
and r 1 = 0 ⇒ [∀w 1,1
∃w 1,2
· · · Qw 1,k
−1 : T (q 1 ,w 1,1 , . . . ,w 1,k −1 ) = 0]
..
.
and r n = 1 ⇒ [∃w n,1∀w n,2 · · · Qw n,k −1 : T (q n ,w n,1 , . . . ,w n,k −1 ) = 1]
0
0
0
0
0
and r n = 0 ⇒ [∀w n,1
∃w n,2
· · · Qw n,k
−1 : T (q n ,w n,1 , . . . ,w n,k −1 ) = 0]
⇐⇒ ∃w ∗ ,t = (q 1 ,r 1 , . . . ,q n ,r n ),w 1,1 , . . . ,w n,1 :
0
0
∀w 1,2 , . . . ,w n,2 ,w 1,1
, . . . ,w n,1
:
0
0
∃w 1,3 , . . . ,w n,3 ,w 1,2
, . . . ,w n,2
:
..
.
0
0
Qw 1,k
−1 , . . . ,w n,k −1 :
t is consistent with caller M (x,w ∗ ) accepting
and [r 1 = 1 ⇒ T (q 1 ,w 1,1 , . . . ,w 1,k −1 ) = 1]
0
0
and [r 1 = 0 ⇒ T (q 1 ,w 1,1
, . . . ,w 1,k
−1 ) = 0]
..
.
and [r n = 1 ⇒ T (q n ,w n,1 , . . . ,w n,k −1 ) = 1]
0
0
and [r n = 0 ⇒ T (q n ,w n,1
, . . . ,w n,k
−1 ) = 0]
This final expression consists of k alternating quantifiers (beginning with ∃), followed by
a condition that can be checked in polynomial time. This shows that L ∈ Σ k , as desired.
2