Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Introduction to The PCP Theorem
K. Alex Mills
The University of Texas at Dallas
Advanced Networking and Dependable Systems Lab
Using PCP
July 19th, 2013
Introduction
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
The most important unsolved problem in Computer
?
Science: P = Np
40 years of research has failed to answer the question, but
our attempts have yielded other fruitful results.
One of which is the notion probabilistically checkable
proofs (PCPs).
The PCP Theorem provides an alternative
characterization of Np, provides insight into
non-deterministic polynomial-time computation.
PCPs are used to prove non-approximability results,
including Håstad’s proof that Maximum-Clique cannot
be approximated within O(n1−ε ) for ε > 0.
Outline
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
1 Turing Machines
2 Determinism
3 Time and Space Complexity
4 Probabilistic Turing Machines
5 The PCP Theorem
6 Using PCP
History of Computation
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
In the 1930s, mathematics was concerned with
characterizing the intuitive notion of “computation”.
Kleene and Rosser developed “recursively enumerable”
(R.E.) functions (1934).
Alonzo Church formulated Lambda Calculus (1936),
showed equivalence with R.E. functions.
Alan Turing formulated Turing Machines (1936), and
proved them to have equivalent power to Lambda Calculus.
All three were proved to be equivalent, in that anything
computable by one is computable by another.
Church-Turing Thesis: Everything which is computable
can be computed by a Turing Machine.
We cannot think of any “computable function” that we
cannot compute using the above methods.
Turing Machines
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
We will define 5 different types of TMs in this lecture.
Deterministic Turing Machines (DTMs)
Non-deterministic Turing Machines (NDTMs)
Oracle Turing Machines (OTMs)
Probabilistic Turing Machines (PTMs)
Verifiers
The above Turing Machines have different characteristics, and
different computational power.
They all share some common characteristics.
Turing Machine Characteristics
Turing
Machines
Determinism
Turing machines are described like finite state automata.
Domain of computation is set of all strings (Σ∗ ) over an
alphabet, Σ.
Time and
Space
Complexity
Input to the TM is a finite string, w ∈ Σ∗ .
Probabilistic
Turing
Machines
Output of the TM is a boolean value, either ACCEPT, or
REJECT.
The PCP
Theorem
Using PCP
For any Turing Machine, M, we define the language accepted
by M, denoted L(M), as follows:
L(M) = {x ∈ Σ∗ | M accepts x}
These characteristics are common to all TMs.
Turing Machines - Intuition
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Intuitive description of a Turing Machine:
Set of internal states, Q, with start, accept and reject
states qs , qa , and qr .
An infinite memory, represented by an infinite tape, which
consist of cells and which contain either a symbol in the
tape alphabet Γ or is blank, .
A tape head, which can both read from and write to the
tape.
A finite control (program) ∆ whose elements are called
transition rules. These rules describe the TMs operation.
Turing Machines - Diagram
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Turing Machines - Formalization
A TM, M is a 6-tuple M = (Q, Σ, Γ, ∆, qs , qa , qr ), where:
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Q is a finite set of internal states.
Σ is the finite input alphabet. ∈
/ Σ.
Γ is a finite tape alphabet. Σ ⊆ Γ, ∈
/ Γ.
∆ is the transition function, defined below
qs , qa , qr ∈ Q are start, accept and reject states,
respectively.
Let Γ0 = Γ ∪ {}.
∆ : (Q × Γ0 ) → (Q × Γ0 × {L, R}).
∆ reads the current state and the symbol under the tape head,
and moves to a different state, writes a value to the tape head,
and moves either to the left or to the right.
Turing Machines - Example
n
We describe a DTM which decides A = {02 | n ≥ 0}.
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Configurations of TMs
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
A configuration of a TM describes the state of the TM at
any time.
Strings of the form aqb can be used to describe
configurations, where:
a, b ∈ (Γ ∪ )∗ .
q ∈ Q.
The symbol to the left of q denotes the position of the
current tape head.
ex: “0010101q4 01101” denotes that the TM is in state q4
and is currently reading a 0 from the tape.
Computations of TMs
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
A computation is a sequence of configurations
C0 , C1 , ..., Cm , where:
C0 = qs w , where w ∈ Σ∗ is the input string.
Each Ci follows from Ci−1 by correct application of the
transition function, ∆.
An accepting computation is one in which Cm includes qa .
A rejecting computation is one in which Cm includes qr .
We assume all TMs halt (cease computing) after reaching
qa or qr .
Outline
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
1 Turing Machines
2 Determinism
3 Time and Space Complexity
4 Probabilistic Turing Machines
5 The PCP Theorem
6 Using PCP
Determinism
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
The previous definition of ∆ was deterministic.
∆ : (Q × Γ0 ) → (Q × Γ0 × {L, R})
For any given state and tape symbol, ∆ maps to exactly
one action taken by the TM.
We say that DTM M accepts input string w if w leads M
to halt in state qa .
The language recognized by DTM M is the set L ⊆ Σ∗
such that:
Each string w ∈ L is accepted by M.
Each string w ∈
/ L is rejected by M.
Non-determinism
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
In contrast, for NDTMs we define ∆ as follows:
∆ ⊆ (Q × Γ0 ) × (Q × Γ0 × {L, R})
For any state and tape symbol, ∆ maps to multiple
actions taken by the TM.
For any given input string, there may be multiple steps
which can be taken. In this situation, the NDTM tracks
multiple computation paths simultaneously.
The computation of an NDTM can be described by a
computation tree.
Computation Trees
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
To the right is a computation
tree for the computation of
input string 1001 on the
NDTM with ∆ described by
the table below.
This meets the requirements
for an accepting computation.
The accepting path is
highlighted in green.
0
1
S
{(S, 0, R), (q1 , 0, R)}
(S, q1 , R)
-
q1
(A, 1, R)
-
A
-
Non-deterministic Acceptance
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
An accepting computation path is a path through the
computation tree which ends in an accepting state.
A string w ∈ Σ∗ is accepted by NDTM M if there is at
least one accepting computation path in the computation
tree.
w is rejected by M if there is no accepting computation
path in the tree.
Determinism vs. Non-determinism
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
With regard to what can eventually be computed in a
finite amount of time, both DTMs and NDTMs are
equivalent.
With regard to the amount of space taken to compute a
result, DTMs and NDTMs do not have equivalent power
(Savitch’s Theorem)
With regard to the amount of time taken to compute a
result, the formal equivalence of DTMs and NDTMs is
?
unknown (P = Np).
However, we expect P 6= Np.
Composition of Turing Machines
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Turing machines can be composed in two ways.
The description of a TM M = (Q, Σ, Γ, qs , qa , qr ) can be
embedded inside another TM, N = (Q 0 , Σ, Γ, qs0 , qa0 , qr0 ).
This embedding consists of ensuring Q ⊆ Q 0 .
M and N are defined on the same input and tape
alphabets. We can enforce this w.l.o.g.
N can also take a suitable encoding of M as part of its
input, decode the TM, and then simulate its behavior on
another portion of its input.
TMs which take other TMs as input are known as
universal Turing machines.
Outline
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
1 Turing Machines
2 Determinism
3 Time and Space Complexity
4 Probabilistic Turing Machines
5 The PCP Theorem
6 Using PCP
Time and Space Complexity
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Time Complexity: The number of computing steps
performed by a TM to accept a language.
Space Complexity: The number of tape cells accessed by
a TM during its computation.
A language L is recognized by a TM M in time O(t(n)) if
L = L(M), and for each w ∈ Σ∗ , where |w | = n, M performs
O(t(n)) computation steps.
Using PCP
Similarly, L is recognized by M in space O(s(n)) if L = L(M),
and for each w ∈ Σ∗ , where |w | = n, if M accesses O(s(n))
tape cells.
Complexity Classes
Turing
Machines
We define complexity classes in terms of the sorts of
languages which can be recognized by TMs with certain
restrictions.
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
For example, let TimeTM(f (n)) be the set of decision
problems D with languages LD which can be recognized by
some DTM M in time O(f (n)).
Let NTimeTM(f (n)) be defined similarly, using NDTMs.
P=
∞
[
TimeTM(nk )
k=0
NP =
∞
[
k=0
NTimeTM(nk )
Oracles
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
What would be possible if we could solve some Np-complete
problem?
Let LP ⊆ Σ∗ be the language associated with problem P.
An oracle, for problem P is an abstract device which,
when given x ∈ Σ∗ as input, accepts x iff x ∈ LP . Asking
the oracle about a string can be done in a single
computation step.
We can augment our TMs with oracles, and then reason
about the sorts of problems they could solve given the
oracle.
An oracle Turing machine (OTM) is a DTM or an NDTM
which can query the oracle and receive an answer.
Outline
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
1 Turing Machines
2 Determinism
3 Time and Space Complexity
4 Probabilistic Turing Machines
5 The PCP Theorem
6 Using PCP
Probabilistic Turing Machines - Diagram
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Probabilistic Turing Machines - Formalization
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Probabilistic Turing Machines (PTMs) are TMs with an
additional read-only tape, and an additional state, qr .
When in state qr , the TM performs a transition by reading
the next symbol on the random tape and advancing the
random tape head to the right.
The transition may include writing to the input tape and
changing the state.
Using PCP
A PTM is said to be r (n)-restricted, if it enters state qr at
most r (n) times.
Probabilistic Turing Machines - Acceptance
Turing
Machines
Acceptance must be redefined for PTMs.
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
For example, the class Rp is defined as the set of
languages L for which there exists a polynomial-time PTM
M such that:
If x ∈ L, then M accepts x with probability at least 12 .
If x ∈
/ L, then M rejects x with probability 1.
The PCP
Theorem
Using PCP
We can define probability that x is accepted by an
r (n)-restricted TM, M as the probability over all strings of
length r (n) that M accepts x.
Outline
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
1 Turing Machines
2 Determinism
3 Time and Space Complexity
4 Probabilistic Turing Machines
5 The PCP Theorem
6 Using PCP
Probabilistically Checkable Proofs
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Goal: arrive at a new, useful characterization of NP.
For any problem P, P ∈ Np iff there is some NDTM, M,
such that LP = L(M), and M runs in polynomial time.
X can be decided by an algorithm that guesses a string,
πx , of polynomial length and then deterministically
performs a computation on the instance x and the guess.
πx above is a membership proof, i.e. a proof that x ∈ LP .
Using PCP
We can define NP as the set of all problems with membership
proofs of polynomial length which can be verified in polynomial
time.
Redefining Np
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Given a decision problem, P, let φP be a unary predicate,
which, on every positive instance x,
φP (x) = true ⇐⇒ x is a positive instance.
Previously, we were interested in the worst-case cost of
computing φP .
Consider that we’re given a proof πx that φP (x) is true.
What is the cost of verifying that πx is a correct proof?
For each problem in NP, there is a polynomial time
computable binary predicate vP such that
vP (x, πx ) is true ⇐⇒ πx is a correct proof of φP (x).
Redefining Np
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
NP is the set of decision problems P, such that:
∀x : φP (x) ⇐⇒ (∃πx : |πx | ≤ p(|x|))[vP (x, πx )].
πx must be polynomial in size.
vP must be computable in polynomial time.
Define φP (x), πx , and and v (x, πx ) for SAT.
This redefines NP in terms of the deterministic
verification of proofs. Interesting results are obtained when
we consider the probabilistic verification of proofs.
Verifiers - Intuition
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Suppose we’re given as input, x ∈ Σ∗ and π, where π is a
proof that x ∈ L.
(w.l.o.g assume π ∈ {0, 1}∗ )
In a deterministic check, all of π has to be read. After
reading the proof, we can determine its correctness with
certainty.
Verifiers instead read a random set of bits in the proof
and use them to deterministically decide whether the
proof is correct.
Verifiers - Formal Definition
A verifier is a polynomial-time oracle PTM.
Turing
Machines
Input: (x, π), where x ∈ Σ∗ , and π ∈ {0, 1}∗ .
Determinism
Output: V (x, ρ, π) ∈ {YES, NO}, where ρ is the random
string.
Verifiers use the oracle to access a proof π on a random
access basis.
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
When the oracle is given a position in π it returns the
value of the corresponding bit.
Verifiers compute in two phases.
Phase I: Verifier uses the random tape to determine which
bits will be read.
Phase II: Verifier deterministically reads the bits, performs
its computation, and then accepts or rejects the proof.
Restricted Verifiers
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
A verifier V is (r (n), q(n))-restricted if V can only read
r (n) bits from the random tape, and for any input x with
|x| = n, V accesses q(n) bits of the proof.
Since the number of random bits is r (n), the number of
random (binary) strings is 2r (n) .
Since, for each random string, the verifier uses q(n) bits
from the proof, the total number of bits that could ever
possibly be used is q(n)2r (n) .
So only proofs of size q(n)2r (n) need to be considered.
The PCP Complexity Class
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
A language L belongs to the class Pcp[r (n), q(n)] iff there
exists a (r (n), q(n))-restricted verifier V such that:
For any x ∈ L, there is a proof, π, such that:
P[V (x, ρ, π) = YES] = 1.
For any x ∈
/ L, for all π,
1
P[V (x, ρ, π) = NO] ≥ .
2
P
Characterizing Np
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
For any two classes of functions, R, Q,
[
Pcp[R, Q] =
Pcp[r (n), q(n)].
r ∈R,q∈Q
Our goal: characterize Np in terms of Pcp.
Clearly, Np = Pcp[0, poly (n)].
Ignoring the random-tape means that our PTM acts like a
DTM.
We previously noted that any problem in Np has proofs
that can be verified in polynomial time.
The PCP Theorem
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Theorem
Np = PCP[O(log n), O(1)].
P
We will prove that Pcp[O(log n), O(1)] ⊆ Np.
The opposite direction is obscenely long, and is contained
in Chapter 7 of [1].
Read at your own risk.
Proof: PCP[O(log n), O(1)] ⊆ Np
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Let L ∈ PCP[O(log n), O(1)], by definition there is some
verifier V for L.
We show that there is a polynomial-time NDTM M, such that,
for all x ∈ Σ∗ :
x ∈ L(M) ⇐⇒ ∃π ∈ {0, 1}∗ : ∀ρ ∈ {0, 1}∗ : V (x, ρ, π).
There are a polynomial number of strings of length
O(log n).
For any input x, M can guess a polynomial-length proof π,
and simulate V on each random string ρ of length
O(log n) in polynomial time.
M accepts if and only if V (x, ρ, π) is true for all ρ. Outline
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
1 Turing Machines
2 Determinism
3 Time and Space Complexity
4 Probabilistic Turing Machines
5 The PCP Theorem
6 Using PCP
Using PCP to Prove Non-approximability Results
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Assume the problem is approximable, show that some
Np-complete problem would be solvable in polynomial
time.
Using the PCP theorem, we can show more
non-approximability results.
We will show 3-Sat ∈
/ Ptas unless P = Np
3-Sat ∈
/ Ptas unless P = Np
3-Sat takes as input a pair (U, C ) where:
U is a set of variables,
Turing
Machines
C is a set of disjunctive clauses, of three variables each.
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
If 3-Sat has a PTAS, we will show how to decide an
arbitrary Np-complete language L using information from
an (O(log n), q)-restricted verifier for L.
Such a verifier exists for every L ∈ Np.
Given an instance x ∈ Σ∗ , we will construct an instance
(U, C ) of 3-Sat such that:
If x ∈ L, then (U, C ) is satisfiable.
If x ∈
/ L, then there is a constant ε > 0 such that a
fraction ε of the clauses in C cannot be satisfied.
The gap technique ensures that we could then solve the
problem to within an arbitrary factor of ε.
3-Sat ∈
/ Ptas unless P = Np (cont.)
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Let r (n) = O(log n),
Without loss of generality, let q > 2, and assume the
verifier always asks for exactly q bits of the proof (it may
ignore some of the bits).
For each bit in the proof, we introduce a boolean variable
in U.
Since for all π, |π| ≤ q2r (n) , and r (n) ≤ c log n,
|π| = |U| ≤ q · nc = O(nc ).
3-Sat ∈
/ Ptas unless P = Np (cont.)
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Given a fixed ρ, the choice of which q bits to read from
the proof πx is deterministic.
Let vρ[1] , ..., vρ[q] be the q variables corresponding to the
q bits which will be read given random string ρ. vρ[i] ∈ U.
Let a1 , ..., aq be the q values read from πx given string ρ.
ai ∈ {0, 1}.
For some values of this q-tuple of bits, the verifier accepts,
for other values, it rejects.
Let Aρ = {(a1 , ..., aq ) | verifier rejects (a1 , ..., aq )}.
By applying the definition of PCP:
x ∈ L ⇐⇒ ∃πx : Aρ = ∅
x∈
/ L ⇐⇒ ∀πx :
|Aρ |
1
≥
2q
2
P
3-Sat ∈
/ Ptas unless P = Np (cont.)
Given Aρ , we can construct our set of clauses, C .
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
For each (a1 , ..., aq ) ∈ Aρ , we construct a clause c of q
literals where c is true iff the variables vρ[1] , ..., vρ[q] do not
take values a1 , ..., aq .
All clauses are satisfied iff Aρ = ∅.
Example:
3-Sat ∈
/ Ptas unless P = Np (cont.)
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Every clause in C has exactly ρ variables.
For each ρ we get at most 2q clauses, for a total of
2q 2r (n) ≤ 2q nc = O(nc ) clauses.
In polynomial time, we can transform C into C 0 , which
has three variables per clause, by introducing extra
variables. (pg. 188)
Using PCP
(U, C 0 ) is an instance of 3-Sat which we obtained by a
polynomial-time process from an arbitrary Np-complete
problem L.
3-Sat ∈
/ Ptas unless P = Np (cont.)
All clauses are satisfied iff Aρ = ∅, therefore
Turing
Machines
x ∈ L ⇐⇒ (U, C 0 ) ∈ 3-Sat
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
If x ∈
/ L, then regardless of the proof, at least 12 of the
random strings ρ will be rejected by the verifier.
For each such ρ the corresponding q-tuple will be in Aρ ,
and therefore the clause corresponding to this q-tuple will
not be satisfied.
There are
2r (n)
2
2r (n)
2
|C 0 |
=
such clauses.
(q
2r (n)
2
− 2)2q+r (n)
≤
2r (n)−1
= 2−(q+1)
2q+r (n)
Final Thoughts
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
Section 6.4.2 uses the standard reduction from 3-Sat to
Maximum Clique and the self-improvability property to
show that:
Maximum Clique ∈
/ Apx unless P = Np.
Many other non-approximability theorems have resulted
from the application of PCPs. For example [3].
References
Turing
Machines
Determinism
Time and
Space
Complexity
Probabilistic
Turing
Machines
The PCP
Theorem
Using PCP
[1] G. Ausiello et al., ”NP, PCP and Non-approximability
Results”, in Complexity and Approximation, 2nd ed. Berlin,
Germany: Springer-Verlag, 2003, ch. 6, pp. 175-200.
[2] M. Sipser, ”The Church-Turing Thesis”, in Introduction to
the Theory of Computation, 2nd ed. Boston, MA:
Thompson Learning, 2006, ch. 3, pp. 143-144.
[3] J Håstad, ”Some Optimal Inapproximability results”, J.
ACM, 2011, vol. 48, pp. 798-859.