The Proof (continued)

knapsack Has an Approximation Threshold of Zero

Theorem 78 For any ϵ, there is a polynomial-time ϵ-approximation algorithm for knapsack.

• We have n weights w¹, w₂, . . . , w_n ∈ Z⁺, a weight limit W , and n values v₁, v₂, . . . , v_n ∈ Z⁺.^b

• We must find an S ⊆ {1, 2, . . . , n} such that

∑

i∈S w_i ≤ W and ∑

i∈S v_i is the largest possible.

aIbarra and Kim (1975).

bIf the values are fractional, the result is slightly messier, but the main conclusion remains correct. Contributed by Mr. Jr-Ben Tian

The Proof (continued)

• Let

V = max{v¹, v₂, . . . , v_n}.

• Clearly, ∑

i∈S v_i ≤ nV .

• Let 0 ≤ i ≤ n and 0 ≤ v ≤ nV .

• W (i, v) is the minimum weight attainable by selecting only from the first i items and with a total value of v.

– It is an (n + 1) × (nV + 1) table.

• Set W (0, v) = ∞ for v ∈ { 1, 2, . . . , nV } and W (i, 0) = 0 for i = 0, 1, . . . , n.^a

aContributed by Mr. Ren-Shuo Liu (D98922016) and Mr. Yen-Wei Wu (D98922013) on December 28, 2009.

The Proof (continued)

• Then, for 0 ≤ i < n,

W (i + 1, v) = min{W (i, v), W (i, v − vⁱ⁺¹) + w_i+1}.

• Finally, pick the largest v such that W (n, v) ≤ W .^a

• The running time is O(n²V ), not polynomial time.

• Key idea: Limit the number of precision bits.

aLawler (1979).

v

<W

nV

The Proof (continued)

• Define

v_i^′ = 2^b

⌊v_i 2^b

⌋ .

– This is equivalent to zeroing each v_i’s last b bits.

• Call the original instance

x = (w₁, . . . , w_n, W, v₁, . . . , v_n).

• Call the approximate instance

x^′ = (w₁, . . . , w_n, W, v₁^′ , . . . , v_n^′ ).

The Proof (continued)

• Solving x^′ takes time O(n²V /2^b).

– The algorithm only performs subtractions on the v_i-related values.

– So the b last bits can be removed from the calculations.

– That is, use v_i^′′ = ⌊_v

i

2^b

⌋ and V = max(v₁^′′, v₂^′′, . . . , v_n^′′) in the calculations.

– Then multiply the returned value by 2^b. – It is an (n + 1) × (nV + 1)/2^b table.

The Proof (continued)

• The solution S^′ is close to the optimum solution S:

∑

i∈S^′

v_i ≥ ∑

i∈S^′

v_i^′ ≥ ∑

i∈S

v_i^′ ≥ ∑

i∈S

(v_i − 2^b) ≥ ∑

i∈S

v_i − n2^b.

• Hence ∑

i∈S^′

v_i ≥ ∑

i∈S

v_i − n2^b.

• Without loss of generality, assume wⁱ ≤ W for all i.

– Otherwise, item i is redundant.

• V is a lower bound on opt.

The Proof (concluded)

• The relative error from the optimum is ≤ n2^b/V :

∑

i∈S v_i − ∑

i∈S^′ v_i

∑

i∈S v_i ≤

∑

i∈S v_i − ∑

i∈S^′ v_i

V ≤ n2^b

V .

• Suppose we pick b = ⌊log2 ϵV n ⌋.

• The algorithm becomes ϵ-approximate.^a

• The running time is then O(n²V /2^b) = O(n³/ϵ), a polynomial in n and 1/ϵ.^b

aSee Eq. (16) on p. 683.

bIt hence depends on the value of 1/ϵ. Thanks to a lively class dis- cussion on December 20, 2006. If we fix ϵ and let the problem size increase, then the complexity is cubic. Contributed by Mr. Ren-Shan Luoh (D97922014) on December 23, 2008.

Comments

• independent set and node cover are reducible to each other (Corollary 40, p. 348).

• node cover has an approximation threshold at most 0.5 (p. 691).

• But independent set is unapproximable (see the textbook).

• independent set limited to graphs with degree ≤ k is called k-degree independent set.

• k-degree independent set is approximable (see the

On P vs. NP

If 50 million people believe a foolish thing, it’s still a foolish thing.

— George Bernard Shaw (1856–1950)

Density

The density of language L ⊆ Σ^∗ is defined as dens_L(n) = |{x ∈ L : | x | ≤ n}|.

• If L = {0, 1}^∗, then dens_L(n) = 2ⁿ⁺¹ − 1.

• So the density function grows at most exponentially.

• For a unary language L ⊆ {0}^∗,

dens_L(n) ≤ n + 1.

– Because L ⊆ {ϵ, 0, 00, . . . ,

z }| {n

00· · · 0, . . .}.

aBerman and Hartmanis (1977).

Sparsity

• Sparse languages are languages with polynomially bounded density functions.

• Dense languages are languages with superpolynomial density functions.

Self-Reducibility for sat

• An algorithm exhibits self-reducibility if it finds a certificate by exploiting algorithms for the decision version of the same problem.

• Let ϕ be a boolean expression in n variables x₁, x₂, . . . , x_n.

• t ∈ {0, 1}^j is a partial truth assignment for x₁, x₂, . . . , x_j.

• ϕ[ t ] denotes the expression after substituting the truth values of t for x₁, x₂, . . . , x_{| t |} in ϕ.

An Algorithm for sat with Self-Reduction

We call the algorithm below with empty t.

1: if | t | = n then

2: return ϕ[ t ];

3: else

4: return ϕ[ t0 ] ∨ ϕ[ t1 ];

5: end if

The above algorithm runs in exponential time, by visiting all the partial assignments (or nodes on a depth-n binary tree).^a

aThe same idea was used in the proof of Proposition 71 on p. 583.

NP-Completeness and Density

Theorem 79 If a unary language U ⊆ {0}^∗ is NP-complete, then P = NP.

• Suppose there is a reduction R from sat to U.

• We use R to find a truth assignment that satisfies

boolean expression ϕ with n variables if it is satisfiable.

• Specifically, we use R to prune the exponential-time exhaustive search on p. 727.

• The trick is to keep the already discovered results ϕ[ t ] in a table H.

aBerman (1978).

1: if | t | = n then

2: return ϕ[ t ];

3: else

4: if (R(ϕ[ t ]), v) is in table H then

5: return v;

6: else

7: if ϕ[ t0 ] = “satisfiable” or ϕ[ t1 ] = “satisfiable” then

8: Insert (R(ϕ[ t ]), “satisfiable”) into H;

9: return “satisfiable”;

10: else

11: Insert (R(ϕ[ t ]), “unsatisfiable”) into H;

12: return “unsatisfiable”;

13: end if

The Proof (continued)

• Since R is a reduction, R(ϕ[ t ]) = R(ϕ[ t^′ ]) implies that ϕ[ t ] and ϕ[ t^′ ] must be both satisfiable or unsatisfiable.

• R(ϕ[ t ]) has polynomial length ≤ p(n) because R runs in log space.

• As R maps to unary numbers, there are only polynomially many p(n) values of R(ϕ[ t ]).

• How many nodes of the complete binary tree (of invocations/truth assignments) need to be visited?

The Proof (continued)

• A search of the table takes time O(p(n)) in the random-access memory model.

• The running time is O(Mp(n)), where M is the total number of invocations of the algorithm.

• If that number is a polynomial, the overall algorithm runs in polynomial time and we are done.

• The invocations of the algorithm form a binary tree of depth at most n.

The Proof (continued)

• There is a set T = {t¹, t₂, . . .} of invocations (partial truth assignments, i.e.) such that:

1. |T | ≥ (M − 1)/(2n).

2. All invocations in T are recursive (nonleaves).

3. None of the elements of T is a prefix of another.

VWVWHS'HOHWH OHDYHV0−

QRQOHDYHVUHPDLQLQJ

QGVWHS6HOHFWDQ\

ERWWRPXQGHOHWHG LQYRFDWLRQWDQGDGG LWWR7

UGVWHS'HOHWHDOOWV DWPRVWQDQFHVWRUV SUHIL[HVIURP

IXUWKHUFRQVLGHUDWLRQ

An Example

r

a c

d e f

g h i j

l k

1

2 3

4 5

T = { h, j }; none of h and j is a prefix of the other.

The Proof (continued)

• All invocations t ∈ T have different R(ϕ[ t ]) values.

– The invocation of one started after the invocation of the other had terminated.

– If they had the same value, the one that was invoked later would have looked it up, and therefore would not be recursive, a contradiction.

• The existence of T implies that there are at least (M − 1)/(2n) different R(ϕ[ t ]) values in the table.

The Proof (concluded)

• We already know that there are at most p(n) such values.

• Hence (M − 1)/(2n) ≤ p(n).

• Thus M ≤ 2np(n) + 1.

• The running time is therefore O(Mp(n)) = O(np²(n)).

• We comment that this theorem holds for any sparse language, not just unary ones.^a

aMahaney (1980).

coNP-Completeness and Density

Theorem 80 (Fortung (1979)) If a unary language U ⊆ {0}^∗ is coNP-complete, then P = NP.

• Suppose there is a reduction R from sat complement to U .

• The rest of the proof is basically identical except that, now, we want to make sure a formula is unsatisfiable.

The Power of Monotone Circuits

• Monotone circuits can only compute monotone boolean functions.

• They are powerful enough to solve a P-complete problem, monotone circuit value (p. 294).

• There are NP-complete problems that are not monotone;

they cannot be computed by monotone circuits at all.

• There are NP-complete problems that are monotone;

they can be computed by monotone circuits.

– hamiltonian path and clique.

clique

• cliquen,k is the boolean function deciding whether a graph G = (V, E) with n nodes has a clique of size k.

• The input gates are the (_n

2

) entries of the adjacency matrix of G.

– Gate g_ij is set to true if the associated undirected edge { i, j } exists.

• cliquen,k is a monotone function.

• Thus it can be computed by a monotone circuit.

• This does not rule out that nonmonotone circuits for

Crude Circuits

• One possible circuit for cliquen,k does the following.

1. For each S ⊆ V with |S| = k, there is a circuit with O(k²) ∧-gates testing whether S forms a clique.

2. We then take an or of the outcomes of all the (_n

k

) subsets S₁, S₂, . . . , S(ⁿ_k).

• This is a monotone circuit with O(k²(_n

k

)) gates, which is exponentially large unless k or n − k is a constant.

• A crude circuit CC(X¹, X₂, . . . , X_m) tests if any of X_i ⊆ V forms a clique.

– The above-mentioned circuit is CC(S₁, S₂, . . . , S(ⁿ_k)).

The Proof: Positive Examples

• Analysis will be applied to only positive examples and negative examples as inputs.

• A positive example is a graph that has (_k

2

) edges connecting k nodes in all possible ways.

• There are (_n

k

) such graphs.

• They all should elicit a true output from cliquen,k.

The Proof: Negative Examples

• Color the nodes with k − 1 different colors and join by an edge any two nodes that are colored differently.

• There are (k − 1)ⁿ such graphs.

• They all should elicit a false output from cliquen,k. – Each set of k nodes must have 2 identically colored

nodes; hence there is no edge between them.

Positive and Negative Examples with k = 5

$SRVLWLYHH[DPSOH $QHJDWLYHH[DPSOH

A Warmup to Razborov’s Theorem

Lemma 81 (The birthday problem) The probability of collision, C(N, q), when q balls are thrown randomly into N ≥ q bins is at most

q(q − 1) 2N .

Lemma 82 If crude circuit CC(X₁, X₂, . . . , X_m) computes cliquen,k, then m ≥ n^n1/8/20 for n sufficiently large.

The Proof (continued)

• Let k = n^1/4.

• Let ℓ = √

k/10.

• Let X ⊆ V .

• Suppose | X | ≤ ℓ.

The Proof (continued)

• A random f : X → { 1, 2, . . . , k − 1 } has collisions with probability less than 0.01 (see Lemma 81 on p. 744).

• Hence f is one-to-one with probability 0.99.

• When f is one-to-one, f is a coloring of X with k − 1 colors without repeated colors.

• As a result, when f is one-to-one, it generates a clique on X.

The Proof (continued)

• Note that a random negative example is simply a random g : V → { 1, 2, . . . , k − 1 }.

• So our random f : X → { 1, 2, . . . , k − 1 } is simply a random g restricted to X.

• In summary, the probability that X is not a clique when supplied with a random negative example is at most

0.01.

The Proof (continued)

• Now suppose | X | > ℓ.

• Consider the probability that X is a clique when supplied with a positive example.

• It is the probability that X is part of the clique.

• Hence the desired probability is (_n−ℓ

k−ℓ

)/(_n

k

).

The Proof (continued)

• Now,

(_n−ℓ

k−ℓ

) (_n

k

) = k(k − 1) · · · (k − ℓ + 1) n(n − 1) · · · (n − ℓ + 1)

≤

(k n

)ℓ

≤ n^{−(3/4) ℓ}

≤ n^−√k/20

= n^−n1/8/20.

The Proof (concluded)

• In summary, the probability that X is a clique when supplied with a random positive example is at most n^−n1/8/20.

• So we need at least n^n1/8/20 Xs in the crude circuit.

Sunflowers

• Fix p ∈ Z⁺ and ℓ ∈ Z⁺.

• A sunflower is a family of p sets {P¹, P₂, . . . , P_p}, called petals, each of cardinality at most ℓ.

• Furthermore, all pairs of sets in the family must have the same intersection (called the core of the sunflower).

FRUH

A Sample Sunflower

{{1, 2, 3, 5}, {1, 2, 6, 9}, {0, 1, 2, 11}, {1, 2, 12, 13}, {1, 2, 8, 10}, {1, 2, 4, 7}}.



Æ¿³È

É¿³Ì

Ë¿³Äà ǿ³Ê

ÿ³ÄÄ ÄÅ¿³ÄÆ

The Erd˝ os-Rado Lemma

Lemma 83 Let Z be a family of more than M = (p − 1)^ℓℓ!

nonempty sets, each of cardinality ℓ or less. Then Z must contain a sunflower (with p petals).

• Induction on ℓ.

• For ℓ = 1, p different singletons form a sunflower (with an empty core).

• Suppose ℓ > 1.

• Consider a maximal subset D ⊆ Z of disjoint sets.

The Proof of the Erd˝ os-Rado Lemma (continued)

For example,

Z = {{1, 2, 3, 5}, {1, 3, 6, 9}, {0, 4, 8, 11}, {4, 5, 6, 7}, {5, 8, 9, 10}, {6, 7, 9, 11}}, D = {{1, 2, 3, 5}, {0, 4, 8, 11}}.

The Proof of the Erd˝ os-Rado Lemma (continued)

• Suppose D contains at least p sets.

– D constitutes a sunflower with an empty core.

• Suppose D contains fewer than p sets.

– Let C be the union of all sets in D.

– | C | < (p − 1)ℓ.

– C intersects every set in Z by D’s maximality.

– There is a d ∈ C that intersects more than

M

(p−1)ℓ = (p − 1)^ℓ−1(ℓ − 1)! sets in Z.

Z^′ {Z − {d} : Z ∈ Z, d ∈ Z}.

The Proof of the Erd˝ os-Rado Lemma (concluded)

• (continued)

– Z^′ has more than M^′ = (p − 1)^ℓ−1(ℓ − 1)! sets.

– M^′ is just M with ℓ replaced with ℓ − 1.

– Z^′ contains a sunflower by induction, say {P¹, P₂, . . . , P_p}.

– Now,

{P¹ ∪ {d}, P² ∪ {d}, . . . , P^p ∪ {d}}

is a sunflower in Z.

Paul Erd˝ os (1913–1996)

Comments on the Erd˝ os-Rado Lemma

• A family of more than M sets must contain a sunflower.

• Plucking a sunflower means replacing the sets in the sunflower by its core.

• By repeatedly finding a sunflower and plucking it, we can reduce a family with more than M sets to a family with at most M sets.

• If Z is a family of sets, the above result is denoted by pluck(Z).

• Note: pluck(Z) is not unique.

An Example of Plucking

• Recall the sunflower on p. 752:

Z = {{1, 2, 3, 5}, {1, 2, 6, 9}, {0, 1, 2, 11}, {1, 2, 12, 13}, {1, 2, 8, 10}, {1, 2, 4, 7}}

• Then

pluck(Z) = {{1, 2}}.

Razborov’s Theorem

Theorem 84 (Razborov (1985)) There is a constant c such that for large enough n, all monotone circuits for cliquen,k with k = n^1/4 have size at least n^cn1/8.

• We shall approximate any monotone circuit for cliquen,k by a restricted kind of crude circuit.

• The approximation will proceed in steps: one step for each gate of the monotone circuit.

• Each step introduces few errors (false positives and false negatives).

• But the final crude circuit has exponentially many errors.

The Proof

• Fix k = n^1/4.

• Fix ℓ = n^1/8.

• Note that^a

2 (ℓ

2 )

≤ k − 1.

• p will be fixed later to be n^1/8 log n.

• Fix M = (p − 1)^ℓℓ!.

– Recall the Erd˝os-Rado lemma (p. 753).

aCorrected by Mr. Moustapha Bande (D98922042) on January 05,

The Proof (continued)

• Each crude circuit used in the approximation process is of the form CC(X₁, X₂, . . . , X_m), where:

– X_i ⊆ V . – |Xⁱ| ≤ ℓ.

– m ≤ M.

• It answers true if any Xⁱ is a clique.

• We shall show how to approximate any circuit for cliquen,k by such a crude circuit, inductively.

• The induction basis is straightforward:

– Input gate g_ij is the crude circuit CC({i, j}).

The Proof (continued)

• Any monotone circuit can be considered the or or and of two subcircuits.

• We shall show how to build approximators of the overall circuit from the approximators of the two subcircuits.

– We are given two crude circuits CC(X ) and CC(Y).

– X and Y are two families of at most M sets of nodes, each set containing at most ℓ nodes.

– We construct the approximate or and the approximate and of these subcircuits.

The Proof: or

• CC(X ∪ Y) is equivalent to the or of CC(X ) and CC(Y).

– A set of nodes C ∈ X ∪ Y is a clique if and only if C ∈ X is a clique or C ∈ Y is a clique.

• Violations in using CC(X ∪ Y) occur when |X ∪ Y| > M.

• Such violations can be eliminated by using CC(pluck(X ∪ Y))

as the approximate or of CC(X ) and CC(Y).

The Proof: or

• If CC(Z) is true, then CC(pluck(Z)) must be true.

– The quick reason: If Y is a clique, then a subset of Y must also be a clique.

– For each Y ∈ X ∪ Y, there must exist at least one X ∈ pluck(X ∪ Y) such that X ⊆ Y .

– If Y is a clique, then this X is also a clique.

• We now bound the number of errors this approximate or makes on the positive and negative examples.

The Proof: or (concluded)

• CC(pluck(X ∪ Y)) introduces a false positive if a

negative example makes both CC(X ) and CC(Y) return false but makes CC(pluck(X ∪ Y)) return true.

• CC(pluck(X ∪ Y)) introduces a false negative if a positive example makes either CC(X ) or CC(Y) return true but makes CC(pluck(X ∪ Y)) return false.

• How many false positives and false negatives are introduced by CC(pluck(X ∪ Y))?

The Number of False Positives

Lemma 85 CC(pluck(X ∪ Y)) introduces at most

M

p−1 2^−p(k − 1)ⁿ false positives.

• A plucking replaces the sunflower {Z¹, Z₂, . . . , Z_p} with its core Z.

• A false positive is necessarily a coloring such that:

– There is a pair of identically colored nodes in each petal Z_i (and so both crude circuits return false).

– But the core contains distinctly colored nodes.

∗ This implies at least one node from each same-color pair was plucked away.

Proof of Lemma 85 (continued)

Proof of Lemma 85 (continued)

• Color nodes V at random with k − 1 colors and let R(X) denote the event that there are repeated colors in set X.

• Now prob[R(Z¹) ∧ · · · ∧ R(Z^p) ∧ ¬R(Z)] is at most prob[R(Z₁) ∧ · · · ∧ R(Z^p)|¬R(Z)]

=

∏p i=1

prob[R(Z_i)|¬R(Z)] ≤

∏p i=1

prob[R(Z_i)]. (19) – First equality holds because R(Z_i) are independent

given ¬R(Z) as Z contains their only common nodes.

– Last inequality holds as the likelihood of repetitions

Proof of Lemma 85 (continued)

• Consider two nodes in Zⁱ.

• The probability that they have identical color is _k−1¹ .

• Now prob[ R(Zⁱ) ] ≤ (^|Zi|₂ )

k−1 ≤ (₂^ℓ)

k−1 ≤ ¹₂.

• So the probability^a that a random coloring is a new false positive is at most 2^−p by inequality (19).

• As there are (k − 1)ⁿ different colorings, each plucking introduces at most 2^−p(k − 1)ⁿ false positives.

aProportion, i.e.

Proof of Lemma 85 (concluded)

• Recall that | X ∪ Y | ≤ 2M.

• pluck(X ∪ Y) ends the moment the set system contains

≤ M sets.

• Each plucking reduces the number of sets by p − 1.

• Hence at most _p^M₋₁ pluckings occur in pluck(X ∪ Y).

• At most

M

p − 1 2^−p(k − 1)ⁿ false positives are introduced.^a

aNote that the numbers of errors are added not multiplied. Recall that

The Number of False Negatives

Lemma 86 CC(pluck(X ∪ Y)) introduces no false negatives.

• A plucking replaces sets in a crude circuit by their (common) subset.

• This makes the test for cliqueness less stringent (p.

765).^a

aRecall that CC(pluck(X ∪ Y)) introduces a false negative if a pos- itive example makes either CC(X ) or CC(Y) return true but makes CC(pluck(X ∪ Y)) return false.

The Number of False Negatives (concluded)

Y

X

The Proof: and

• The approximate and of crude circuits CC(X ) and CC(Y) is

CC(pluck({Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y, |Xⁱ ∪ Y^j| ≤ ℓ})).

• We now count the number of errors this approximate and makes on the positive and negative examples.

The Proof: and (concluded)

• The approximate and introduces a false positive if a negative example makes either CC(X ) or CC(Y) return false but makes the approximate and return true.

• The approximate and introduces a false negative if a positive example makes both CC(X ) and CC(Y) return true but makes the approximate and return false.

• How many false positives and false negatives are introduced by the approximate and?

The Number of False Positives

Lemma 87 The approximate and introduces at most M²2^−p(k − 1)ⁿ false positives.

• We prove this claim in stages.

• CC({Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y}) introduces no false positives.

– If X_i ∪ Y^j is a clique, both X_i and Y_j must be

cliques, making both CC(X ) and CC(Y) return true.

• CC({Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y, |Xⁱ ∪ Y^j| ≤ ℓ}) introduces no additional false positives because we are testing fewer sets for cliqueness.

Proof of Lemma 87 (concluded)

• | {Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y, |Xⁱ ∪ Y^j| ≤ ℓ} | ≤ M².

• Each plucking reduces the number of sets by p − 1.

• So pluck({Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y, |Xⁱ ∪ Y^j| ≤ ℓ}) involves ≤ M²/(p − 1) pluckings.

• Each plucking introduces at most 2^−p(k − 1)ⁿ false positives by the proof of Lemma 85 (p. 767).

• The desired upper bound is

[ M²/(p − 1) ] 2^−p(k − 1)ⁿ ≤ M²2^−p(k − 1)ⁿ.

The Number of False Negatives

Lemma 88 The approximate and introduces at most M²(_n−ℓ−1

k−ℓ−1

) false negatives.

• We again prove this claim in stages.

• CC({Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y}) introduces no false negatives.

– Suppose both CC(X ) and CC(Y) accept a positive example with a clique of size k.

– This clique must contain an X_i ∈ X and a Y^j ∈ Y.

∗ This is why both CC(X ) and CC(Y) return true.

– As the clique contains X_i ∪ Y^j, the new circuit returns true.

Proof of Lemma 88 (continued)

Y_j X_i

Clique of size k

Proof of Lemma 88 (continued)

• CC({Xⁱ ∪ Y^j : X_i ∈ X , Y^j ∈ Y, |Xⁱ ∪ Y^j| ≤ ℓ}) introduces

≤ M²(_n−ℓ−1

k−ℓ−1

) false negatives.

– Deletion of set Z = X_i ∪ Y^j larger than ℓ introduces false negatives only if Z is part of a clique.

– There are (_n−|Z|

k−|Z|

) such cliques.

∗ It is the number of positive examples whose clique contains Z.

– (_n−|Z|

k−|Z|

) ≤ (_n−ℓ−1

k−ℓ−1

) as |Z| > ℓ.

– There are at most M² such Zs.

Proof of Lemma 88 (concluded)

• Plucking introduces no false negatives.

– Recall that if CC(Z) is true, then CC(pluck(Z)) must be true (p. 765).

Two Summarizing Lemmas

From Lemmas 85 (p. 767) and 87 (p. 776), we have:

Lemma 89 Each approximation step introduces at most M²2^−p(k − 1)ⁿ false positives.

From Lemmas 86 (p. 772) and 88 (p. 778), we have:

Lemma 90 Each approximation step introduces at most M²(_n−ℓ−1

k−ℓ−1

) false negatives.

The Proof (continued)

• The above two lemmas show that each approximation step introduces “few” false positives and false negatives.

• We next show that the resulting crude circuit has “a lot” of false positives or false negatives.

The Final Crude Circuit

Lemma 91 Every final crude circuit is:

1. Identically false—thus wrong on all positive examples.

2. Or outputs true on at least half of the negative examples.

• Suppose it is not identically false.

• By construction, it accepts at least those graphs that have a clique on some set X of nodes, with | X | ≤ ℓ, which at n^1/8 is less than k = n^1/4.

• The proof of Lemma 85 (p. 767ff) shows that at least half of the colorings assign different colors to nodes in X.

• So half of the negative examples have a clique in X and are accepted.

The Proof (continued)

• Recall the constants on p. 761: k = n^1/4, ℓ = n^1/8, p = n^1/8 log n, M = (p − 1)^ℓℓ! < n^(1/3)n1/8 for large n.

• Suppose the final crude circuit is identically false.

– By Lemma 90 (p. 782), each approximation step introduces at most M²(_n−ℓ−1

k−ℓ−1

) false negatives.

– There are (_n

k

) positive examples.

– The original monotone circuit for cliquen,k has at least

(_n

k

)

M²(_n−ℓ−1) ≥ 1 M²

(n − ℓ k

)ℓ

≥ n^(1/12)n1/8

The Proof (concluded)

• Suppose the final crude circuit is not identically false.

– Lemma 91 (p. 784) says that there are at least (k − 1)ⁿ/2 false positives.

– By Lemma 89 (p. 782), each approximation step introduces at most M²2^−p(k − 1)ⁿ false positives – The original monotone circuit for cliquen,k has at

least

(k − 1)ⁿ/2

M²2^−p(k − 1)ⁿ = 2^p−1

M² ≥ n^(1/3)n1/8 gates.

Alexander Razborov (1963–)

P ̸= NP Proved?

• Razborov’s theorem says that there is a monotone language in NP that has no polynomial monotone circuits.

• If we can prove that all monotone languages in P have polynomial monotone circuits, then P ̸= NP.

• But Razborov proved in 1985 that some monotone languages in P have no polynomial monotone circuits!

Finis