Computational Complexity: Complexity Classes

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Computational Complexity
Graduate Course
Antonis Antonopoulos
Computation and Reasoning Laboratory
National Technical University of Athens
This work is licensed under a Creative Commons Attribution-
NonCommercial- NoDerivatives 4.0 International License.
£
¢

¡3f311e480301e69f7d7081fe3b91ec87f3480230

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Bibliography
Textbooks
1 C. Papadimitriou, Computational Complexity, Addison Wesley,
1994
2 S. Arora, B. Barak, Computational Complexity: A Modern
Approach, Cambridge University Press, 2009
3 O. Goldreich, Computational Complexity: A Conceptual
Perspective, Cambridge University Press, 2008
Lecture Notes
1 L. Trevisan, Lecture Notes in Computational Complexity,
2002, UC Berkeley
2 J. Katz, Notes on Complexity Theory, 2011, University of
Maryland

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Contents
Introduction
Turing Machines
Undecidability
Complexity Classes
Oracles & The Polynomial Hierarchy
The Structure of NP
Randomized Computation
Non-Uniform Complexity
Interactive Proofs
Inapproximability
Derandomization of Complexity Classes
Counting Complexity
Epilogue

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Introduction
Parameters used to deﬁne complexity classes:
Model of Computation (Turing Machine, RAM, Circuits)
Mode of Computation (Deterministic, Nondeterministic,
Probabilistic)
Complexity Measures (Time, Space, Circuit Size-Depth)
Other Parameters (Randomization, Interaction)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Introduction
Our ﬁrst complexity classes
Deﬁnition
Let L ⊆ Σ∗, and T, S : N → N:
We say that L ∈ DTIME[T(n)] if there exists a TM M deciding L,
which operates within the time bound O (T(n)), where n = |x|.
We say that L ∈ DSPACE[S(n)] if there exists a TM M deciding
L, which operates within space bound O (S(n)), that is, for any
input x, requires space at most S(|x|).
We say that L ∈ NTIME[T(n)] if there exists a nondeterministic
TM M deciding L, which operates within the time bound
O (T(n)).
We say that L ∈ NSPACE[S(n)] if there exists a nondeterministic
TM M deciding L, which operates within space bound O (S(n)).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Introduction
The above are Complexity Classes, in the sense that they are sets
of languages.
All these classes are parameterized by a function T or S, so they
are families of classes (for each function we obtain a complexity
class).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Introduction
The above are Complexity Classes, in the sense that they are sets
of languages.
All these classes are parameterized by a function T or S, so they
are families of classes (for each function we obtain a complexity
class).
Deﬁnition (Complementary complexity class)
For any complexity class C, coC denotes the class: {L | L ∈ C}, where
L = Σ∗ L = {x ∈ Σ∗ | x /∈ L}.
We want to deﬁne “reasonable” complexity classes, in the sense
that we want to “compute more problems”, given more
computational resources.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Constructible Functions
Can we use all computable functions to deﬁne Complexity
Classes?

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Can we use all computable functions to deﬁne Complexity
Classes?
Theorem (Gap Theorem)
For any computable functions r and a, there exists a computable function
f such that f(n) ≥ a(n), and
DTIME[f(n)] = DTIME[r(f(n))]
That means, for r(n) = 22f(n)
, the incementation from f(n) to
22f(n)
does not allow the computation of any new function!
So, we must use some restricted families of functions:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Deﬁnition (Time-Constructible Function)
A nondecreasing function T : N → N is time constructible if
T(n) ≥ n and there is a TM M that computes the function
x → ⌞T(|x|)⌟ in time T(n).
Deﬁnition (Space-Constructible Function)
A nondecreasing function S : N → N is space-constructible if
S(n) > log n and there is a TM M that computes S(|x|) using S(|x|)
space, given x as input.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Deﬁnition (Time-Constructible Function)
A nondecreasing function T : N → N is time constructible if
T(n) ≥ n and there is a TM M that computes the function
x → ⌞T(|x|)⌟ in time T(n).
Deﬁnition (Space-Constructible Function)
A nondecreasing function S : N → N is space-constructible if
S(n) > log n and there is a TM M that computes S(|x|) using S(|x|)
space, given x as input.
The restriction T(n) ≥ n is to allow the machine to read its input.
The restriction S(n) > log n is to allow the machine to “remember”
the index of the cell of the input tape that it is currently reading.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
Also, if f1(n), f2(n) are time/space-constructible functions, so are
f1 + f2, f1 · f2 and ff2
1 .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
f1 + f2, f1 · f2 and ff2
1 .
If we use only constructible functions, we can prove Hierarchy
Theorems, stating that with more resources we can compute more
languages:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
f1 + f2, f1 · f2 and ff2
1 .
If we use only constructible functions, we can prove Hierarchy
Theorems, stating that with more resources we can compute more
languages:
Theorem (Hierarchy Theorems)
Let t1, t2 be time-constructible functions, and s1, s2 be
space-constructible functions. Then:
1 If t1(n) log t1(n) = o(t2(n)), then DTIME(t1) ⊊ DTIME(t2).
2 If t1(n + 1) = o(t2(n)), then NTIME(t1) ⊊ NTIME(t2).
3 If s1(n) = o(s2(n)), then DSPACE(s1) ⊊ DSPACE(s2).
4 If s1(n) = o(s2(n)), then NSPACE(s1) ⊊ NSPACE(s2).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
Simpliﬁed Case of Deterministic Time Hierarchy Theorem
Theorem
DTIME[n] ⊊ DTIME[n1.5]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
Theorem
DTIME[n] ⊊ DTIME[n1.5]
Proof (Diagonalization): See Th.3.1 (p.69) in [2]
Let D be the following machine:
On input x, run for |x|1.4 steps U(Mx, x);
If U(Mx, x) = b, then return 1 − b;
Else return 0;
Clearly, L = L(D) ∈ DTIME[n1.5]
We claim that L /∈ DTIME[n]:
Let L ∈ DTIME[n] ⇒ ∃ M : M(x) = D(x) ∀x ∈ Σ∗, and M
works for O (|x|) steps.
The time to simulate M using U is c|x| log |x|, for some c.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
Proof (cont’d):
∃n0 : n1.4 > cn log n ∀n ≥ n0
There exists a xM, s.t. xM = ⌞M⌟ and |xM| > n0 (why?) Then,
D(xM) = 1 − M(xM) (while we have also that D(x) = M(x), ∀x)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
Proof (cont’d):
∃n0 : n1.4 > cn log n ∀n ≥ n0
Contradiction!! □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complexity Classes
Proof (cont’d):
∃n0 : n1.4 > cn log n ∀n ≥ n0
Contradiction!! □
So, we have the hierachy:
DTIME[n] ⊊ DTIME[n2
] ⊊ DTIME[n3
] ⊊ · · ·
We will later see that the class containing the problems we can
eﬃciently solve (recall the Edmonds-Cobham Thesis) is the class
P =
∪
c∈N DTIME[nc].

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Relations among Complexity Classes
Hierarchy Theorems tell us how classes of the same kind relate to
each other, when we vary the complexity bound.
The most interesting results concern relationships between classes
of diﬀerent kinds:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Theorem
Suppose that T(n), S(n) are time-constructible and space-constructible
functions, respectively.Then:
1 DTIME[T(n)] ⊆ NTIME[T(n)]
2 DSPACE[S(n)] ⊆ NSPACE[S(n)]
3 NTIME[T(n)] ⊆ DSPACE[T(n)]
4 NSPACE[S(n)] ⊆ DTIME[2O(S(n))]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Theorem
Suppose that T(n), S(n) are time-constructible and space-constructible
functions, respectively.Then:
1 DTIME[T(n)] ⊆ NTIME[T(n)]
2 DSPACE[S(n)] ⊆ NSPACE[S(n)]
3 NTIME[T(n)] ⊆ DSPACE[T(n)]
4 NSPACE[S(n)] ⊆ DTIME[2O(S(n))]
Corollary
NTIME[T(n)] ⊆
∪
c>1
DTIME[cT(n)
]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof: See Th.7.4 (p.147) in [1]
1 Trivial
2 Trivial
3 We can simulate the machine for each nondeterministic choice,
using at most T(n) steps in each simulation.
There are exponentially many simulations, but we can simulate
them one-by-one, reusing the same space.
4 Recall the notion of a configuration of a TM: For a k-tape
machine, is a 2k − 2 tuple: (q, i, w2, u2, . . . , wk−1, uk−1)
How many configurations are there?
|Q| choices for the state
n + 1 choices for i, and
Fewer than |Σ|(2k−2)S(n)
for the remaining strings
So, the total number of configurations on input size n is at most
nc
S(n)
1 = 2O(S(n)).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof (cont’d):
Definition (Configuration Graph of a TM)
The configuration graph of M on input x, denoted G(M, x), has as
vertices all the possible configurations, and there is an edge between
two vertices C and C′ if and only if C′ can be reached from C in one
step, according to M’s transition function.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof (cont’d):
Definition (Configuration Graph of a TM)
The configuration graph of M on input x, denoted G(M, x), has as
vertices all the possible configurations, and there is an edge between
two vertices C and C′ if and only if C′ can be reached from C in one
step, according to M’s transition function.
So, we have reduced this simulation to REACHABILITY*
problem (also known as S-T CONN), for which we know there is
a poly-time (O
(
n2
)
) algorithm.
So, the simulation takes
(
2O(S(n))
)2
∼ 2O(S(n)) steps. □
*REACHABILITY: Given a graph G and two nodes v1, vn ∈ V, is there a
path from v1 to vn?

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
The essential Complexity Hierarchy
Deﬁnition
L = DSPACE[log n]
NL = NSPACE[log n]
P =
∪
c∈N
DTIME[nc
]
NP =
∪
c∈N
NTIME[nc
]
PSPACE =
∪
c∈N
DSPACE[nc
]
NPSPACE =
∪
c∈N
NSPACE[nc
]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Deﬁnition
EXP =
∪
c∈N
DTIME[2nc
]
NEXP =
∪
c∈N
NTIME[2nc
]
EXPSPACE =
∪
c∈N
DSPACE[2nc
]
NEXPSPACE =
∪
c∈N
NSPACE[2nc
]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Deﬁnition
EXP =
∪
c∈N
DTIME[2nc
]
NEXP =
∪
c∈N
NTIME[2nc
]
EXPSPACE =
∪
c∈N
DSPACE[2nc
]
NEXPSPACE =
∪
c∈N
NSPACE[2nc
]
L ⊆ NL ⊆ P ⊆ NP ⊆ PSPACE ⊆ NPSPACE ⊆ EXP ⊆ NEXP

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Certificates & Quantifiers
Certificate Characterization of NP
Definition
Let R ⊆ Σ∗ × Σ∗ a binary relation on strings.
R is called polynomially decidable if there is a DTM deciding the
language {x; y | (x, y) ∈ R} in polynomial time.
R is called polynomially balanced if (x, y) ∈ R implies
|y| ≤ |x|k, for some k ≥ 1.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Deﬁnition
Let R ⊆ Σ∗ × Σ∗ a binary relation on strings.
R is called polynomially decidable if there is a DTM deciding the
language {x; y | (x, y) ∈ R} in polynomial time.
R is called polynomially balanced if (x, y) ∈ R implies
|y| ≤ |x|k, for some k ≥ 1.
Theorem
Let L ⊆ Σ∗ be a language. L ∈ NP if and only if there is a polynomially
decidable and polynomially balanced relation R, such that:
L = {x | ∃y R(x, y)}
This y is called succinct certiﬁcate, or witness.
So, an NP Search Problem is the problem of computing witnesses.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof: See Pr.9.1 (p.181) in [1]
(⇐) If such an R exists, we can construct the following NTM deciding
L:
“On input x, guess a y, such that |y| ≤ |x|k, and then test (in poly-time)
if (x, y) ∈ R. If so, accept, else reject.” Observe that an accepting
computation exists if and only if x ∈ L.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof: See Pr.9.1 (p.181) in [1]
(⇐) If such an R exists, we can construct the following NTM deciding
L:
“On input x, guess a y, such that |y| ≤ |x|k, and then test (in poly-time)
if (x, y) ∈ R. If so, accept, else reject.” Observe that an accepting
computation exists if and only if x ∈ L.
(⇒) If L ∈ NP, then ∃ an NTM N that decides L in time |x|k, for some
k. Deﬁne the following R:
“(x, y) ∈ R if and only if y is an encoding of an accepting computation
of N(x).”
R is polynomially balanced and decidable (why?), so, given by
assumption that N decides L, we have our conclusion. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Example (Encoding of a computation path)
0 1
0
✓
0 1
1
0
0 1
0
0
✓
1
1
1
010 and 111 encode accepting paths.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Can creativity be automated?
As we saw:
Class P: Efficient Computation
Class NP: Efficient Verification
So, if we can efficiently verify a mathematical proof, can we create
it efficiently?

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Can creativity be automated?
As we saw:
Class P: Efficient Computation
Class NP: Efficient Verification
So, if we can efficiently verify a mathematical proof, can we create
it efficiently?
If P = NP...
For every mathematical statement, and given a page limit, we would
(quickly) generate a proof, if one exists.
Given detailed constraints on an engineering task, we would (quickly)
generate a design which meets the given criteria, if one exists.
Given data on some phenomenon and modeling restrictions, we would
(quickly) generate a theory to explain the data, if one exists.
See “A. Wigderson: Knowledge, Creativity and P versus NP”

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Complementary complexity classes
Deterministic complexity classes are in general closed under
complement (coL = L, coP = P, coPSPACE = PSPACE).
Complementaries of non-deterministic complexity classes are very
interesting:
The class coNP contains all the languages that have succinct
disqualifications (the analogue of succinct certificate for the class
NP). The “no” instance of a problem in coNP has a short proof of
its being a “no” instance.
So:
P ⊆ NP ∩ coNP
Note the similarity and the difference with R = RE ∩ coRE.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Quantiﬁer Characterization of Complexity Classes
Deﬁnition
We denote as C = (Q1/Q2), where Q1, Q2 ∈ {∃, ∀}, the class C of
languages L satisfying:
x ∈ L ⇒ Q1y R(x, y)
x /∈ L ⇒ Q2y ¬R(x, y)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Quantiﬁer Characterization of Complexity Classes
Deﬁnition
We denote as C = (Q1/Q2), where Q1, Q2 ∈ {∃, ∀}, the class C of
languages L satisfying:
x ∈ L ⇒ Q1y R(x, y)
x /∈ L ⇒ Q2y ¬R(x, y)
P = (∀/∀)
NP = (∃/∀)
coNP = (∀/∃)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Savitch’s Theorem
REACHABILITY ∈ NL. See Ex.2.10 (p.48) in [1]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Savitch’s Theorem
Theorem (Savitch’s Theorem)
REACHABILITY ∈ DSPACE[log2
n]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Savitch’s Theorem
Theorem (Savitch’s Theorem)
REACHABILITY ∈ DSPACE[log2
n]
REACH(x, y, i) : “There is a path from x to y, of length ≤ i”.
We can solve REACHABILITY if we can compute
REACH(x, y, n), for any nodes x, y ∈ V, since any path in G can
be at most n long.
If i = 1, we can check whether REACH(x, y, i).
If i > 1, we use recursion:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Proof (cont’d):
def REACH( s , t , k )
i f k==1:
i f ( s== t or ( s , t ) in edges ) : return t r u e
i f k >1:
for u in v e r t i c e s :
i f (REACH( s , u , f l o o r ( k / 2 ) ) and
(REACH( u , t , c e i l ( k / 2 ) ) ) : return t r u e
return f a l s e

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Proof (cont’d):
def REACH( s , t , k )
i f k==1:
i f ( s== t or ( s , t ) in edges ) : return t r u e
i f k >1:
for u in v e r t i c e s :
i f (REACH( s , u , f l o o r ( k / 2 ) ) and
(REACH( u , t , c e i l ( k / 2 ) ) ) : return t r u e
return f a l s e
We generate all nodes u one after the other, reusing space.
The algorithm has recursion depth of ⌈log n⌉.
For each recursion level, we have to store s, t, k and u, that is,
O (log n) space.
Thus, the total space used is O
(
log2
n
)
. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Savitch’s Theorem
Corollary
NSPACE[S(n)] ⊆ DSPACE[S2(n)], for any space-constructible
function S(n) ≥ log n.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Savitch’s Theorem
Corollary
Proof:
Let M be the nondeterministic TM to be simulated.
We run the algorithm of Savitch’s Theorem proof on the
configuration graph of M on input x.
Since the configuration graph has cS(n) nodes, O
(
S2(n)
)
space
suffices. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Savitch’s Theorem
Corollary
Proof:
Let M be the nondeterministic TM to be simulated.
We run the algorithm of Savitch’s Theorem proof on the
configuration graph of M on input x.
Since the configuration graph has cS(n) nodes, O
(
S2(n)
)
space
suffices. □
Corollary
PSPACE = NPSPACE

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
NL-Completeness
In Complexity Theory, we “connect” problems in a complexity
class with partial ordering relations, called reductions, which
formalize the notion of “a problem that is at least as hard as
another”.
A reduction must be computationally weaker than the class in
which we use it.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
NL-Completeness
In Complexity Theory, we “connect” problems in a complexity
class with partial ordering relations, called reductions, which
formalize the notion of “a problem that is at least as hard as
another”.
A reduction must be computationally weaker than the class in
which we use it.
Deﬁnition
A language L1 is logspace reducible to a language L2, denoted
L1 ≤ℓ
m L2, if there is a function f : Σ∗ → Σ∗, computable by a DTM in
O (log n) space, such that for all x ∈ Σ∗:
x ∈ L1 ⇔ f(x) ∈ L2
We say that a language A is NL-complete if it is in NL and for every
B ∈ NL, B ≤ℓ
m A.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
NL-Completeness
Theorem
REACHABILITY is NL-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
NL-Completeness
Theorem
We ’ve argued why REACHABILITY ∈ NL.
Let L ∈ NL, that is, it is decided by a O (log n) NTM N.
Given input x, we can construct the conﬁguration graph of N(x).
We can assume that this graph has a single accepting node.
We can construct this in logspace: Given conﬁgurations C, C′ we
can in space O (|C| + |C′|) = O (log |x|) check the graph’s
adjacency matrix if they are connected by an edge.
It is clear that x ∈ L if and only if the produced instance of
REACHABILITY has a “yes” answer. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Certificate Definition of NL
We want to give a characterization of NL, similar to the one we
gave for NP.
A certificate may be polynomially long, so a logspace machine
may not have the space to store it.
So, we will assume that the certificate is provided to the machine
on a separate tape that is read once.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Certificate Definition of NL
Definition
A language L is in NL if there exists a deterministic TM M with an
additional special read-once input tape, such that for every x ∈ Σ∗:
x ∈ L ⇔ ∃y, |y| ∈ poly(|x|), M(x, y) = 1
where by M(x, y) we denote the output of M where x is placed on its
input tape, and y is placed on its special read-once tape, and M uses at
most O (log |x|) space on its read-write tapes for every input x.
What if remove the read-once restriction and allow the TM’s head to
move back and forth on the certificate, and read each bit multiple times?

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Immerman-Szelepscényi
Theorem (The Immerman-Szelepscényi Theorem)
REACHABILITY ∈ NL

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Immerman-Szelepscényi
Theorem (The Immerman-Szelepscényi Theorem)
REACHABILITY ∈ NL
It suffices to show a O (log n) verification algorithm A such that:
∀ (G, s, t), ∃ a polynomial certificate u such that:
A((G, s, t), u) = “yes” iff t is not reachable from s.
A has read-once access to u.
G’s vertices are identified by numbers in {1, . . . , n} = [n]
Ci: “The set of vertices reachable from s in ≤ i steps.”
Membership in Ci is easily certified:
∀i ∈ [n]: v0, . . . , vk along the path from s to v, k ≤ i.
The certificate is at most polynomial in n.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
The Immerman-Szelepscényi Theorem
Proof (cont’d):
We can check the certificate using read-once access:
1 v0 = s
2 for j > 0, (vj−1, vj) ∈ E(G)
3 vk = v
4 Path ends within at most i steps
We now construct two types of certificates:
1 A certificate that a vertex v /∈ Ci, given |Ci|.
2 A certificate that |Ci| = c, for some c, given |Ci−1|.
Since C0 = {s}, we can provide the 2nd certificate to convince the
verifier for the sizes of C1, . . . , Cn
Cn is the set of vertices reachable from s.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Proof (cont’d):
Since the verifier has been convinced of |Cn|, we can use the 1st
type of certificate to convince the verifier that t /∈ Cn.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Proof (cont’d):
Since the verifier has been convinced of |Cn|, we can use the 1st
type of certificate to convince the verifier that t /∈ Cn.
Certifying that v /∈ Ci, given |Ci|
The certificate is the list of certificates that u ∈ Ci, for every
u ∈ Ci.
The verifier will check:
1 Each certificate is valid
2 Vertex u, given a certificate for u, is larger than the previous.
3 No certificate is provided for v.
4 The total number of certificates is exactly |Ci|.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Proof (cont’d):
Certifying that v /∈ Ci, given |Ci−1|
The certificate is the list of certificates that u ∈ Ci−1, for every u ∈ Ci−1
3 No certificate is provided for v or for a neighbour of v.
4 The total number of certificates is exactly |Ci−1|.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Proof (cont’d):
Certifying that v /∈ Ci, given |Ci−1|
The certificate is the list of certificates that u ∈ Ci−1, for every u ∈ Ci−1
3 No certificate is provided for v or for a neighbour of v.
4 The total number of certificates is exactly |Ci−1|.
Certifying that |Ci| = c, given |Ci−1|
The certificate will consist of n certificates, for vertices 1 to n, in
ascending order.
The verifier will check all certificates, and count the vertices that have
been certified to be in Ci. If |Ci| = c, it accepts. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Corollary
For every space constructible S(n) > log n:
NSPACE[S(n)] = coNSPACE[S(n)]
Proof:
Let L ∈ NSPACE[S(n)]. We will show that ∃ S(n) space-bounded
NTM M deciding L:
M on input x uses the above certiﬁcation procedure on the
conﬁguration graph of M. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Corollary
For every space constructible S(n) > log n:
NSPACE[S(n)] = coNSPACE[S(n)]
Proof:
Let L ∈ NSPACE[S(n)]. We will show that ∃ S(n) space-bounded
NTM M deciding L:
M on input x uses the above certiﬁcation procedure on the
conﬁguration graph of M. □
Corollary
NL = coNL

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
What about Undirected Reachability?
UNDIRECTED REACHABILITY captures the phenomenon of
conﬁguration graphs with both directions.
H. Lewis and C. Papadimitriou deﬁned the class SL (Symmetric
Logspace) as the class of languages decided by a Symmetric
Turing Machine using logarithmic space.
Obviously,
L ⊆ SL ⊆ NL
As in the case of NL, UNDIRECTED REACHABILITY is
SL-complete.
But in 2004, Omer Reingold showed, using expander graphs, a
deterministic logspace algorithm for UNDIRECTED
REACHABILITY, so:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
What about Undirected Reachability?
UNDIRECTED REACHABILITY captures the phenomenon of
conﬁguration graphs with both directions.
H. Lewis and C. Papadimitriou deﬁned the class SL (Symmetric
Logspace) as the class of languages decided by a Symmetric
Turing Machine using logarithmic space.
Obviously,
L ⊆ SL ⊆ NL
As in the case of NL, UNDIRECTED REACHABILITY is
SL-complete.
But in 2004, Omer Reingold showed, using expander graphs, a
deterministic logspace algorithm for UNDIRECTED
REACHABILITY, so:
Theorem (Reingold, 2004)
L = SL

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Space Computation
Our Complexity Hierarchy Landscape
L
NL
= coNL
P
N
P
NPC
coN
P
PSPACE
= NPSPACE
EXP
NEXP

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Reductions & Completeness
Karp Reductions
Deﬁnition
A language L1 is Karp reducible to a language L2, denoted by
L1 ≤p
m L2, if there is a function f : Σ∗ → Σ∗, computable by a
polynomial-time DTM, such that for all x ∈ Σ∗:
x ∈ L1 ⇔ f(x) ∈ L2

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Karp Reductions
Deﬁnition
A language L1 is Karp reducible to a language L2, denoted by
L1 ≤p
m L2, if there is a function f : Σ∗ → Σ∗, computable by a
polynomial-time DTM, such that for all x ∈ Σ∗:
x ∈ L1 ⇔ f(x) ∈ L2
Deﬁnition
Let C be a complexity class.
We say that a language A is C-hard (or ≤p
m-hard for C) if for every
B ∈ C, B ≤p
m A.
We say that a language A is C-complete, if it is C-hard, and also
A ∈ C.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Karp reductions vs logspace redutions
Theorem
A logspace reduction is a polynomial-time reduction.
Let M the logspace reduction TM.
M has 2O(log n) possible conﬁgurations.
The machine is deterministic, so no conﬁguration can be repeated
in the computation.
So, the computation takes O
(
nk
)
time, for some k. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Circuits and CVP
Deﬁnition (Boolean circuits)
For every n ∈ N an n-input, single output Boolean Circuit C is a
directed acyclic graph with n sources and one sink.
All nonsource vertices are called gates and are labeled with one of ∧
(and), ∨ (or) or ¬ (not).
The vertices labeled with ∧ and ∨ have fan-in (i.e. number or incoming
edges) 2.
The vertices labeled with ¬ have fan-in 1.
For every vertex v of C, we assign a value as follows: for some input
x ∈ {0, 1}n
, if v is the i-th input vertex then val(v) = xi, and otherwise
val(v) is deﬁned recursively by applying v’s logical operation on the
values of the vertices connected to v.
The output C(x) is the value of the output vertex.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Circuits and CVP
Deﬁnition (CVP)
Circuit Value Problem (CVP): Given a circuit C and an assignment x to
its variables, determine whether C(x) = 1.
CVP ∈ P.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Circuits and CVP
Definition (CVP)
Circuit Value Problem (CVP): Given a circuit C and an assignment x to
its variables, determine whether C(x) = 1.
CVP ∈ P.
Example
REACHABILITY ≤ℓ
m CVP: Graph G → circuit R(G):
The gates are of the form:
gi,j,k, 1 ≤ i, j ≤ n, 0 ≤ k ≤ n.
hi,j,k, 1 ≤ i, j, k ≤ n
gi,j,k is true iff there is a path from i to j without intermediate
nodes bigger than k.
hi,j,k is true iff there is a path from i to j without intermediate
nodes bigger than k, and k is used.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Circuits and CVP
Example
Input gates: gi,j,0 is true iﬀ (i = j or (i, j) ∈ E(G)).
For k = 1, . . . , n: hi,j,k = (gi,k,k−1 ∧ gk,j,k−1)
For k = 1, . . . , n: gi,j,k = (gi,j,k−1 ∨ hi,j,k)
The output gate g1,n,n is true iﬀ there is a path from 1 to n using
no intermediate paths above n (sic).
We also can compute the reduction in logspace: go over all
possible i, j, k’s and output the appropriate edges and sorts for the
variables (1, . . . , 2n3 + n2).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Composing Reductions
Theorem
If L1 ≤ℓ
m L2 and L2 ≤ℓ
m L3, then L1 ≤ℓ
m L3.
Proof: See Prop.8.2 (p.164) in [1]
Let R, R′ be the aforementioned reductions.
We have to prove that R′(R(x)) is a logspace reduction.
But R(x) may by longer than log |x|...

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Composing Reductions
Theorem
If L1 ≤ℓ
m L2 and L2 ≤ℓ
m L3, then L1 ≤ℓ
m L3.
Proof: See Prop.8.2 (p.164) in [1]
Let R, R′ be the aforementioned reductions.
We have to prove that R′(R(x)) is a logspace reduction.
But R(x) may by longer than log |x|...
We simulate MR′ by remembering the head position i of the input
string of MR′ , i.e. the output string of MR.
If the head moves to the right, we increment i and simulate MR
long enough to take the ith bit of the output.
If the head stays in the same position, we just remember the ith bit.
If the head moves to the left, we decrement i and start MR from
the beginning, until we reach the desired bit. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Closure under reductions
Complete problems are the maximal elements of the reductions
partial ordering.
Complete problems capture the essence and diﬃculty of a
complexity class.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
partial ordering.
complexity class.
Deﬁnition
A class C is closed under reductions if for all A, B ⊆ Σ∗:
If A ≤ B and B ∈ C, then A ∈ C.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
partial ordering.
complexity class.
Deﬁnition
P, NP, coNP, L, NL, PSPACE, EXP are closed under Karp and
logspace reductions.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
partial ordering.
complexity class.
Deﬁnition
If an NP-complete language is in P, then P = NP.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
partial ordering.
complexity class.
Deﬁnition
If L is NP-complete, then ¯L is coNP-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
partial ordering.
complexity class.
Deﬁnition
If L is NP-complete, then ¯L is coNP-complete.
If a coNP-complete problem is in NP, then NP = coNP.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
P-Completeness
Theorem
If two classes C and C′ are both closed under reductions and there is an
L ⊆ Σ∗ complete for both C and C′, then C = C′.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
P-Completeness
Theorem
If two classes C and C′ are both closed under reductions and there is an
L ⊆ Σ∗ complete for both C and C′, then C = C′.
Consider the Computation Table T of a poly-time TM M(x):
§
¦
¤
¥
Tij represents the contents of tape position j at step i.
But how to remember the head position and state?
At the ith step: if the state is q and the head is in position j, then
Tij ∈ Σ × Q.
We say that the table is accepting if T|x|k−1,j ∈ (Σ × {qyes}), for
some j.
Observe that Tij depends only on the contents of the same of
adjacent positions at time i − 1.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
P-Completeness
Theorem
CVP is P-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
P-Completeness
Theorem
CVP is P-complete.
Proof: See Th. 8.1 (p.168) in [1]
We have to show that for any L ∈ P there is a reduction R from L
to CVP.
R(x) must be a variable-free circuit such that x ∈ L ⇔ R(x) = 1.
Tij depends only on Ti−1,j−1, Ti−1,j, Ti−1,j+1.
Let Γ = Σ ∪ (Σ × Q).
Encode s ∈ Γ as (s1, . . . , sm), where m = ⌈log |Γ|⌉.
Then the computation table can be seen as a table of binary entries
Sijℓ, 1 ≤ ℓ ≤ m.
Sijℓ depends only on the 3m entries Si−1,j−1,ℓ′ , Si−1,j,ℓ′ , Si−1,j+1,ℓ′ ,
where 1 ≤ ℓ′ ≤ m.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
P-Completeness
Proof (cont’d):
So, there are m Boolean Functions f1, . . . , fm : {0, 1}3m → {0, 1}
s.t.:
Sijℓ = fℓ(
−→
S i−1,j−1,
−→
S i−1,j,
−→
S i−1,j+1)
Thus, there exists a Boolean Circuit C with 3m inputs and m
outputs computing Tij.
C depends only on M, and has constant size.
R(x) will be (|x|k − 1) × (|x|k − 2) copies of C.
The input gates are fixed.
R(x)’s output gate will be the first bit of C|x|k−1,1.
The circuit C is fixed, so we can generate indexed copies of C,
using O (log |x|) space for indexing. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
CIRCUIT SAT & SAT
Definition (CIRCUIT SAT)
Given Boolen Circuit C, is there a truth assignment x appropriate to C,
such that C(x) = 1?
Definition (SAT)
Given a Boolean Expression ϕ in CNF, is it satisfiable?

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
CIRCUIT SAT & SAT
Definition (CIRCUIT SAT)
Given Boolen Circuit C, is there a truth assignment x appropriate to C,
such that C(x) = 1?
Definition (SAT)
Given a Boolean Expression ϕ in CNF, is it satisfiable?
Example
CIRCUIT SAT ≤ℓ
m SAT:
Given C → Boolean Formula R(C), s.t. C(x) = 1 ⇔ R(C)(x) = T.
Variables of C → variables of R(C).
Gate g of C → variable g of R(C).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
CIRCUIT SAT & SAT
Example
Gate g of C → clauses in R(C):
g variable gate: add (¬g ∨ x) ∧ (g ∨ ¬x) ≡ g ⇔ x
g TRUE gate: add (g)
g FALSE gate: add (¬g)
g NOT gate & pred(g) = h: add (¬g ∨ ¬h) ∧ (g ∨ h) ≡ g ⇔ ¬h
g OR gate & pred(g) = {h, h′
}: add
(¬h ∨ g) ∧ (¬h′
∨ g) ∧ (h ∨ h′
∨ ¬g) ≡ g ⇔ (h ∨ h′
)
g AND gate & pred(g) = {h, h′
}: add
(¬g ∨ h) ∧ (¬g ∨ h′
) ∧ (¬h ∨ ¬h′
∨ g) ≡ g ⇔ (h ∧ h′
)
g output gate: add (g)
R(C) is satisﬁable if and only if C is.
The construction can be done within log |x| space. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Bounded Halting Problem
We can deﬁne the time-bounded analogue of HP:
Deﬁnition (Bounded Halting Problem (BHP))
Given the code ⌞M⌟ of an NTM M, and input x and a string 0t, decide
if M accepts x in t steps.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Theorem
BHP is NP-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Theorem
BHP is NP-complete.
Proof:
BHP ∈ NP.
Let A ∈ NP. Then, ∃ NTM M deciding A in time p(|x|), for some
p ∈ poly(|x|).
The reduction is the function R(x) = ⟨⌞M⌟, x, 0p(|x|)⟩. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Cook’s Theorem
Theorem (Cook’s Theorem)
SAT is NP-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Cook’s Theorem
Theorem (Cook’s Theorem)
SAT is NP-complete.
SAT ∈ NP.
Let L ∈ NP. We will show that L ≤ℓ
m CIRCUIT SAT ≤ℓ
m SAT.
Since L ∈ NP, there exists an NPTM M deciding L in nk steps.
Let (c1, . . . , cnk ) ∈ {0, 1}nk
a certiﬁcate for M (recall the binary
encoding of the computation tree).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Cook’s Theorem
Proof (cont’d):
If we fix a certificate, then the computation is deterministic (the
language’s Verifier V(x, y) is a DPTM).
So, we can define the computation table T(M, x, −→c ).
As before, all non-top row and non-extreme column cells Tij will
depend only on Ti−1,j−1, Ti−1,j, Ti−1,j+1 and the nondeterministic
choice ci−1.
We now fixed a circuit C with 3m + 1 input gates.
Thus, we can construct in log |x| space a circuit R(x) with variable
gates c1, . . . cnk corresponding to the nondeterministic choices of
the machine.
R(x) is satisfiable if and only if x ∈ L. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
NP-completeness: Web of Reductions
Many NP-complete problems stem from Cook’s Theorem via
reductions:
3SAT, MAX2SAT, NAESAT
IS, CLIQUE, VERTEX COVER, MAX CUT
TSP(D), 3COL
SET COVER, PARTITION, KNAPSACK, BIN PACKING
INTEGER PROGRAMMING (IP): Given m inequalities oven n
variables ui ∈ {0, 1}, is there an assignment satisfying all the
inequalities?
Always remember that these are decision versions of the
corresponding optimization problems.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Many NP-complete problems stem from Cook’s Theorem via
reductions:
3SAT, MAX2SAT, NAESAT
IS, CLIQUE, VERTEX COVER, MAX CUT
TSP(D), 3COL
SET COVER, PARTITION, KNAPSACK, BIN PACKING
INTEGER PROGRAMMING (IP): Given m inequalities oven n
variables ui ∈ {0, 1}, is there an assignment satisfying all the
inequalities?
Always remember that these are decision versions of the
corresponding optimization problems.
But 2SAT, 2COL ∈ P.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Example
SAT ≤ℓ
m IP:
Every clause can be expressed as an inequality, eg:
(x1 ∨ ¯x2 ∨ ¯x3) −→ x1 + (1 − x2) + (1 − x3) ≥ 1

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Example
SAT ≤ℓ
m IP:
Every clause can be expressed as an inequality, eg:
(x1 ∨ ¯x2 ∨ ¯x3) −→ x1 + (1 − x2) + (1 − x3) ≥ 1
This method is generalized by the notion of Constraint Satisfaction
Problems.
A Constraint Satisfaction Problem (CSP) generalizes SAT by
allowing clauses of arbitrary form (instead of ORs of literals).

¨
©
3SAT is the subcase of qCSP, where arity q = 3 and the constraints
are ORs of the involved literals.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Reductions Completeness
Quantified Boolean Formulas
Definition (Quantified Boolean Formula)
A Quantified Boolean Formula F is a formula of the form:
F = ∃x1∀x2∃x3 · · · Qnxn ϕ(x1, . . . , xn)
where ϕ is plain (quantifier-free) boolean formula.
Let TQBF the language of all true QBFs.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Definition (Quantified Boolean Formula)
A Quantified Boolean Formula F is a formula of the form:
F = ∃x1∀x2∃x3 · · · Qnxn ϕ(x1, . . . , xn)
where ϕ is plain (quantifier-free) boolean formula.
Let TQBF the language of all true QBFs.
Example
F = ∃x1∀x2∃x3 [(x1 ∨ ¬x2) ∧ (¬x2 ∨ x3) ∧ (¬x1 ∨ x2 ∨ ¬x3)]
The above is a True QBF ((1, 0, 0) and (1, 1, 1) satisfy it).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Theorem
TQBF is PSPACE-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Theorem
TQBF is PSPACE-complete.
Proof: See Th. 19.1 (p.456) in [1] – Th.4.13 (p.84) in [2]
TQBF ∈ PSPACE:
Let ϕ be a QBF, with n variables and length m.
Recursive algorithm A(ϕ):
If n = 0, then there are only constants, hence O (m) time/space.
If n 0:
A(ϕ) = A (ϕ|x1=0) ∨ A (ϕ|x1=1), if Q1 = ∃, and
A(ϕ) = A (ϕ|x1=0) ∧ A (ϕ|x1=1), if Q1 = ∀.
Both recursive computations can be run on the same space.
So spacen,m = spacen−1,m + O (m) ⇒ spacen,m = O (n · m).

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof (cont’d):
Now, let M a TM with space bound p(n).
We can create the configuration graph of M(x), having size
2O(p(n)).
M accepts x iff there is a path of length at most 2O(p(n)) from the
initial to the accepting configuration.
Using Savitch’s Theorem idea, for two configurations C and C′ we
have:
REACH(C, C′, 2i) ⇔
⇔ ∃C′′
[
REACH(C, C′′, 2i−1) ∧ REACH(C′′, C′, 2i−1)
]

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof (cont’d):
Now, let M a TM with space bound p(n).
We can create the configuration graph of M(x), having size
2O(p(n)).
M accepts x iff there is a path of length at most 2O(p(n)) from the
initial to the accepting configuration.
Using Savitch’s Theorem idea, for two configurations C and C′ we
have:
REACH(C, C′, 2i) ⇔
⇔ ∃C′′
[
REACH(C, C′′, 2i−1) ∧ REACH(C′′, C′, 2i−1)
]
But, this is a bad idea: Doubles the size each time.
Instead, we use additional variables:
∃C′′∀D1∀D2 [(D1 = C ∧ D2 = C′′) ∨ (D1 = C′′ ∧ D2 = C′)] ⇒
REACH(D1, D2, 2i−1)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Proof (cont’d): See Th. 19.1 (p.456) in [1] – Th.4.13 (p.84) in [2]
The base case of the recursion is C1 → C2, and can be encoded as
a quantiﬁer-free formula.
The size of the formula in the ith step is
spacei ≤ spacei−1 + O (p(n)) ⇒ O
(
p2(n)
)
. □

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Descriptive Complexity
*Logical Characterizations
Descriptive complexity is a branch of computational complexity
theory and of ﬁnite model theory that characterizes complexity
classes by the type of logic needed to express the languages in
them.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
*Logical Characterizations
Descriptive complexity is a branch of computational complexity
theory and of ﬁnite model theory that characterizes complexity
classes by the type of logic needed to express the languages in
them.
Theorem (Fagin’s Theorem)
The set of all properties expressible in Existential Second-Order Logic is
precisely NP.
Theorem
The class of all properties expressible in Horn Existential Second-Order
Logic with Successor is precisely P.
HORNSAT is P-complete.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
We define complexity classes using a computation model/mode
and complexity measures.
Time/Space constructible functions are used as complexity
measures.
Classes of the same kind form proper hierarchies.
NP is the class of easily verifiable problems: given a certificate,
one can efficiently verify that it is correct.
Savitch’s Theorem implies that PSPACE = NPSPACE.
Summary 1/2

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Complexity Classes
Reductions relate problems with respect to hardness.
Complete problems reflect the difficulty of the class.
Immerman-Szelepscényi’s Theorem implies that NL = coNL.
Circuit Value Problem (CVP) is P-complete under logspace
reductions.
CIRCUIT SAT and SAT are NP-complete.
True Quantified Boolean Formula (TQBF) is
PSPACE-complete.
Summary 2/2

Computational Complexity: Complexity Classes

More Related Content

What's hot

Similar to Computational Complexity: Complexity Classes

Recently uploaded

Computational Complexity: Complexity Classes