More Efficient Queries in PCPs for NP and ... - Semantic Scholar
Department of Numerical Analysis and Computer Science
More Efficient Queries in PCPs for NP and Improved Approximation Hardness of Maximum CSP
Lars Engebretsen
Jonas Holmerin
TRITA-NA-0409
Lars Engebretsen; Jonas Holmerin More Efficient Queries in PCPs for NP and Improved Approximation Hardness of Maximum CSP Report number: TRITA-NA-0409 Publication date: April 2004 E-mail of author: [email protected]
Reports can be ordered from: Numerical Analysis and Computer Science (NADA) Royal Institute of Technology (KTH) SE-100 44 Stockholm SWEDEN telefax: +46 8 790 09 30 http://www.nada.kth.se/
More Efficient Queries in PCPs for NP and Improved Approximation Hardness of Maximum CSP Lars Engebretsen and Jonas Holmerin Department of Numerical Analysis and Computer Science Royal Institute of Technology SE-100 44 Stockholm SWEDEN E-mail: {enge,joho}@kth.se April 2004
Abstract. In the PCP model, a verifier is supposed to probabilistically decide if a given input belongs to some language by posing queries to a purported proof of this fact. The probability that the verifier accepts an input in the language given a correct proof is called the completeness c; the probability that the verifier rejects an input not in the language given any proof is called the soundness s. For a verifier posing q queries to the proof, the amortized query complexity is defined by q/ log2 (c/s) if the proof is coded in binary. It is a measure of the average “efficiency” of the queries in the following sense: An ideal query should preserve the completeness and halve the soundness. If this were the case for all queries, the amortized query complexity would be exactly one. Samorodnitsky and Trevisan [STOC 2000] gave a q-query PCP for NP with amor√ tized query complexity 1+2/ q +ε for any constant ε > 0. In this paper, we examine to what extent their result can be sharpened. Using the layered label cover problem recently introduced by Dinur et al. [STOC 2003], we devise a new “outer verifier” that allows us to construct an “inner verifier” that uses the query bits more efficiently than earlier verifiers. This enables us to construct a PCPpfor NP that queries q positions in the proof and has amortized query complexity 1 + 2/q + ε. As an immediate corollary, we also obtain an improved hardness of approximation result for the Maximum q-CSP problem. Since the improvement compared to previous work is moderate, we then examine if there is an underlying reason for this. Our construction in this paper follows a paradigm for query efficient PCPs for NP outlined by many previous researchers and it combines a state-of-the-art “outer verifier” with a natural candidate for a query efficient “inner verifier”. We prove in this paper that all natural attempts to construct more query efficient versions of our verifier are doomed to fail. This implies that significantly new ideas regarding proof composition and encoding of PCP proofs are required to construct PCPs for NP that are more query efficient than the one we propose in his paper.
1
1
Introduction
For more than a decade, one of the most powerful techniques for proving approximation hardness results for various types of discrete optimization problems, in particular constraint satisfaction problems, has been the use of Probabilistically Checkable Proofs (PCPs) for NP. In the PCP model, the verifier is given an input and oracle access to an alleged proof of the fact that the input belongs to some specified language. The verifier also has access to a specified amount of random bits. Based on the random bits and the input, the verifier decides which positions in the proof it should look at. Once it has examined the positions of its choice, it uses all available information to decide if the input should be accepted or rejected. The PCP theorem [1] asserts the startling fact that any language in NP can be probabilistically checked by a verifier that uses logarithmic randomness, always accepts a correct proof of an input in the language, accepts proofs of inputs not in the language with probability at most 1/2, and examines a constant number of bits of the proof. The probability that the PCP verifier accepts a correct proof of an input in the language is called the completeness c, while the probability that the verifier accepts any proof of an input not in the language is called the soundness s. It is generally desirable to have c ≈ 1 and s as small as possible. PCPs using a logarithmic number of random bits can be used to prove approximation hardness results for many combinatorial optimization problems. In particular, PCPs querying a small number of bits, say q bits, are intimately connected with Boolean q-ary constraint satisfaction problems: Strong approximation hardness results follow immediately from such PCPs with high completeness and low soundness. H˚astad’s approximation hardness result for linear equations mod 2 gives such a characterization [10]: The verifier in his PCP for NP queries three bits, has completeness 1 − ε and soundness 1/2 + δ for arbitrary ε and δ. Allowing the verifier to make more queries to the proof is a natural way to lower the soundness even further; independent repetition of H˚astad’s protocol k times gives a PCP that queries 3k bits, has completeness at least 1 − kε and soundness at most (1/2 + δ)k . Hence the soundness goes down exponentially fast with the number of bits read from the proof. The purpose of this paper is to study exactly how fast the soundness can go down. There are several possible measures of “fast” in this context. One is the so called amortized query complexity: For a PCP with q queries, the amortized query complexity is defined as q¯ = q/ log(c/s). The task of constructing PCPs for NP with low amortized query complexity—as well as the related question of testing if a function is linear—has been explored previously, most notably in a sequence of papers by Trevisan with different coauthors [17, 15, 14]. The key idea in those papers is to use dependent repetitions of H˚astad’s basic protocol. The technical part of the argument then boils down to showing that this dependence does not destroy the soundness of the verifier. In this paper, we adapt and extend these previous ideas. In particular, we show that the idea of using dependent repetitions can be combined with the recently introduced layered label cover problem [6]. 2
1.1
Query-efficient verification of NP
Another important efficiency measure for PCPs is the free bit complexity: A PCP has free bit complexity f if there are, for every outcome of the random bits used by the verifier, at most 2f possible answers to the verifier’s queries that make the verifier accept. Using the free bit complexity, our first main result in this paper can be written as follows: Theorem 1. For any integer f ≥ 2, any positive integer t ≤ f (f − 1)/2, and any constant ε > 0, there is a PCP for NP with free bit complexity f, query complexity f + t, completeness 1 − ε, and soundness 2−t + ε. To compare this with the previously best known result, due to Samorodnitsky and Trevisan [14], it is instructive to cast this result in terms of the amortized query complexity as a function of the number of queries: Corollary 1. For any integer q ≥ 3 and any constant ε > 0, there p is a PCP for NP with query complexity q and amortized query complexity 1 + 2/q + ε. Writing the soundness of our PCP as a function of the number of queries, we also get as an immediate corollary of our main result an improved approximation hardness result for the q-CSP problem: Corollary 2. For √ any integer q ≥ 3, it is NP-hard to approximate the q-CSP prob2q−2−1/2 . q− lem within 2 The previously best known construction, due to Samorodnitsky and Trevisan [14] √ gives amortized √ query complexity 1 + 2/ q + ε and hardness of approximation within 2q−2 q+1+1 . While our improvements might at first seem moderate, we remark that it is possible to approximate the q-CSP problem within 2q−1 in polynomial time and that a PCP for NP cannot have amortized query complexity 1 + 1/(q − 1) unless P = NP; this follows from Trevisan’s approximation algorithm for q-CSP [16]. Hence the only possible further improvements, unless P = NP, along this line of research concern the lower order term in q¯ and the lower term in the exponent of the approximation factor—where we get an improvement by a √ factor of 2. Our second main result in this paper is that there seems to be an underlying reason for why our improvement compared to previous work is moderate. Our construction in this paper follows a paradigm for query efficient PCPs for NP outlined by many previous researchers: On a high level, it combines a state-of-the-art “outer verifier” corresponding to a so called “layered label cover problem” with a corresponding “inner verifier” that is more query efficient than previously known verifiers. There are natural ways to extend this inner verifier in certain ways to produce what, at first, looks like even more query efficient verifiers. We prove in § 5, however, that all such extensions give verifiers that are less query efficient than our proposed verifier in the sense that the new verifiers have the same soundness as our verifier but pose more queries. This implies that significantly new ideas regarding 3
proof composition and encoding of PCP proofs are required to construct PCPs for NP that are more query efficient than the one we propose in his paper. Driven by the desire to prove strong inapproximability results for Maximum Clique another measure, the amortized free bit complexity, was introduced [4]. Recall that a PCP has free bit complexity f if there are, for every outcome of the random bits used by the verifier, at most 2f possible answers to the verifier’s queries that make the verifier accept. The amortized free bit complexity is then defined as f¯ = f / log(c/s). The intuition behind the term free bit complexity is that a typical verifier with free bit complexity f first reads f bits, the so called “free bits”, from the proof and then performs a number of consistency checks, each involving some of the free bits and some new positions in the proof. The PCP constructed by Samorodnitsky and Trevisan [14] has a verifier that first queries 2k free bits and then makes k 2 consistency checks, each of which uses two (different) free bits and one unique non-free bit. Hence the verifier queries in total 2k + k 2 bits and it can be shown that the test has completeness 1 − ε 2 and soundness 2−k + ε. It follows that the amortized query complexity can be written as 1 + 4/f + ε where f is the number of free bits used by the verifier. Under the assumption that the verifier first queries some free bits and then performs consistency checks involving two free bits where the same two free bits are present in at most one consistency check, the amortized query complexity cannot be lower than 1 + 2/(f − 1). Our construction in this paper achieves this goal. Corollary 3. For any integer f ≥ 2 and any constant ε > 0, there is a PCP for NP with free bit complexity f and amortized query complexity 1 + 2/(f − 1) + ε. Hence it is optimal among the PCPs that work as described above. One natural suggestion to improve the soundness is to perform consistency checks not only on pairs of free bits but on all possible subsets of free bits. In their paper [14], Samorodnitsky and Trevisan show that such an approach is fruitless for the related problem of linearity testing. In that setting, the “proof” is a table of a Boolean function and “consistency” simply means that this table respects linearity. For the more complex situation involving PCPs for NP with several tables defining different functions that should be correlated in some way, there is no known corresponding result. As mentioned above, the second main result in this paper is an optimality result. In the above language, this result shows that it is impossible to beat the soundness bounds stated above even with a verifier that tests consistency induced not only by pairs of free bits but by all possible Boolean predicates on the free bits. Since all hitherto constructed PCPs with low amortized query complexity work in this way, our result shows that to construct PCPs with even lower amortized query complexity, radically new ideas are needed.
1.2
Main sources of our improvements
Our paper uses the fundamental idea of “recycling” query bits in linearity tests and PCPs, introduced and explored in a sequence of papers authored by Trevisan with 4
different coauthors. For linearity tests, the construction is founded on the basic BLR linearity test [5] that selects random x and y and tests if f (x)f (y) = f (xy). Trevisan [17] introduced the notion of a graph test iterating the basic BLR test once for every edge in the graph: Each variable in the graph corresponds to a randomly selected value and for each edge {x, y} the test f (x)f (y) = f (xy) is executed. These tests are, of course, dependent, but Trevisan [17] was able to show that they still behave essentially as independent tests for some graphs. He also used similar ideas to construct a PCP for NP with q¯ = 2.5 + ε. Extending the analysis, both for linearity tests and PCPs, Sudan and Trevisan [15] constructed a PCP for NP with q¯ = 1.5 + 3/(q − 2) + ε, and, finally, Samorodnitsky and Trevisan [14] constructed √ the PCP for NP mentioned above, with q¯ = 1 + 2/ q + ε. Our main source of improvement is that we use a layered label cover problem recently introduced by Dinur et al. [6] as our underlying NP-hard problem. While our construction of the label cover instance is exactly the same as used by Dinur et al., we need in this paper a stronger hardness result than they state in their paper. We also use a new way to connect this layered label cover problem—or “outer verifier” as it is often called in PCP jargon—with the actual PCP—or “inner verifier”. Loosely speaking, while previous constructions checked pairwise consistency between pairs (W0 , Wi ) of proof tables for some number of Wi :s, our use of the layered label cover problem as an outer verifier enables us to devise an inner verifier that tests pairwise consistency between all pairs (Wi , Wj ). On a slightly more concrete level, the Samorodnitsky-Trevisan verifier queries k free bits in the table W0 and then one free bit in each of the tables Wi . But it does not use all possible pairs of free bits for consistency checks, only (roughly) half of them. The intuitive reason why our construction is more efficient with respect to the free bits is that we check pairwise consistency between tables (Wi , Wj ) by first querying one free bit from each table and then using all pairs of free bits for a consistency check. H˚astad and Wigderson [12] have presented a much simplified analysis of the Samorodnitsky-Trevisan PCP; we use the same kind of analysis in this paper.
2
Background
Our construction, as most other PCP constructions, use the powerful technique of proof composition, introduced by Arora and Safra [2]. The main idea in such constructions is to combine two verifiers that optimize different type of parameters into one verifier that optimizes both parameters. In particular, it is common to use an “outer verifier” that queries a proof containing values from some large domain and an “inner verifier” whose proof contains purported answers to the outer verifier encoded with some error correcting code. To get an intuitive understanding of both our construction and earlier related constructions, it is instructive to recall a high-level description of H˚astad’s PCP
5
for NP with three queries—two of which are free—completeness 1 − ε and soundness 1/2 + ε [10]. The outer verifier used by H˚astad can be described in several different ways. While H˚astad describes it in terms of a two-prover one-round protocol for a certain class of 3-Sat formulae, we chose one of the alternate formulations: a label cover problem with a certain “gap” property. Definition 1. Given two sets R and S, an instance of the label cover problem on R and S is a set Ψ ⊆ V × Φ, where V and Φ are sets of variables with ranges R and S, respectively, with an onto function πvφ : S → R for every (v, φ) ∈ Ψ . The instance is regular if every v ∈ V occurs in the same number of pairs in Ψ and every φ ∈ Φ occurs in the same number of pairs in Ψ . The following theorem is a consequence of the PCP theorem [1] combined with a certain regularization procedure [9] and the parallel repetition theorem [13]. Theorem 2 [1, 9, 13]. There exists a universal constant µ > 0 such that for every large enough constant u there exist sets R and S with 2u ≤ |R| ≤ |S| ≤ 7u such that it is NP-hard to distinguish between the following two cases given a regular instance Ψ ⊆ V × Φ of a label cover problem on R and S: YES: There exist assignments ΠV : V → R and ΠΦ : Φ → S such that for every (v, φ) ∈ Ψ , ΠV (v) = πvφ (ΠΦ (φ)). NO: There are no assignments ΠV : V → R and ΠΦ : Φ → S such that for more than a fraction |R|−µ of the pairs (v, φ) ∈ Ψ , ΠV (v) = πvφ (ΠΦ (φ)). A regular label cover problem Ψ on (V, R) and (Φ, S) can be viewed as a bi-regular bipartite graph with the node set V ∪. Φ and an edge {v, φ} for every (v, φ) ∈ Ψ . The objective is then to assign labels to the nodes in such a way that for every edge {v, φ}, the constraint ΠV (v) = πvφ (ΠΦ (φ)) holds. The above theorem says that it is NP-hard to distinguish the case when this is possible from the case when it is only possible to satisfy a tiny fraction of the constraints. The inner verifier in H˚astad’s PCP has access to several sub-tables: one for each v ∈ V and one for each φ ∈ Φ. These tables contain purported encodings of the labels assigned to the corresponding variable/vertex. The labels are encoded by the so called long code, first used in the context of PCPs by Bellare, Goldreich and Sudan [3]. The long code Aw,σ of an assignment/label σ to some variable/vertex w assuming values in some set R is a function mapping f ∈ {−1, 1}R to a value in {−1, 1} by the map Aw,σ (f ) = f (σ). To check the proof, H˚astad’s inner verifier essentially selects a random (v, φ) ∈ Ψ , random functions f and g and then checks if Av (f )Aφ (g) = Aφ (fg). (The test is actually slightly more complicated. In fact, the test as written above does not quite work, but we ignore this here, and for the rest of this section, for the sake of clarity.) There are two important points to note here: 1) There are two free queries, Av (f ) and Aφ (g), and one “check”, Aφ (fg). 2) The queries involve tables of two types, one v-table and one φ-table. Trevisan put forward the idea that the free queries could be “recycled”. In his first paper [16], he recycled the query Aφ (g) and made two checks: Av (f1 )Aφ (g) = 6
Aφ (f1 g) and Av (f2 )Aφ (g) = Aφ (f2 g). These checks are dependent, but it turns out that the dependence is weak enough to give soundness 1/4 + ε at the price of 3 free and 2 non-free queries. Hence this construction has amortized query complexity 2.5 + ε. Sudan and Trevisan [15] extended the analysis by using a modification of the outer verifier: From an instance Ψ ⊆ V × Φ of the basic label cover problem, a modified label cover instance is constructed as follows: The instance consists of all tuples (v, φ1 , . . . , φk ) such that (v, φj ) ∈ Ψ for all j; denote by Ψ˜ this set of tuples. The objective is then to construct labelings ΠV and ΠΦ , respectively, of V and Ψ , respectively, such that for all (v, φ1 , . . . , φk ) ∈ Ψ˜ , the constraint ΠV (v) = πvφj (ΠΦ (φj )) holds for every j. Sudan and Trevisan show in their paper that it is NP-hard to distinugish the case when this is possible from the case when it holds for at most a tiny fraction of the tuples in Ψ˜ that ΠV (v) = πvφj (ΠΦ (φj )) for some j. More formally, their theorem can be stated as follows: Theorem 3 [15]. There exists a universal constant µ > 0 such that for every large enough constant u there exist sets R and S with 2u ≤ |R| ≤ |S| ≤ 7u such that it is NP-hard to distinguish between the following two cases given an instance Ψ ⊆ V × Φ of a regular label cover problem on R and S: YES: There exist assignments ΠV : V → R and ΠΦ : Φ → S such that for every (v, φ1 , . . . , φk ) such that (v, φi ) ∈ Ψ for every i, ΠV (v) = πvφi (ΠΦ (φi )) for every i. NO: There are no assignments ΠV : V → R and ΠΦ : Φ → S such that for more than a fraction |R|−µ of the tuples (v, φ1 , . . . , φk ) such that (v, φi ) ∈ Ψ for every i, ΠV (v) = πvφi (ΠΦ (φi )) for some i. (We remark that Sudan and Trevisan called their construction a “k-outer verifier”; they did not use the term “label cover”.) Using this new outer verifier, Sudan and Trevisan [15] were able to analyze an inner verifier that selects random functions f1 , f2 and g1 , . . . , gk , and then checks Av (fi )Aφj (gj ) = Aφj (fi gj ) for all i and j. This gives amortized query complexity 1.5 + ε. Finally, Samorodnitsky and Trevisan [14], using the same outer verifier, were able to analyze the even more general case where the verifier selects v and φ1 , . . . , φk as above, random functions f1 , . . . , fk and g1 , . . . , gk and then checks Av (fi )Aφj (gj ) = Aφj (fi gj ) for all i and j. This construction gives amortized query complexity 1 + ε.
3
A multi-layered label cover problem
The outer verifier devised by Sudan and Trevisan [15] has the property that one v and several φj connected to v are used. There is one “check” for every pair (f, g) of free queries where f is queried from table Av and g is queried from table Aφj . Hence, all of the above constructions check pairwise consistency between the same node v and several nodes φj connected to v in the underlying label cover instance. Our main idea to push the “recycling” further is to instead select k + 1 nodes from 7
a tailored label cover instance in such a way that we can check pairwise consistency between every pair of nodes. This tailored label cover instance was recently devised by Dinur et al. [6] and used by them to prove strong approximation hardness results for hypergraph vertex cover. For our application we prove a slightly stronger “gap” property than they needed. The difference is somewhat technical, but we believe that the ideas in our, stronger, hardness result may be of further use. Recall that the objective of the label cover problem on R and S is to assign to nodes in V labels from R and to nodes in Φ labels from S in such a way that many edges are “satisfied” in the sense that the corresponding projections {πvφ }(v,φ)∈Ψ are satisfied. Our layered label cover problem is similar in spirit, but the instance has more structure. It can be viewed as a k-wise parallel repetition of the original label cover problem but with the objective to construct certain “hybrid” labelings. Given an instance Ψ of the basic label cover problem from Definition 1 we construct a corresponding instance of our layered label cover problem as all k-tuples of elements from Ψ ; hence the instance is simply the k-wise Cartesian product Ψ k and some arbitrary ψ ∈ Ψ k can be written as ψ = ((v1 , φ1 ), . . . , (vk , φk )). In an “ordinary” k-wise parallel repetition the goal would be to construct an assignment to all k-tuples (v1 , . . . , vk ) ∈ V k and an assignment to all k-tuples (φ1 , . . . , φk ) ∈ Φk in such a way that the assignments are consistent, where “consistent” means that each coordinate satisfies the corresponding projection πvj φj from the basic label cover problem. The goal in our layered label cover problem is to construct in total k + 1 assignments: not only one assignment to tuples in V k and one assignment to tuples in Φk , but also k − 1 “hybrid” assignments to “hybrid“ tuples of the form (φ1 , . . . , φt , vt+1 , . . . , vk ) ∈ Φt × V k−t ; see Figure 1. We say that a tuple belongs to layer t if the first t coordinates of the tuple contain values from Φ and the remaining coordinates contain values from V . With this notation, layer 0 corresponds to tuples containing only variables from V , layer k corresponds to tuples containing only variables from Φ, and each ψ ∈ Ψ k corresponds to k + 1 tuples, one in each layer. (Readers very familiar with the presentation of the layered verifier in [6] may want to notice that what we call a tuple corresponding to ψ ∈ Ψ k corresponds to a clique in the multi-partite graph defined in the proof of Theorem 3.3 in [6].) Write ψ = ((v1 , φ1 ), . . . , (vk , φk )) and consider the tuples corresponding to ψ. Assignments to these tuples produce tuples of values from R (values to V -variables) and S (values to Φ-variables). There is an obvious way to require consistency between these assignments. For two tuples (φ1 , . . . , φi , vi+1 , . . . , vk ) and (φ1 , . . . , φj , vj+1 , . . . , vk ) where i < j and cor0 responding assignments (s1 , . . . , si , ri+1 , . . . , rk ) and (s01 , . . . , s0j , rj+1 , . . . , rk0 ), we use the projections πvφ from the basic label cover instance to define what it means for the assignments to be consistent: st = s0t (t ≤ i) and rt = πvt φt (s0t ) (i < t ≤ j) and rt = rt0 (t > j); see Figure 2. Definition 2. Given R, S, V , Φ, Ψ , and {πvφ }(v,φ)∈Ψ as in Definition 1, denote an arbitrary ψ ∈ Ψ k by the vector ((v1 , φ1 ), . . . , (vk , φk )) and define the shorthand πψ,j→i : S j × Rk−j → S i × Rk−i as the map (s1 , . . . , sj , rj+1 , . . . , rk ) 7→ 8
(s1 , . . . , si , πvi+1 φi+1 (si+1 ), . . . , πvj φj (sj ), rj+1 , . . . , rk ). The objective of our label cover problem is to produce k + 1 assignments such that all constraints πψ,j→i are satisfied. It is straightforward to see that if the case “YES” from Theorem 2 holds for the original instance Ψ , the assignments ΠV and ΠΨ guaranteed in this case can be used to construct such assignments. In our application, we need a somewhat non-standard formulation of the “NO” case for our layered label cover. Specifically, we allow non-standard assignments. Normally, an assignment to some set W of variables is a function from W to the set of possible values for the variables. With this approach, a “standard” assignment to a tuple from layer t would then be a function from Φt × V k−t to S t × Rk−t . For the application to PCP:s we need an extended notion of assignments where the assignment function creating labels to a layer t tuple is allowed to use some information that is present in tuples from other layers. Formally, we need that there are no layers ` and h, where ` < h, such that there are “assignments” Π` and Πh with the property that for some fraction of the tuples ψ ∈ Ψ k , it holds that Π` (φ1 , . . . , φh−1 , v1 , . . . , vk ) = πψ,h→` Πh (φ1 , . . . , φk , vh+1 , . . . , vk ) . (1) Consider a ψ ∈ Ψ k and the corresponding k +1 tuples defined above. In words, the above equation states that the function producing labels for the tuple in layer ` is allowed to use the information present in all tuples in layers 0 to h−1; similarly, the function producing labels for the tuple in layer h is allowed to use the information present in all tuples in layers h to k. We can now formulate the hardness result that serves as a starting point for our PCP construction. Theorem 4. There exists a universal constant µ > 0 such that for every large enough constant u and every integer k > 0 there exist sets R and S with 2u ≤ |R| ≤ |S| ≤ 7u such that it is NP-hard to distinguish between the following two cases given an instance Ψ ⊆ V × Φ of a regular label cover problem on R and S: YES: There exist assignments Πi : Φi × V k−i → S i × Rk−i (0 ≤ i ≤ k) such that for all ψ ∈ Ψ k and all i and j (0 ≤ i < j ≤ k) it holds that Πi (φ1 , . . . , φi , vi+1 , . . . , vk ) = πψ,j→i Πj (φ1 , . . . , φj , vj+1 , . . . , vk ) , where {vi }ki=1 , {φi }ki=1 , and {πψ,j→i }0≤i<j≤k are defined from ψ as in Definition 2. NO: There are no two integers ` and h (0 ≤ ` < h ≤ k) such that there exist functions P` from Φh−1 × V k to probability distributions on S ` × Rk−` and Ph from Φk × V k−h to probability distributions on S h × Rk−h with the property that 1 X Prr∼P` (φ1 ,...,φh−1 ,v1 ,...,vk ) [r = πψ,h→` (s)] ≥ |R|−µ , |Ψ k | s∼Ph (φ1 ,...,φk ,vh+1 ,...,vk ) k ψ∈Ψ
where {vi }ki=1 , {φi }ki=1 , and πψ,h→` are defined from ψ as in Definition 2. Proof. If there are assignments satisfying property YES in Theorem 2, the same assignments applied coordinate-wise satisfy property YES in this theorem. For 9
the converse, we prove that if property NO in this theorem is violated, then property NO in Theorem 2 is also violated. Hence assume that there are ` and h and families of probability distributions such that property NO in this theorem is violated. A straightforward derandomization using the method of conditional probabilities then shows that there exist functions Π` : Φh−1 × V k → S ` × Rk−` and Πh : Φk × V k−h → S h × Rk−h with the property that equation (1) holds for a fraction at least |R|−µ of the tuples ψ ∈ Ψ k . Consider the partition on Ψ k induced by the equivalence relation “all coordinates but the hth one are equal”. Clearly, there must exist some equivalence class such that the above equality holds for at least a fraction |R|−µ of the ψ in that equivalence class, i.e., for a fraction |R|−µ of the values of the hth coordinate. Define assignments ΠV : V → R and ΠΦ : Φ → S by the hth coordinate of Π` and Πh , respectively, restricted to that particular equivalence class. Since equation (1) is satisfied for a fraction at least |R|−µ of the values of the hth coordinate, coordinate h of the equality must be satisfied for a fraction at least |R|−µ of the values of the hth coordinate. In other words, ΠV (v) = πvφ (ΠΦ (φ)) for at least a fraction |R|−µ of the (v, φ) ∈ Ψ . We remark that the above proof is very similar to the proof presented by Dinur et al. [6]. Hence, the new contribution in terms of variants of the label cover problem in this paper is not the proof, but rather the precise formulation of the hardness result in Theorem 4. The difference is quite subtle and concerns the NO case above. In the hardness result formulated by Dinur et al. [6], their equivalent of the function P` above is only allowed to depend on layer ` and its task is to describe assignments to the variables in that layer (for a pictorial view of the layered PCP, see Fig. 1). Similarly, the function Ph is only allowed to depend on layer h and its task is to describe assignments to the variables in that layer. By contrast, the function P` is in our setting allowed to use information from all layers up to, and including, layer h−1. And the function Ph is in our case allowed to use information from layers h to k. This could potentially give more power to a malicious prover, but it turns out that the proof provided by Dinur et al. [6] can easily be adapted to cover also this new setting. We also allow probabilistic assignments in the “NO” case in our theorem, whereas Dinur et al. [6] only allow deterministic ones. It is, however, well known that this does not make the theorem stronger; we use the probabilistic formulation since we need it in the application of the theorem.
4
A recycling PCP
We now describe a verifier with access to several proof tables, each containing a purported encoding of a label for a node in the layered label cover instance. The verifier bases its decision to accept or reject on some carefully selected values from tables corresponding to the nodes created from some ψ ∈ Ψ k as described in § 3. The main properties of the verifier can loosely be described as follows: 1) If case 10
“YES” in Theorem 4 holds, there exists a proof that makes the verifier accept with high probability; 2) If case “NO” in Theorem 4 holds, the PCP verifier accepts with very small probability.
4.1
The proof
The proof in our PCP contains for each i (0 ≤ i ≤ k) and each w ∈ Φi × V k−i a i k−i table Aw of size 2|S| |R| which should be interpreted as the values of a function i k−i from {−1, 1}S ×R to {−1, 1}. For such a w and some function f : S i × Rk−i → {−1, 1}, Aw (f ) denotes the position in table Aw corresponding to f. Definition 3. Given R, S, V , Φ, Ψ , and an arbitrary ψ ∈ Ψ k , define Aψ,i to be the table Aw where w ∈ Φi × V k−i is defined from ψ = ((v1 , φ1 ), . . . , (vk , φk )) as the k-tuple where position t contains φt if t ≤ i and vt if t > i. We remark here, that a function f: S i × Rk−i → {−1, 1} can be used to index into Aw for any w ∈ Φi × V k−i . This simplifies our analysis below. Also, all tables are assumed to be folded, i.e., Aw (f ) = −Aw (−f ) for all w and f; this property can be enforced by certain access conventions in the verifier. Our only need for folding comes from the fact that certain Fourier coefficients of the tables in the proof are guaranteed to vanish for folded tables; see H˚astad’s paper [10, §§ 2.4–2.6] for details.
4.2
The verifier
The verifier is parameterized by a rational ε > 0, an integer k > 0 and a non-empty subset P of {(i, j) : 0 ≤ i < j ≤ k}. The actions of the verifier are follows: 1. Select ψ ∈ Ψ k uniformly at random. 2. Select fi : S i × Rk−i → {−1, 1} (0 ≤ i ≤ k) independently uniformly at random. 3. Select functions eij : S j × Rk−j → {−1, 1} for each (i, j) ∈ P by selecting eij (x) independently at random to be 1 with probability 1 − ε and −1 otherwise. 4. Accept if Aψ,i (fi )Aψ,j (fj ) = Aψ,j ((fi ◦ πψ,j→i )fj eij ) for every (i, j) ∈ P ; reject otherwise. Here, πψ,j→i is defined as described in Definition 2 and Aψ,i is defined as in Definition 3. Before embarking on the analysis of the soundness of the verifier, let us note some immediate consequences of the construction. Lemma 1. The verifier has completeness at least 1 − |P |ε, query complexity |P | + k + 1, and free bit complexity k + 1. Moreover, it uses at most kdlog |Ψ |e + (k + 1)|S|k + |P ||S|k dlog ε−1 e random bits.
11
Proof. Consider a proof consisting of correct encodings of labels satisfying the “YES” case in Theorem 4. Then Aψ,i (fi ) = fi (ri ) and Aψ,j ((fi ◦ πψ,j→i )fj eij ) = fi (πψ,j→i (rj ))fj (rj )eij (rj ) = fi (ri )fj (rj )eij (rj ) where {ri }ki=0 denotes the labels to the nodes corresponding to ψ. Hence, the verifier accepts if eij (rj ) = 1 for all (i, j) ∈ P . This establishes the completeness. The other claims are verified by straightforward inspection of the protocol.
4.3
Analysis of the soundness
The acceptance predicate is arithmetized as usual: Y 1 + Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) 2
(i,j)∈P
is an indicator for the event that the verifier accepts. This expression can be rewritten as X Y 2−|P | Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ). S⊆P (i,j)∈S
If the expectation of this is at least 2−|P | +δ, there must exist some nonempty S ⊆ P such that Y E Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) ≥ δ. (2) (i,j)∈S
We now consider one such S and prove that it is possible to extract assignments violating property NO in Theorem 4 provided that the above inequality holds. The main idea in the proof of this result is to split the product inside the expectation in inequality (2) above into three parts. The Fourier transform of two of these parts are then used to devise functions P` and Ph that violate property NO in Theorem 4. The precise way to split the product is carefully chosen so that the resulting functions P` and Ph are guaranteed to depend only on certain variables, as required by Theorem 4. This is the place where our modification of the hardness result due to Dinur et al. [6] is needed. Indeed, we arrived at the formulation of our modified version of the hardness result for the layered label cover problem by the requirement that it must always be possible to split the product inside the expectation in (2) in such a way that the resulting `, h, P` , and Ph have precisely the properties needed to violate the NO case in the hardness result. Lemma 2. Suppose that a PCP is constructed as described above from an instance of the k-layered label cover problem with |R| > (ε−1 δ−2 /4)1/µ and that Y E Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) ≥ δ, (i,j)∈S
where the expectation is over the random choices of the verifier, for some nonempty S ⊆ P . Then property NO in Theorem 4 is violated. 12
Proof. Define h = max{j : ∃i(i, j) ∈ S} and ` = min{i : (i, h) ∈ S}. Since the choice of the functions {fi }ki=0 and {eij }0≤i<j≤k is independent of the choice of ψ, there exist functions fi for i 6∈ {`, h} and functions eij for (i, j) 6= (`, h) such that the expectation over f` , fh , e`h and ψ is at least δ. Fix such functions for the remainder of the analysis. We now rewrite the expectation as Y Eψ Ef` ,fh ,e`h Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) (i,j)∈S
and analyze the inner expectation above by splitting the product into three groups. The first group contains the only factor depending on e`h : Aψ,h ((f` ◦ πψ,h→` )fh e`h ). The second group contains all factors corresponding to pairs depending on f` but neither on fh or e`h : Y Bψ (f` ) = Aψ,` (f` ) Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) (i,j)∈S j δ. Applying the Cauchy-Schwartz inequality and using the fact that α Cˆ α = 1, we obtain X 2 ˆ2 2|α| ˆ E Aα Bπψ (α) (1 − 2ε) > δ2 . α
Recall that our objective is to prove that the NO case in Theorem 4 is violated. We do this by constructing probabilistic assignments that are consistent with high probability. Consider the following probabilistic procedure: Compute Aˆ α and Bˆ β and select α and β with probabilities Aˆ 2α and Bˆ β2 , respectively—this is a well-defined procedure by Plancherel’s equality. Then select a random s ∈ α—since the tables are folded, such an s always exists—and a random r ∈ β if one exists, select an arbitrary r ∈ S ` × Rk−` otherwise. It is easy to see that if β = πψ (α) 6= ∅ there is for every r ∈ β at least one s ∈ α such that πψ,h→` (α(s)) = β(r). Hence, the selected assignments are consistent with probability at least X Aˆ 2 Bˆ 2 X α πψ (α) 2 ˆ2 |α| ˆ E ≥ 4ε E Aα Bπψ (α) (1 − 2ε) > 4εδ2 , |α| α α where the inequality follows from the previous section. (There is a slight technicality here, coming from the fact that B need not be folded. However, the fact that A is folded implies that Aˆ α = 0 for all α such that πψ (α) = ∅ [10, Lemma 2.44].) But by assumption 4εδ2 > |R|−µ , hence the above assignments are consistent with probability greater than |R|−µ .
14
5
Limitations of current techniques
It is easy to see that our verifier from § 4 accepts a random proof, i.e., a proof where every location is selected uniformly at random, with probability 2−k(k+1)/2 . Hence our analysis of the PCP is tight. We prove next that it is impossible to improve the soundness of the PCP by adding additional queries of a certain form. In particular, we assume that we use the same basic outer verifier as defined above. Therefore, the inner verifier starts by selecting a ψ ∈ Ψ k uniformly at random. Next, the verifier selects positions in the k+1 tables corresponding to ψ as follows: First, one position in each table is selected by choosing functions fi : S i × Rk−i → {−1, 1} (0 ≤ i ≤ k) independently, but not necessarily uniformly, at random. To check consistency, the verifier may now make one check for every Boolean predicate b: {0, 1}k+1 → {0, 1} in the obvious way: It creates a function hb mapping x ∈ S k to b(f0 (x), . . . , fk (x)) and then checks that the value corresponding to this position in the proof is consistent with the k + 1 values corresponding to the functions fi . Here we, with slight abuse of notation, use the convention that fi (x) is defined by first projecting x so that it is in the domain of fi and then applying fi . There is, however, a slight technicality here: The are k + 1 tables corresponding to the ψ selected by the verifier, in what table should the query induced by the Boolean predicate b be resolved? The “topmost” table always works—this is what was outlined above since hb was defined as a function with domain S k . For predicates b that only depend on, say, the first s coordinates, there are more available tables. Specifically, the tables denoted by Aψ,i such that i ≥ s can be used. We allow the verifier to use all possible tables simultaneously. I.e., for predicates b that depend on the first s coordinates only, we define functions hb,s , hb,s+1 , . . . , hb,k where hb,i is a function mapping x ∈ S i × Rk−i to b(f1 (x), . . . , fi (x), 0, . . . , 0). Then, the verifier checks that the value Aψ,i (hb,i ) is consistent with the queries corresponding to f0 , . . . , fs . It is easy to see that the above verifier always accepts if it holds for all i (0 ≤ i < k) and all j (i < j ≤ k) that fi (ri ) = (fi ◦πj→i )(rj ). If all those k(k +1)/2 tests were independent, it would immediately follow that the soundness of the verifier is at least 2−k(k+1)/2 . However, the tests are not independent since the same fi appears, maybe composed with a projection function, in several different tests. Therefore, a calculation is required to establish that the probability of all k(k+1)/2 tests being simultaneously satisfied is indeed at least 2−k(k+1)/2 . Theorem 5. The verifier outlined above has soundness at least 2−k(k+1)/2 . Proof. Consider the following randomly selected proof: For each i (0 ≤ i ≤ k) and each w ∈ Φi × V k−i select an sw uniformly and independently from S k and then define Aw as the long code of πk→i (sw ). Fix an arbitrary ψ and focus on the consistency checks performed by the verifier. By assumption Aψ,i (fi ) = fi (ri ) where ri = πk→i (si ) and the si are selected independently and uniformly at random from S k . Since every table is a correct
15
long code, Aψ,i (hb,i ) = b(f0 (ri ), . . . , fs (ri ), 0, . . . , 0) for every i ≥ s. Similarly, Aψ,i (fi ) = fi (ri ). Hence, the verifier definitely accepts if it holds for all i (0 ≤ i < k) and all j (i < j ≤ k) that fi (ri ) = (fi ◦ πj→i )(rj ). Therefore, the proof follows from Lemma 3 below. Lemma 3. Given ψ ∈ Ψ k and functions fi : Ri → {0, 1} (0 ≤ i ≤ k), select si (0 ≤ i ≤ k) independently and uniformly at random from S k and define ri = πψ,k→i (si ). Under this distribution, the probability that fi (ri ) = fi (πψ,j→i (rj )) for all i (0 ≤ i < k) and all j (i < j ≤ k) is at least 2−k(k+1)/2 . Proof. By defining the event Ei = ∩kj=i+1 {fi (ri ) = fi (πψ,j→i (rj )}, the sought probability can be written as k−1 k−1 \ Y Pr[Ei | E0 , . . . , Ei−1 ]. Pr Ei = i=0
i=0
We then proceed by showing that Pr[Ei | E0 , . . . , Ei−1 ] can be lower bounded by 2i−k . This is enough to prove the lemma, since then the entire product above is lower bounded by 2−k(k+1)/2 . It is straightforward to bound Pr[E0 ]. Since f0 is a function from R0 to {0, 1} and the πj→0 (rj ) are independent identically distributed variables, f0 (πj→0 (rj )) (0 ≤ j ≤ k) are independent identically distributed Bernoulli random variables. It is well known that the probability that k + 1 such variables attain the same value is at least 2−k . To bound a general factor, we first examine the structure imposed by the condition that E0 , . . . , Ei−1 holds. Introduce the relation ∼µ defined inductively by s ∼0 s0 ⇐⇒ f0 (πk→0 (s)) = f0 (πk→0 (s0 )) and then s ∼µ s0 ⇐⇒ s ∼µ−1 s0
and
fµ (πk→µ (s)) = fµ (πk→µ (s0 )).
These relations are all equivalence relations and s ∼µ s0 implies that s ∼ν s0 for ν < µ; hence the relations introduce finer and finer partitions of S k . We denote by Σµ the set of equivalence classes of S k under ∼µ , i.e., each Σµ contains subsets of S k whose disjoint union forms S k . That the event E0 holds is equivalent to the fact that ∀j[f0 (πk→0 (sj )) = 0] ∨ ∀j[f0 (πk→0 (sj )) = 1] , or, equivalently, that (s1 , . . . , sk ) ∈ ∪σ∈Σ0 σ k . Similarly, the fact that E0 , . . . , Ei−1 holds is equivalent to the fact that (sµ , . . . , sk ) ∈ ∪σ∈Σµ σ k−µ+1 holds for all µ (0 ≤ µ ≤ i − 1). Using the fact that the Σµ are finer and finer partitions of S k
16
together with the fact that the underlying probability space used to compute Pr[Ei | E0 , . . . , Ei−1 ] is the independent and uniform selection of si , . . . , sk , we can write [ k−i+1 Pr[Ei | E0 , . . . , Ei−1 ] = Pr Ei (si , . . . , sk ) ∈ σ . σ∈Σi−1
Using the law of conditional expectation twice, this last probability can be written as P k−i+1 }] Pr[(s , . . . , s ) ∈ σ k−i+1 ] i k σ∈Σi−1 Pr[Ei | {(si , . . . , sk ) ∈ σ , k−i+1 Pr[(si , . . . , sk ) ∈ ∪σ∈Σi−1 σ ] where we also used that since Σi−1 is a partition of S k , the events {(si , . . . , sk ) ∈ σ k−i+1 } are disjoint. Note that since P k−i+1 ] σ∈Σi−1 Pr[(si−1 , . . . , sk ) ∈ σ =1 Pr[(si−1 , . . . , sk ) ∈ ∪σ∈Σi−1 σ k−i+1 ] it suffices to lower bound Pr[Ei | {(si−1 , . . . , sk ) ∈ σ k−i+1 }] by 2i−k for each fixed σ ∈ Σi−1 . Such a bound, however, follows straightforwardly by the observation that the underlying probability distribution on (si , . . . , sk ) is a product distribution. Then the condition (si , . . . , sk ) ∈ σ k−i+1 gives a product distribution on σ k−i+1 . Since fi (πψ,j→i (rj )) = fi (sj ) it therefore follows that the fi (πψ,j→i (rj )) (i ≤ j ≤ k) are independent identically distributed Bernoulli random variables; hence the lower bound 2i−k on the probability follows in the same way as the lower bound on Pr[E0 ].
6
Future work: larger domains and perfect completeness
It is straightforward to extend our result to PCPs over arbitrary finite Abelian groups using the, by now, standard approach [7, 8, 10]. H˚astad and Khot [11] proved results similar to those of Samorodnitsky and Trevisan [14] but for the case when the verifier has completeness 1 rather than 1 − ε. In particular, they provide a protocol that iterates a basic test involving four free and one non-free bit, the entire test queries 4k + k 2 bits and has soundness 2 2−k . They also provide an adaptive protocol, i.e., a protocol where the verifier’s queries may depend on the answers to earlier queries, that queries 2k + k 2 bits and 2 has soundness 2−k . It seems that those results can also be adapted with reasonable straightforward but rather tedious calculations to our setting, the main complication 2 being the adaptive protocol with 2k + k 2 queries and soundness 2−k . An interesting direction for future research is to try to construct a PCP with perfect completeness that iterates a predicate with fewer free bits but still only one non-free bit. If such a predicate were found and combined with the techniques of this paper,√it could potentially give results comparable to ours—we query ap2 proximately 2k + k 2 bits to get soundness 2−k —but with perfect rather than near-perfect completeness. 17
References 1. Sanjeev Arora, Carsten Lund, Rajeev Motwani, Madhu Sudan, and M´ari´o Szegedy. Proof verification and the hardness of approximation problems. Journal of the ACM, 45(3):501–555, May 1998. 2. Sanjeev Arora and Shmuel Safra. Probabilistic checking of proofs: A new characterization of NP. Journal of the ACM, 45(1):70–122, January 1998. 3. Mihir Bellare, Oded Goldreich, and Madhu Sudan. Free bits, PCPs and non-approximability— towards tight results. SIAM Journal on Computing, 27(3):804–915, June 1998. 4. Mihir Bellare and Madhu Sudan. Improved non-approximability results. In Proceedings of the Twenty-Sixth Annual ACM Symposium on the Theory of Computing, pages 184–193. Montr´eal, Qu´ebec, Canada, 23–25 May 1994. 5. Manuel Blum, Michael Luby, and Ronitt Rubinfeld. Self-testing/correcting with applications to numerical problems. Journal of Computer and System Sciences, 47(3):549–595, December 1993. 6. Irit Dinur, Venkatesan Guruswami, Subhash Khot, and Oded Regev. A new multilayered PCP and the hardness of hypergraph vertex cover. In Proceedings of the 35th Annual ACM Symposium on Theory of Computing, pages 595–601. San Diego, California, 9–11 June 2003. 7. Lars Engebretsen. The non-approximability of non-Boolean predicates. Accepted for publication in SIAM Journal on Discrete Mathematics. 8. Lars Engebretsen and Jonas Holmerin. Three-query PCPs with perfect completeness over nonBoolean domains. In Proceedings of the 18th IEEE Conference on Computational Complexity, ˚ pages 284–299. IEEE, Arhus, 7–10 July 2003. 9. Uriel Feige. A threshold of ln n for approximating set cover. Journal of the ACM, 45(4):634– 652, July 1998. 10. Johan H˚astad. Some optimal inapproximability results. Journal of the ACM, 48(4):798–859, July 2001. 11. Johan H˚astad and Subhash Khot. Query efficient PCPs with perfect completeness. In 42nd Annual Symposium on Foundations of Computer Science, pages 610–619. IEEE, Las Vegas, Nevada, 14–17 November 2001. 12. Johan H˚astad and Avi Wigderson. Simple analysis of graph tests for linearity and PCP. Random Structures and Algorithms, 22(2):139–160, March 2003. 13. Ran Raz. A parallel repetition theorem. SIAM Journal on Computing, 27(3):763–803, June 1998. 14. Alex Samorodnitsky and Luca Trevisan. A PCP characterization of NP with optimal amortized query complexity. In Proceedings of the Thirty-Second Annual ACM Symposium on Theory of Computing, pages 191–199. Portland, Oregon, 21–23 May 2000. 15. Madhu Sudan and Luca Trevisan. Probabilistically checkable proofs with low amortized query complexity. In 39th Annual Symposium on Foundations of Computer Science, pages 18–27. IEEE, Palo Alto, California, 8–11 November 1998. 16. Luca Trevisan. Parallel approximation algorithms by positive linear programming. Algorithmica, 21(1):72–88, May 1998. 17. Luca Trevisan. Recycling queries in PCPs and in linearity tests. In Proceedings of the Thirtieth Annual ACM Symposium on Theory of Computing, pages 299–308. Dallas, Texas, 23–26 May 1998.
18
k
h h−1
`
1 0
Figure 1. A pictorial view of the layered PCP construction. The dashed squares represent variables from V , the other squares represent variables from Φ. In the proof of Theorem 4 all coordinates but the one between the two dashed lines are fixed.
πvj φj
πvi+1 φi+1
Figure 2. Construction of the projection function πψ,j→i using the coordinatewise projection functions πvi+1 φi+1 , . . . , πvj φj . The dashed squares represent variables from R, the other squares represent variables from S.
`
h
Figure 3. Definition of ` and h in the proof of Lemma 2 given a set S of points (i, j) where 0 ≤ i < j ≤ k.
19
More Efficient Queries in PCPs for NP and Improved Approximation Hardness of Maximum CSP
Lars Engebretsen
Jonas Holmerin
TRITA-NA-0409
Lars Engebretsen; Jonas Holmerin More Efficient Queries in PCPs for NP and Improved Approximation Hardness of Maximum CSP Report number: TRITA-NA-0409 Publication date: April 2004 E-mail of author: [email protected]
Reports can be ordered from: Numerical Analysis and Computer Science (NADA) Royal Institute of Technology (KTH) SE-100 44 Stockholm SWEDEN telefax: +46 8 790 09 30 http://www.nada.kth.se/
More Efficient Queries in PCPs for NP and Improved Approximation Hardness of Maximum CSP Lars Engebretsen and Jonas Holmerin Department of Numerical Analysis and Computer Science Royal Institute of Technology SE-100 44 Stockholm SWEDEN E-mail: {enge,joho}@kth.se April 2004
Abstract. In the PCP model, a verifier is supposed to probabilistically decide if a given input belongs to some language by posing queries to a purported proof of this fact. The probability that the verifier accepts an input in the language given a correct proof is called the completeness c; the probability that the verifier rejects an input not in the language given any proof is called the soundness s. For a verifier posing q queries to the proof, the amortized query complexity is defined by q/ log2 (c/s) if the proof is coded in binary. It is a measure of the average “efficiency” of the queries in the following sense: An ideal query should preserve the completeness and halve the soundness. If this were the case for all queries, the amortized query complexity would be exactly one. Samorodnitsky and Trevisan [STOC 2000] gave a q-query PCP for NP with amor√ tized query complexity 1+2/ q +ε for any constant ε > 0. In this paper, we examine to what extent their result can be sharpened. Using the layered label cover problem recently introduced by Dinur et al. [STOC 2003], we devise a new “outer verifier” that allows us to construct an “inner verifier” that uses the query bits more efficiently than earlier verifiers. This enables us to construct a PCPpfor NP that queries q positions in the proof and has amortized query complexity 1 + 2/q + ε. As an immediate corollary, we also obtain an improved hardness of approximation result for the Maximum q-CSP problem. Since the improvement compared to previous work is moderate, we then examine if there is an underlying reason for this. Our construction in this paper follows a paradigm for query efficient PCPs for NP outlined by many previous researchers and it combines a state-of-the-art “outer verifier” with a natural candidate for a query efficient “inner verifier”. We prove in this paper that all natural attempts to construct more query efficient versions of our verifier are doomed to fail. This implies that significantly new ideas regarding proof composition and encoding of PCP proofs are required to construct PCPs for NP that are more query efficient than the one we propose in his paper.
1
1
Introduction
For more than a decade, one of the most powerful techniques for proving approximation hardness results for various types of discrete optimization problems, in particular constraint satisfaction problems, has been the use of Probabilistically Checkable Proofs (PCPs) for NP. In the PCP model, the verifier is given an input and oracle access to an alleged proof of the fact that the input belongs to some specified language. The verifier also has access to a specified amount of random bits. Based on the random bits and the input, the verifier decides which positions in the proof it should look at. Once it has examined the positions of its choice, it uses all available information to decide if the input should be accepted or rejected. The PCP theorem [1] asserts the startling fact that any language in NP can be probabilistically checked by a verifier that uses logarithmic randomness, always accepts a correct proof of an input in the language, accepts proofs of inputs not in the language with probability at most 1/2, and examines a constant number of bits of the proof. The probability that the PCP verifier accepts a correct proof of an input in the language is called the completeness c, while the probability that the verifier accepts any proof of an input not in the language is called the soundness s. It is generally desirable to have c ≈ 1 and s as small as possible. PCPs using a logarithmic number of random bits can be used to prove approximation hardness results for many combinatorial optimization problems. In particular, PCPs querying a small number of bits, say q bits, are intimately connected with Boolean q-ary constraint satisfaction problems: Strong approximation hardness results follow immediately from such PCPs with high completeness and low soundness. H˚astad’s approximation hardness result for linear equations mod 2 gives such a characterization [10]: The verifier in his PCP for NP queries three bits, has completeness 1 − ε and soundness 1/2 + δ for arbitrary ε and δ. Allowing the verifier to make more queries to the proof is a natural way to lower the soundness even further; independent repetition of H˚astad’s protocol k times gives a PCP that queries 3k bits, has completeness at least 1 − kε and soundness at most (1/2 + δ)k . Hence the soundness goes down exponentially fast with the number of bits read from the proof. The purpose of this paper is to study exactly how fast the soundness can go down. There are several possible measures of “fast” in this context. One is the so called amortized query complexity: For a PCP with q queries, the amortized query complexity is defined as q¯ = q/ log(c/s). The task of constructing PCPs for NP with low amortized query complexity—as well as the related question of testing if a function is linear—has been explored previously, most notably in a sequence of papers by Trevisan with different coauthors [17, 15, 14]. The key idea in those papers is to use dependent repetitions of H˚astad’s basic protocol. The technical part of the argument then boils down to showing that this dependence does not destroy the soundness of the verifier. In this paper, we adapt and extend these previous ideas. In particular, we show that the idea of using dependent repetitions can be combined with the recently introduced layered label cover problem [6]. 2
1.1
Query-efficient verification of NP
Another important efficiency measure for PCPs is the free bit complexity: A PCP has free bit complexity f if there are, for every outcome of the random bits used by the verifier, at most 2f possible answers to the verifier’s queries that make the verifier accept. Using the free bit complexity, our first main result in this paper can be written as follows: Theorem 1. For any integer f ≥ 2, any positive integer t ≤ f (f − 1)/2, and any constant ε > 0, there is a PCP for NP with free bit complexity f, query complexity f + t, completeness 1 − ε, and soundness 2−t + ε. To compare this with the previously best known result, due to Samorodnitsky and Trevisan [14], it is instructive to cast this result in terms of the amortized query complexity as a function of the number of queries: Corollary 1. For any integer q ≥ 3 and any constant ε > 0, there p is a PCP for NP with query complexity q and amortized query complexity 1 + 2/q + ε. Writing the soundness of our PCP as a function of the number of queries, we also get as an immediate corollary of our main result an improved approximation hardness result for the q-CSP problem: Corollary 2. For √ any integer q ≥ 3, it is NP-hard to approximate the q-CSP prob2q−2−1/2 . q− lem within 2 The previously best known construction, due to Samorodnitsky and Trevisan [14] √ gives amortized √ query complexity 1 + 2/ q + ε and hardness of approximation within 2q−2 q+1+1 . While our improvements might at first seem moderate, we remark that it is possible to approximate the q-CSP problem within 2q−1 in polynomial time and that a PCP for NP cannot have amortized query complexity 1 + 1/(q − 1) unless P = NP; this follows from Trevisan’s approximation algorithm for q-CSP [16]. Hence the only possible further improvements, unless P = NP, along this line of research concern the lower order term in q¯ and the lower term in the exponent of the approximation factor—where we get an improvement by a √ factor of 2. Our second main result in this paper is that there seems to be an underlying reason for why our improvement compared to previous work is moderate. Our construction in this paper follows a paradigm for query efficient PCPs for NP outlined by many previous researchers: On a high level, it combines a state-of-the-art “outer verifier” corresponding to a so called “layered label cover problem” with a corresponding “inner verifier” that is more query efficient than previously known verifiers. There are natural ways to extend this inner verifier in certain ways to produce what, at first, looks like even more query efficient verifiers. We prove in § 5, however, that all such extensions give verifiers that are less query efficient than our proposed verifier in the sense that the new verifiers have the same soundness as our verifier but pose more queries. This implies that significantly new ideas regarding 3
proof composition and encoding of PCP proofs are required to construct PCPs for NP that are more query efficient than the one we propose in his paper. Driven by the desire to prove strong inapproximability results for Maximum Clique another measure, the amortized free bit complexity, was introduced [4]. Recall that a PCP has free bit complexity f if there are, for every outcome of the random bits used by the verifier, at most 2f possible answers to the verifier’s queries that make the verifier accept. The amortized free bit complexity is then defined as f¯ = f / log(c/s). The intuition behind the term free bit complexity is that a typical verifier with free bit complexity f first reads f bits, the so called “free bits”, from the proof and then performs a number of consistency checks, each involving some of the free bits and some new positions in the proof. The PCP constructed by Samorodnitsky and Trevisan [14] has a verifier that first queries 2k free bits and then makes k 2 consistency checks, each of which uses two (different) free bits and one unique non-free bit. Hence the verifier queries in total 2k + k 2 bits and it can be shown that the test has completeness 1 − ε 2 and soundness 2−k + ε. It follows that the amortized query complexity can be written as 1 + 4/f + ε where f is the number of free bits used by the verifier. Under the assumption that the verifier first queries some free bits and then performs consistency checks involving two free bits where the same two free bits are present in at most one consistency check, the amortized query complexity cannot be lower than 1 + 2/(f − 1). Our construction in this paper achieves this goal. Corollary 3. For any integer f ≥ 2 and any constant ε > 0, there is a PCP for NP with free bit complexity f and amortized query complexity 1 + 2/(f − 1) + ε. Hence it is optimal among the PCPs that work as described above. One natural suggestion to improve the soundness is to perform consistency checks not only on pairs of free bits but on all possible subsets of free bits. In their paper [14], Samorodnitsky and Trevisan show that such an approach is fruitless for the related problem of linearity testing. In that setting, the “proof” is a table of a Boolean function and “consistency” simply means that this table respects linearity. For the more complex situation involving PCPs for NP with several tables defining different functions that should be correlated in some way, there is no known corresponding result. As mentioned above, the second main result in this paper is an optimality result. In the above language, this result shows that it is impossible to beat the soundness bounds stated above even with a verifier that tests consistency induced not only by pairs of free bits but by all possible Boolean predicates on the free bits. Since all hitherto constructed PCPs with low amortized query complexity work in this way, our result shows that to construct PCPs with even lower amortized query complexity, radically new ideas are needed.
1.2
Main sources of our improvements
Our paper uses the fundamental idea of “recycling” query bits in linearity tests and PCPs, introduced and explored in a sequence of papers authored by Trevisan with 4
different coauthors. For linearity tests, the construction is founded on the basic BLR linearity test [5] that selects random x and y and tests if f (x)f (y) = f (xy). Trevisan [17] introduced the notion of a graph test iterating the basic BLR test once for every edge in the graph: Each variable in the graph corresponds to a randomly selected value and for each edge {x, y} the test f (x)f (y) = f (xy) is executed. These tests are, of course, dependent, but Trevisan [17] was able to show that they still behave essentially as independent tests for some graphs. He also used similar ideas to construct a PCP for NP with q¯ = 2.5 + ε. Extending the analysis, both for linearity tests and PCPs, Sudan and Trevisan [15] constructed a PCP for NP with q¯ = 1.5 + 3/(q − 2) + ε, and, finally, Samorodnitsky and Trevisan [14] constructed √ the PCP for NP mentioned above, with q¯ = 1 + 2/ q + ε. Our main source of improvement is that we use a layered label cover problem recently introduced by Dinur et al. [6] as our underlying NP-hard problem. While our construction of the label cover instance is exactly the same as used by Dinur et al., we need in this paper a stronger hardness result than they state in their paper. We also use a new way to connect this layered label cover problem—or “outer verifier” as it is often called in PCP jargon—with the actual PCP—or “inner verifier”. Loosely speaking, while previous constructions checked pairwise consistency between pairs (W0 , Wi ) of proof tables for some number of Wi :s, our use of the layered label cover problem as an outer verifier enables us to devise an inner verifier that tests pairwise consistency between all pairs (Wi , Wj ). On a slightly more concrete level, the Samorodnitsky-Trevisan verifier queries k free bits in the table W0 and then one free bit in each of the tables Wi . But it does not use all possible pairs of free bits for consistency checks, only (roughly) half of them. The intuitive reason why our construction is more efficient with respect to the free bits is that we check pairwise consistency between tables (Wi , Wj ) by first querying one free bit from each table and then using all pairs of free bits for a consistency check. H˚astad and Wigderson [12] have presented a much simplified analysis of the Samorodnitsky-Trevisan PCP; we use the same kind of analysis in this paper.
2
Background
Our construction, as most other PCP constructions, use the powerful technique of proof composition, introduced by Arora and Safra [2]. The main idea in such constructions is to combine two verifiers that optimize different type of parameters into one verifier that optimizes both parameters. In particular, it is common to use an “outer verifier” that queries a proof containing values from some large domain and an “inner verifier” whose proof contains purported answers to the outer verifier encoded with some error correcting code. To get an intuitive understanding of both our construction and earlier related constructions, it is instructive to recall a high-level description of H˚astad’s PCP
5
for NP with three queries—two of which are free—completeness 1 − ε and soundness 1/2 + ε [10]. The outer verifier used by H˚astad can be described in several different ways. While H˚astad describes it in terms of a two-prover one-round protocol for a certain class of 3-Sat formulae, we chose one of the alternate formulations: a label cover problem with a certain “gap” property. Definition 1. Given two sets R and S, an instance of the label cover problem on R and S is a set Ψ ⊆ V × Φ, where V and Φ are sets of variables with ranges R and S, respectively, with an onto function πvφ : S → R for every (v, φ) ∈ Ψ . The instance is regular if every v ∈ V occurs in the same number of pairs in Ψ and every φ ∈ Φ occurs in the same number of pairs in Ψ . The following theorem is a consequence of the PCP theorem [1] combined with a certain regularization procedure [9] and the parallel repetition theorem [13]. Theorem 2 [1, 9, 13]. There exists a universal constant µ > 0 such that for every large enough constant u there exist sets R and S with 2u ≤ |R| ≤ |S| ≤ 7u such that it is NP-hard to distinguish between the following two cases given a regular instance Ψ ⊆ V × Φ of a label cover problem on R and S: YES: There exist assignments ΠV : V → R and ΠΦ : Φ → S such that for every (v, φ) ∈ Ψ , ΠV (v) = πvφ (ΠΦ (φ)). NO: There are no assignments ΠV : V → R and ΠΦ : Φ → S such that for more than a fraction |R|−µ of the pairs (v, φ) ∈ Ψ , ΠV (v) = πvφ (ΠΦ (φ)). A regular label cover problem Ψ on (V, R) and (Φ, S) can be viewed as a bi-regular bipartite graph with the node set V ∪. Φ and an edge {v, φ} for every (v, φ) ∈ Ψ . The objective is then to assign labels to the nodes in such a way that for every edge {v, φ}, the constraint ΠV (v) = πvφ (ΠΦ (φ)) holds. The above theorem says that it is NP-hard to distinguish the case when this is possible from the case when it is only possible to satisfy a tiny fraction of the constraints. The inner verifier in H˚astad’s PCP has access to several sub-tables: one for each v ∈ V and one for each φ ∈ Φ. These tables contain purported encodings of the labels assigned to the corresponding variable/vertex. The labels are encoded by the so called long code, first used in the context of PCPs by Bellare, Goldreich and Sudan [3]. The long code Aw,σ of an assignment/label σ to some variable/vertex w assuming values in some set R is a function mapping f ∈ {−1, 1}R to a value in {−1, 1} by the map Aw,σ (f ) = f (σ). To check the proof, H˚astad’s inner verifier essentially selects a random (v, φ) ∈ Ψ , random functions f and g and then checks if Av (f )Aφ (g) = Aφ (fg). (The test is actually slightly more complicated. In fact, the test as written above does not quite work, but we ignore this here, and for the rest of this section, for the sake of clarity.) There are two important points to note here: 1) There are two free queries, Av (f ) and Aφ (g), and one “check”, Aφ (fg). 2) The queries involve tables of two types, one v-table and one φ-table. Trevisan put forward the idea that the free queries could be “recycled”. In his first paper [16], he recycled the query Aφ (g) and made two checks: Av (f1 )Aφ (g) = 6
Aφ (f1 g) and Av (f2 )Aφ (g) = Aφ (f2 g). These checks are dependent, but it turns out that the dependence is weak enough to give soundness 1/4 + ε at the price of 3 free and 2 non-free queries. Hence this construction has amortized query complexity 2.5 + ε. Sudan and Trevisan [15] extended the analysis by using a modification of the outer verifier: From an instance Ψ ⊆ V × Φ of the basic label cover problem, a modified label cover instance is constructed as follows: The instance consists of all tuples (v, φ1 , . . . , φk ) such that (v, φj ) ∈ Ψ for all j; denote by Ψ˜ this set of tuples. The objective is then to construct labelings ΠV and ΠΦ , respectively, of V and Ψ , respectively, such that for all (v, φ1 , . . . , φk ) ∈ Ψ˜ , the constraint ΠV (v) = πvφj (ΠΦ (φj )) holds for every j. Sudan and Trevisan show in their paper that it is NP-hard to distinugish the case when this is possible from the case when it holds for at most a tiny fraction of the tuples in Ψ˜ that ΠV (v) = πvφj (ΠΦ (φj )) for some j. More formally, their theorem can be stated as follows: Theorem 3 [15]. There exists a universal constant µ > 0 such that for every large enough constant u there exist sets R and S with 2u ≤ |R| ≤ |S| ≤ 7u such that it is NP-hard to distinguish between the following two cases given an instance Ψ ⊆ V × Φ of a regular label cover problem on R and S: YES: There exist assignments ΠV : V → R and ΠΦ : Φ → S such that for every (v, φ1 , . . . , φk ) such that (v, φi ) ∈ Ψ for every i, ΠV (v) = πvφi (ΠΦ (φi )) for every i. NO: There are no assignments ΠV : V → R and ΠΦ : Φ → S such that for more than a fraction |R|−µ of the tuples (v, φ1 , . . . , φk ) such that (v, φi ) ∈ Ψ for every i, ΠV (v) = πvφi (ΠΦ (φi )) for some i. (We remark that Sudan and Trevisan called their construction a “k-outer verifier”; they did not use the term “label cover”.) Using this new outer verifier, Sudan and Trevisan [15] were able to analyze an inner verifier that selects random functions f1 , f2 and g1 , . . . , gk , and then checks Av (fi )Aφj (gj ) = Aφj (fi gj ) for all i and j. This gives amortized query complexity 1.5 + ε. Finally, Samorodnitsky and Trevisan [14], using the same outer verifier, were able to analyze the even more general case where the verifier selects v and φ1 , . . . , φk as above, random functions f1 , . . . , fk and g1 , . . . , gk and then checks Av (fi )Aφj (gj ) = Aφj (fi gj ) for all i and j. This construction gives amortized query complexity 1 + ε.
3
A multi-layered label cover problem
The outer verifier devised by Sudan and Trevisan [15] has the property that one v and several φj connected to v are used. There is one “check” for every pair (f, g) of free queries where f is queried from table Av and g is queried from table Aφj . Hence, all of the above constructions check pairwise consistency between the same node v and several nodes φj connected to v in the underlying label cover instance. Our main idea to push the “recycling” further is to instead select k + 1 nodes from 7
a tailored label cover instance in such a way that we can check pairwise consistency between every pair of nodes. This tailored label cover instance was recently devised by Dinur et al. [6] and used by them to prove strong approximation hardness results for hypergraph vertex cover. For our application we prove a slightly stronger “gap” property than they needed. The difference is somewhat technical, but we believe that the ideas in our, stronger, hardness result may be of further use. Recall that the objective of the label cover problem on R and S is to assign to nodes in V labels from R and to nodes in Φ labels from S in such a way that many edges are “satisfied” in the sense that the corresponding projections {πvφ }(v,φ)∈Ψ are satisfied. Our layered label cover problem is similar in spirit, but the instance has more structure. It can be viewed as a k-wise parallel repetition of the original label cover problem but with the objective to construct certain “hybrid” labelings. Given an instance Ψ of the basic label cover problem from Definition 1 we construct a corresponding instance of our layered label cover problem as all k-tuples of elements from Ψ ; hence the instance is simply the k-wise Cartesian product Ψ k and some arbitrary ψ ∈ Ψ k can be written as ψ = ((v1 , φ1 ), . . . , (vk , φk )). In an “ordinary” k-wise parallel repetition the goal would be to construct an assignment to all k-tuples (v1 , . . . , vk ) ∈ V k and an assignment to all k-tuples (φ1 , . . . , φk ) ∈ Φk in such a way that the assignments are consistent, where “consistent” means that each coordinate satisfies the corresponding projection πvj φj from the basic label cover problem. The goal in our layered label cover problem is to construct in total k + 1 assignments: not only one assignment to tuples in V k and one assignment to tuples in Φk , but also k − 1 “hybrid” assignments to “hybrid“ tuples of the form (φ1 , . . . , φt , vt+1 , . . . , vk ) ∈ Φt × V k−t ; see Figure 1. We say that a tuple belongs to layer t if the first t coordinates of the tuple contain values from Φ and the remaining coordinates contain values from V . With this notation, layer 0 corresponds to tuples containing only variables from V , layer k corresponds to tuples containing only variables from Φ, and each ψ ∈ Ψ k corresponds to k + 1 tuples, one in each layer. (Readers very familiar with the presentation of the layered verifier in [6] may want to notice that what we call a tuple corresponding to ψ ∈ Ψ k corresponds to a clique in the multi-partite graph defined in the proof of Theorem 3.3 in [6].) Write ψ = ((v1 , φ1 ), . . . , (vk , φk )) and consider the tuples corresponding to ψ. Assignments to these tuples produce tuples of values from R (values to V -variables) and S (values to Φ-variables). There is an obvious way to require consistency between these assignments. For two tuples (φ1 , . . . , φi , vi+1 , . . . , vk ) and (φ1 , . . . , φj , vj+1 , . . . , vk ) where i < j and cor0 responding assignments (s1 , . . . , si , ri+1 , . . . , rk ) and (s01 , . . . , s0j , rj+1 , . . . , rk0 ), we use the projections πvφ from the basic label cover instance to define what it means for the assignments to be consistent: st = s0t (t ≤ i) and rt = πvt φt (s0t ) (i < t ≤ j) and rt = rt0 (t > j); see Figure 2. Definition 2. Given R, S, V , Φ, Ψ , and {πvφ }(v,φ)∈Ψ as in Definition 1, denote an arbitrary ψ ∈ Ψ k by the vector ((v1 , φ1 ), . . . , (vk , φk )) and define the shorthand πψ,j→i : S j × Rk−j → S i × Rk−i as the map (s1 , . . . , sj , rj+1 , . . . , rk ) 7→ 8
(s1 , . . . , si , πvi+1 φi+1 (si+1 ), . . . , πvj φj (sj ), rj+1 , . . . , rk ). The objective of our label cover problem is to produce k + 1 assignments such that all constraints πψ,j→i are satisfied. It is straightforward to see that if the case “YES” from Theorem 2 holds for the original instance Ψ , the assignments ΠV and ΠΨ guaranteed in this case can be used to construct such assignments. In our application, we need a somewhat non-standard formulation of the “NO” case for our layered label cover. Specifically, we allow non-standard assignments. Normally, an assignment to some set W of variables is a function from W to the set of possible values for the variables. With this approach, a “standard” assignment to a tuple from layer t would then be a function from Φt × V k−t to S t × Rk−t . For the application to PCP:s we need an extended notion of assignments where the assignment function creating labels to a layer t tuple is allowed to use some information that is present in tuples from other layers. Formally, we need that there are no layers ` and h, where ` < h, such that there are “assignments” Π` and Πh with the property that for some fraction of the tuples ψ ∈ Ψ k , it holds that Π` (φ1 , . . . , φh−1 , v1 , . . . , vk ) = πψ,h→` Πh (φ1 , . . . , φk , vh+1 , . . . , vk ) . (1) Consider a ψ ∈ Ψ k and the corresponding k +1 tuples defined above. In words, the above equation states that the function producing labels for the tuple in layer ` is allowed to use the information present in all tuples in layers 0 to h−1; similarly, the function producing labels for the tuple in layer h is allowed to use the information present in all tuples in layers h to k. We can now formulate the hardness result that serves as a starting point for our PCP construction. Theorem 4. There exists a universal constant µ > 0 such that for every large enough constant u and every integer k > 0 there exist sets R and S with 2u ≤ |R| ≤ |S| ≤ 7u such that it is NP-hard to distinguish between the following two cases given an instance Ψ ⊆ V × Φ of a regular label cover problem on R and S: YES: There exist assignments Πi : Φi × V k−i → S i × Rk−i (0 ≤ i ≤ k) such that for all ψ ∈ Ψ k and all i and j (0 ≤ i < j ≤ k) it holds that Πi (φ1 , . . . , φi , vi+1 , . . . , vk ) = πψ,j→i Πj (φ1 , . . . , φj , vj+1 , . . . , vk ) , where {vi }ki=1 , {φi }ki=1 , and {πψ,j→i }0≤i<j≤k are defined from ψ as in Definition 2. NO: There are no two integers ` and h (0 ≤ ` < h ≤ k) such that there exist functions P` from Φh−1 × V k to probability distributions on S ` × Rk−` and Ph from Φk × V k−h to probability distributions on S h × Rk−h with the property that 1 X Prr∼P` (φ1 ,...,φh−1 ,v1 ,...,vk ) [r = πψ,h→` (s)] ≥ |R|−µ , |Ψ k | s∼Ph (φ1 ,...,φk ,vh+1 ,...,vk ) k ψ∈Ψ
where {vi }ki=1 , {φi }ki=1 , and πψ,h→` are defined from ψ as in Definition 2. Proof. If there are assignments satisfying property YES in Theorem 2, the same assignments applied coordinate-wise satisfy property YES in this theorem. For 9
the converse, we prove that if property NO in this theorem is violated, then property NO in Theorem 2 is also violated. Hence assume that there are ` and h and families of probability distributions such that property NO in this theorem is violated. A straightforward derandomization using the method of conditional probabilities then shows that there exist functions Π` : Φh−1 × V k → S ` × Rk−` and Πh : Φk × V k−h → S h × Rk−h with the property that equation (1) holds for a fraction at least |R|−µ of the tuples ψ ∈ Ψ k . Consider the partition on Ψ k induced by the equivalence relation “all coordinates but the hth one are equal”. Clearly, there must exist some equivalence class such that the above equality holds for at least a fraction |R|−µ of the ψ in that equivalence class, i.e., for a fraction |R|−µ of the values of the hth coordinate. Define assignments ΠV : V → R and ΠΦ : Φ → S by the hth coordinate of Π` and Πh , respectively, restricted to that particular equivalence class. Since equation (1) is satisfied for a fraction at least |R|−µ of the values of the hth coordinate, coordinate h of the equality must be satisfied for a fraction at least |R|−µ of the values of the hth coordinate. In other words, ΠV (v) = πvφ (ΠΦ (φ)) for at least a fraction |R|−µ of the (v, φ) ∈ Ψ . We remark that the above proof is very similar to the proof presented by Dinur et al. [6]. Hence, the new contribution in terms of variants of the label cover problem in this paper is not the proof, but rather the precise formulation of the hardness result in Theorem 4. The difference is quite subtle and concerns the NO case above. In the hardness result formulated by Dinur et al. [6], their equivalent of the function P` above is only allowed to depend on layer ` and its task is to describe assignments to the variables in that layer (for a pictorial view of the layered PCP, see Fig. 1). Similarly, the function Ph is only allowed to depend on layer h and its task is to describe assignments to the variables in that layer. By contrast, the function P` is in our setting allowed to use information from all layers up to, and including, layer h−1. And the function Ph is in our case allowed to use information from layers h to k. This could potentially give more power to a malicious prover, but it turns out that the proof provided by Dinur et al. [6] can easily be adapted to cover also this new setting. We also allow probabilistic assignments in the “NO” case in our theorem, whereas Dinur et al. [6] only allow deterministic ones. It is, however, well known that this does not make the theorem stronger; we use the probabilistic formulation since we need it in the application of the theorem.
4
A recycling PCP
We now describe a verifier with access to several proof tables, each containing a purported encoding of a label for a node in the layered label cover instance. The verifier bases its decision to accept or reject on some carefully selected values from tables corresponding to the nodes created from some ψ ∈ Ψ k as described in § 3. The main properties of the verifier can loosely be described as follows: 1) If case 10
“YES” in Theorem 4 holds, there exists a proof that makes the verifier accept with high probability; 2) If case “NO” in Theorem 4 holds, the PCP verifier accepts with very small probability.
4.1
The proof
The proof in our PCP contains for each i (0 ≤ i ≤ k) and each w ∈ Φi × V k−i a i k−i table Aw of size 2|S| |R| which should be interpreted as the values of a function i k−i from {−1, 1}S ×R to {−1, 1}. For such a w and some function f : S i × Rk−i → {−1, 1}, Aw (f ) denotes the position in table Aw corresponding to f. Definition 3. Given R, S, V , Φ, Ψ , and an arbitrary ψ ∈ Ψ k , define Aψ,i to be the table Aw where w ∈ Φi × V k−i is defined from ψ = ((v1 , φ1 ), . . . , (vk , φk )) as the k-tuple where position t contains φt if t ≤ i and vt if t > i. We remark here, that a function f: S i × Rk−i → {−1, 1} can be used to index into Aw for any w ∈ Φi × V k−i . This simplifies our analysis below. Also, all tables are assumed to be folded, i.e., Aw (f ) = −Aw (−f ) for all w and f; this property can be enforced by certain access conventions in the verifier. Our only need for folding comes from the fact that certain Fourier coefficients of the tables in the proof are guaranteed to vanish for folded tables; see H˚astad’s paper [10, §§ 2.4–2.6] for details.
4.2
The verifier
The verifier is parameterized by a rational ε > 0, an integer k > 0 and a non-empty subset P of {(i, j) : 0 ≤ i < j ≤ k}. The actions of the verifier are follows: 1. Select ψ ∈ Ψ k uniformly at random. 2. Select fi : S i × Rk−i → {−1, 1} (0 ≤ i ≤ k) independently uniformly at random. 3. Select functions eij : S j × Rk−j → {−1, 1} for each (i, j) ∈ P by selecting eij (x) independently at random to be 1 with probability 1 − ε and −1 otherwise. 4. Accept if Aψ,i (fi )Aψ,j (fj ) = Aψ,j ((fi ◦ πψ,j→i )fj eij ) for every (i, j) ∈ P ; reject otherwise. Here, πψ,j→i is defined as described in Definition 2 and Aψ,i is defined as in Definition 3. Before embarking on the analysis of the soundness of the verifier, let us note some immediate consequences of the construction. Lemma 1. The verifier has completeness at least 1 − |P |ε, query complexity |P | + k + 1, and free bit complexity k + 1. Moreover, it uses at most kdlog |Ψ |e + (k + 1)|S|k + |P ||S|k dlog ε−1 e random bits.
11
Proof. Consider a proof consisting of correct encodings of labels satisfying the “YES” case in Theorem 4. Then Aψ,i (fi ) = fi (ri ) and Aψ,j ((fi ◦ πψ,j→i )fj eij ) = fi (πψ,j→i (rj ))fj (rj )eij (rj ) = fi (ri )fj (rj )eij (rj ) where {ri }ki=0 denotes the labels to the nodes corresponding to ψ. Hence, the verifier accepts if eij (rj ) = 1 for all (i, j) ∈ P . This establishes the completeness. The other claims are verified by straightforward inspection of the protocol.
4.3
Analysis of the soundness
The acceptance predicate is arithmetized as usual: Y 1 + Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) 2
(i,j)∈P
is an indicator for the event that the verifier accepts. This expression can be rewritten as X Y 2−|P | Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ). S⊆P (i,j)∈S
If the expectation of this is at least 2−|P | +δ, there must exist some nonempty S ⊆ P such that Y E Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) ≥ δ. (2) (i,j)∈S
We now consider one such S and prove that it is possible to extract assignments violating property NO in Theorem 4 provided that the above inequality holds. The main idea in the proof of this result is to split the product inside the expectation in inequality (2) above into three parts. The Fourier transform of two of these parts are then used to devise functions P` and Ph that violate property NO in Theorem 4. The precise way to split the product is carefully chosen so that the resulting functions P` and Ph are guaranteed to depend only on certain variables, as required by Theorem 4. This is the place where our modification of the hardness result due to Dinur et al. [6] is needed. Indeed, we arrived at the formulation of our modified version of the hardness result for the layered label cover problem by the requirement that it must always be possible to split the product inside the expectation in (2) in such a way that the resulting `, h, P` , and Ph have precisely the properties needed to violate the NO case in the hardness result. Lemma 2. Suppose that a PCP is constructed as described above from an instance of the k-layered label cover problem with |R| > (ε−1 δ−2 /4)1/µ and that Y E Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) ≥ δ, (i,j)∈S
where the expectation is over the random choices of the verifier, for some nonempty S ⊆ P . Then property NO in Theorem 4 is violated. 12
Proof. Define h = max{j : ∃i(i, j) ∈ S} and ` = min{i : (i, h) ∈ S}. Since the choice of the functions {fi }ki=0 and {eij }0≤i<j≤k is independent of the choice of ψ, there exist functions fi for i 6∈ {`, h} and functions eij for (i, j) 6= (`, h) such that the expectation over f` , fh , e`h and ψ is at least δ. Fix such functions for the remainder of the analysis. We now rewrite the expectation as Y Eψ Ef` ,fh ,e`h Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) (i,j)∈S
and analyze the inner expectation above by splitting the product into three groups. The first group contains the only factor depending on e`h : Aψ,h ((f` ◦ πψ,h→` )fh e`h ). The second group contains all factors corresponding to pairs depending on f` but neither on fh or e`h : Y Bψ (f` ) = Aψ,` (f` ) Aψ,i (fi )Aψ,j (fj )Aψ,j ((fi ◦ πψ,j→i )fj eij ) (i,j)∈S j δ. Applying the Cauchy-Schwartz inequality and using the fact that α Cˆ α = 1, we obtain X 2 ˆ2 2|α| ˆ E Aα Bπψ (α) (1 − 2ε) > δ2 . α
Recall that our objective is to prove that the NO case in Theorem 4 is violated. We do this by constructing probabilistic assignments that are consistent with high probability. Consider the following probabilistic procedure: Compute Aˆ α and Bˆ β and select α and β with probabilities Aˆ 2α and Bˆ β2 , respectively—this is a well-defined procedure by Plancherel’s equality. Then select a random s ∈ α—since the tables are folded, such an s always exists—and a random r ∈ β if one exists, select an arbitrary r ∈ S ` × Rk−` otherwise. It is easy to see that if β = πψ (α) 6= ∅ there is for every r ∈ β at least one s ∈ α such that πψ,h→` (α(s)) = β(r). Hence, the selected assignments are consistent with probability at least X Aˆ 2 Bˆ 2 X α πψ (α) 2 ˆ2 |α| ˆ E ≥ 4ε E Aα Bπψ (α) (1 − 2ε) > 4εδ2 , |α| α α where the inequality follows from the previous section. (There is a slight technicality here, coming from the fact that B need not be folded. However, the fact that A is folded implies that Aˆ α = 0 for all α such that πψ (α) = ∅ [10, Lemma 2.44].) But by assumption 4εδ2 > |R|−µ , hence the above assignments are consistent with probability greater than |R|−µ .
14
5
Limitations of current techniques
It is easy to see that our verifier from § 4 accepts a random proof, i.e., a proof where every location is selected uniformly at random, with probability 2−k(k+1)/2 . Hence our analysis of the PCP is tight. We prove next that it is impossible to improve the soundness of the PCP by adding additional queries of a certain form. In particular, we assume that we use the same basic outer verifier as defined above. Therefore, the inner verifier starts by selecting a ψ ∈ Ψ k uniformly at random. Next, the verifier selects positions in the k+1 tables corresponding to ψ as follows: First, one position in each table is selected by choosing functions fi : S i × Rk−i → {−1, 1} (0 ≤ i ≤ k) independently, but not necessarily uniformly, at random. To check consistency, the verifier may now make one check for every Boolean predicate b: {0, 1}k+1 → {0, 1} in the obvious way: It creates a function hb mapping x ∈ S k to b(f0 (x), . . . , fk (x)) and then checks that the value corresponding to this position in the proof is consistent with the k + 1 values corresponding to the functions fi . Here we, with slight abuse of notation, use the convention that fi (x) is defined by first projecting x so that it is in the domain of fi and then applying fi . There is, however, a slight technicality here: The are k + 1 tables corresponding to the ψ selected by the verifier, in what table should the query induced by the Boolean predicate b be resolved? The “topmost” table always works—this is what was outlined above since hb was defined as a function with domain S k . For predicates b that only depend on, say, the first s coordinates, there are more available tables. Specifically, the tables denoted by Aψ,i such that i ≥ s can be used. We allow the verifier to use all possible tables simultaneously. I.e., for predicates b that depend on the first s coordinates only, we define functions hb,s , hb,s+1 , . . . , hb,k where hb,i is a function mapping x ∈ S i × Rk−i to b(f1 (x), . . . , fi (x), 0, . . . , 0). Then, the verifier checks that the value Aψ,i (hb,i ) is consistent with the queries corresponding to f0 , . . . , fs . It is easy to see that the above verifier always accepts if it holds for all i (0 ≤ i < k) and all j (i < j ≤ k) that fi (ri ) = (fi ◦πj→i )(rj ). If all those k(k +1)/2 tests were independent, it would immediately follow that the soundness of the verifier is at least 2−k(k+1)/2 . However, the tests are not independent since the same fi appears, maybe composed with a projection function, in several different tests. Therefore, a calculation is required to establish that the probability of all k(k+1)/2 tests being simultaneously satisfied is indeed at least 2−k(k+1)/2 . Theorem 5. The verifier outlined above has soundness at least 2−k(k+1)/2 . Proof. Consider the following randomly selected proof: For each i (0 ≤ i ≤ k) and each w ∈ Φi × V k−i select an sw uniformly and independently from S k and then define Aw as the long code of πk→i (sw ). Fix an arbitrary ψ and focus on the consistency checks performed by the verifier. By assumption Aψ,i (fi ) = fi (ri ) where ri = πk→i (si ) and the si are selected independently and uniformly at random from S k . Since every table is a correct
15
long code, Aψ,i (hb,i ) = b(f0 (ri ), . . . , fs (ri ), 0, . . . , 0) for every i ≥ s. Similarly, Aψ,i (fi ) = fi (ri ). Hence, the verifier definitely accepts if it holds for all i (0 ≤ i < k) and all j (i < j ≤ k) that fi (ri ) = (fi ◦ πj→i )(rj ). Therefore, the proof follows from Lemma 3 below. Lemma 3. Given ψ ∈ Ψ k and functions fi : Ri → {0, 1} (0 ≤ i ≤ k), select si (0 ≤ i ≤ k) independently and uniformly at random from S k and define ri = πψ,k→i (si ). Under this distribution, the probability that fi (ri ) = fi (πψ,j→i (rj )) for all i (0 ≤ i < k) and all j (i < j ≤ k) is at least 2−k(k+1)/2 . Proof. By defining the event Ei = ∩kj=i+1 {fi (ri ) = fi (πψ,j→i (rj )}, the sought probability can be written as k−1 k−1 \ Y Pr[Ei | E0 , . . . , Ei−1 ]. Pr Ei = i=0
i=0
We then proceed by showing that Pr[Ei | E0 , . . . , Ei−1 ] can be lower bounded by 2i−k . This is enough to prove the lemma, since then the entire product above is lower bounded by 2−k(k+1)/2 . It is straightforward to bound Pr[E0 ]. Since f0 is a function from R0 to {0, 1} and the πj→0 (rj ) are independent identically distributed variables, f0 (πj→0 (rj )) (0 ≤ j ≤ k) are independent identically distributed Bernoulli random variables. It is well known that the probability that k + 1 such variables attain the same value is at least 2−k . To bound a general factor, we first examine the structure imposed by the condition that E0 , . . . , Ei−1 holds. Introduce the relation ∼µ defined inductively by s ∼0 s0 ⇐⇒ f0 (πk→0 (s)) = f0 (πk→0 (s0 )) and then s ∼µ s0 ⇐⇒ s ∼µ−1 s0
and
fµ (πk→µ (s)) = fµ (πk→µ (s0 )).
These relations are all equivalence relations and s ∼µ s0 implies that s ∼ν s0 for ν < µ; hence the relations introduce finer and finer partitions of S k . We denote by Σµ the set of equivalence classes of S k under ∼µ , i.e., each Σµ contains subsets of S k whose disjoint union forms S k . That the event E0 holds is equivalent to the fact that ∀j[f0 (πk→0 (sj )) = 0] ∨ ∀j[f0 (πk→0 (sj )) = 1] , or, equivalently, that (s1 , . . . , sk ) ∈ ∪σ∈Σ0 σ k . Similarly, the fact that E0 , . . . , Ei−1 holds is equivalent to the fact that (sµ , . . . , sk ) ∈ ∪σ∈Σµ σ k−µ+1 holds for all µ (0 ≤ µ ≤ i − 1). Using the fact that the Σµ are finer and finer partitions of S k
16
together with the fact that the underlying probability space used to compute Pr[Ei | E0 , . . . , Ei−1 ] is the independent and uniform selection of si , . . . , sk , we can write [ k−i+1 Pr[Ei | E0 , . . . , Ei−1 ] = Pr Ei (si , . . . , sk ) ∈ σ . σ∈Σi−1
Using the law of conditional expectation twice, this last probability can be written as P k−i+1 }] Pr[(s , . . . , s ) ∈ σ k−i+1 ] i k σ∈Σi−1 Pr[Ei | {(si , . . . , sk ) ∈ σ , k−i+1 Pr[(si , . . . , sk ) ∈ ∪σ∈Σi−1 σ ] where we also used that since Σi−1 is a partition of S k , the events {(si , . . . , sk ) ∈ σ k−i+1 } are disjoint. Note that since P k−i+1 ] σ∈Σi−1 Pr[(si−1 , . . . , sk ) ∈ σ =1 Pr[(si−1 , . . . , sk ) ∈ ∪σ∈Σi−1 σ k−i+1 ] it suffices to lower bound Pr[Ei | {(si−1 , . . . , sk ) ∈ σ k−i+1 }] by 2i−k for each fixed σ ∈ Σi−1 . Such a bound, however, follows straightforwardly by the observation that the underlying probability distribution on (si , . . . , sk ) is a product distribution. Then the condition (si , . . . , sk ) ∈ σ k−i+1 gives a product distribution on σ k−i+1 . Since fi (πψ,j→i (rj )) = fi (sj ) it therefore follows that the fi (πψ,j→i (rj )) (i ≤ j ≤ k) are independent identically distributed Bernoulli random variables; hence the lower bound 2i−k on the probability follows in the same way as the lower bound on Pr[E0 ].
6
Future work: larger domains and perfect completeness
It is straightforward to extend our result to PCPs over arbitrary finite Abelian groups using the, by now, standard approach [7, 8, 10]. H˚astad and Khot [11] proved results similar to those of Samorodnitsky and Trevisan [14] but for the case when the verifier has completeness 1 rather than 1 − ε. In particular, they provide a protocol that iterates a basic test involving four free and one non-free bit, the entire test queries 4k + k 2 bits and has soundness 2 2−k . They also provide an adaptive protocol, i.e., a protocol where the verifier’s queries may depend on the answers to earlier queries, that queries 2k + k 2 bits and 2 has soundness 2−k . It seems that those results can also be adapted with reasonable straightforward but rather tedious calculations to our setting, the main complication 2 being the adaptive protocol with 2k + k 2 queries and soundness 2−k . An interesting direction for future research is to try to construct a PCP with perfect completeness that iterates a predicate with fewer free bits but still only one non-free bit. If such a predicate were found and combined with the techniques of this paper,√it could potentially give results comparable to ours—we query ap2 proximately 2k + k 2 bits to get soundness 2−k —but with perfect rather than near-perfect completeness. 17
References 1. Sanjeev Arora, Carsten Lund, Rajeev Motwani, Madhu Sudan, and M´ari´o Szegedy. Proof verification and the hardness of approximation problems. Journal of the ACM, 45(3):501–555, May 1998. 2. Sanjeev Arora and Shmuel Safra. Probabilistic checking of proofs: A new characterization of NP. Journal of the ACM, 45(1):70–122, January 1998. 3. Mihir Bellare, Oded Goldreich, and Madhu Sudan. Free bits, PCPs and non-approximability— towards tight results. SIAM Journal on Computing, 27(3):804–915, June 1998. 4. Mihir Bellare and Madhu Sudan. Improved non-approximability results. In Proceedings of the Twenty-Sixth Annual ACM Symposium on the Theory of Computing, pages 184–193. Montr´eal, Qu´ebec, Canada, 23–25 May 1994. 5. Manuel Blum, Michael Luby, and Ronitt Rubinfeld. Self-testing/correcting with applications to numerical problems. Journal of Computer and System Sciences, 47(3):549–595, December 1993. 6. Irit Dinur, Venkatesan Guruswami, Subhash Khot, and Oded Regev. A new multilayered PCP and the hardness of hypergraph vertex cover. In Proceedings of the 35th Annual ACM Symposium on Theory of Computing, pages 595–601. San Diego, California, 9–11 June 2003. 7. Lars Engebretsen. The non-approximability of non-Boolean predicates. Accepted for publication in SIAM Journal on Discrete Mathematics. 8. Lars Engebretsen and Jonas Holmerin. Three-query PCPs with perfect completeness over nonBoolean domains. In Proceedings of the 18th IEEE Conference on Computational Complexity, ˚ pages 284–299. IEEE, Arhus, 7–10 July 2003. 9. Uriel Feige. A threshold of ln n for approximating set cover. Journal of the ACM, 45(4):634– 652, July 1998. 10. Johan H˚astad. Some optimal inapproximability results. Journal of the ACM, 48(4):798–859, July 2001. 11. Johan H˚astad and Subhash Khot. Query efficient PCPs with perfect completeness. In 42nd Annual Symposium on Foundations of Computer Science, pages 610–619. IEEE, Las Vegas, Nevada, 14–17 November 2001. 12. Johan H˚astad and Avi Wigderson. Simple analysis of graph tests for linearity and PCP. Random Structures and Algorithms, 22(2):139–160, March 2003. 13. Ran Raz. A parallel repetition theorem. SIAM Journal on Computing, 27(3):763–803, June 1998. 14. Alex Samorodnitsky and Luca Trevisan. A PCP characterization of NP with optimal amortized query complexity. In Proceedings of the Thirty-Second Annual ACM Symposium on Theory of Computing, pages 191–199. Portland, Oregon, 21–23 May 2000. 15. Madhu Sudan and Luca Trevisan. Probabilistically checkable proofs with low amortized query complexity. In 39th Annual Symposium on Foundations of Computer Science, pages 18–27. IEEE, Palo Alto, California, 8–11 November 1998. 16. Luca Trevisan. Parallel approximation algorithms by positive linear programming. Algorithmica, 21(1):72–88, May 1998. 17. Luca Trevisan. Recycling queries in PCPs and in linearity tests. In Proceedings of the Thirtieth Annual ACM Symposium on Theory of Computing, pages 299–308. Dallas, Texas, 23–26 May 1998.
18
k
h h−1
`
1 0
Figure 1. A pictorial view of the layered PCP construction. The dashed squares represent variables from V , the other squares represent variables from Φ. In the proof of Theorem 4 all coordinates but the one between the two dashed lines are fixed.
πvj φj
πvi+1 φi+1
Figure 2. Construction of the projection function πψ,j→i using the coordinatewise projection functions πvi+1 φi+1 , . . . , πvj φj . The dashed squares represent variables from R, the other squares represent variables from S.
`
h
Figure 3. Definition of ` and h in the proof of Lemma 2 given a set S of points (i, j) where 0 ≤ i < j ≤ k.
19
