Toward Probabilistic Checking against Non-Signaling Strategies with Constant Locality

09/10/2020
by   Mohammad Mahdi Jahanara, et al.
Simon Fraser University
0

Non-signaling strategies are a generalization of quantum strategies that have been studied in physics over the past three decades. Recently, they have found applications in theoretical computer science, including to proving inapproximability results for linear programming and to constructing protocols for delegating computation. A central tool for these applications is probabilistically checkable proof (PCPs) systems that are sound against non-signaling strategies. In this paper we show, assuming a certain geometrical hypothesis about noise robustness of non-signaling proofs (or, equivalently, about robustness to noise of solutions to the Sherali-Adams linear program), that a slight variant of the parallel repetition of the exponential-length constant-query PCP construction due to Arora et al. (JACM 1998) is sound against non-signaling strategies with constant locality. Our proof relies on the analysis of the linearity test and agreement test (also known as the direct product test) in the non-signaling setting.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

03/11/2020

The Measure-and-Reprogram Technique 2.0: Multi-Round Fiat-Shamir and More

We revisit recent works by Don, Fehr, Majenz and Schaffner and by Liu an...
04/12/2019

Proceedings Joint International Workshop on Linearity Trends in Linear Logic and Applications

This volume contains a selection of papers presented at Linearity/TLLA 2...
07/02/2021

Formal Semantics of a Classical-Quantum Language

We investigate the formal semantics of a simple imperative language that...
03/05/2018

Spatial Isolation Implies Zero Knowledge Even in a Quantum World

Zero knowledge plays a central role in cryptography and complexity. The ...
04/08/2018

Verifier Non-Locality in Interactive Proofs

In multi-prover interactive proofs, the verifier interrogates the prover...
09/27/2020

Quantum soundness of the classical low individual degree test

Low degree tests play an important role in classical complexity theory, ...
12/21/2021

Extending Merge Resolution to a Family of Proof Systems

Merge Resolution (MRes [Beyersdorff et al. J. Autom. Reason.'2021]) is a...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Probabilistically Checkable Proofs (PCPs) [BFLS91, FGL96, AS98, ALM98]

are proofs that can be verified by a probabilistic verifier that queries only a few locations of the proof. PCPs have been a powerful tool in the theory of computing, with applications in diverse areas such as hardness of approximation 

[FGL96] and delegation of computation [Kil92, Mic00]. A seminal result of [AS98, ALM98]

, known as the PCP theorem, says that every language decidable by a non-deterministic Turing machine in time

has a PCP system which allows to check if a given input of length is in the language by using random bits and making only queries to the given proof.

Recall that in the classical setting of PCPs the two standard requirements are completeness and soundness. Completeness

requires that if a given input is in the language, then there is some proof that convinces the prover with probability

. Soundness requirement states that if the input is not in the language, the prover rejects any proof with some significant probability. In this paper we study PCP systems that are sound against non-signalling proofs or non-signalling strategies, i.e., we require the prover to reject any non-signalling proof with some significant probability.

Non-signalling strategies are a certain restricted class of probabilistic oracles. When such oracle is given a set of queries, the response to the queries is sampled from a distribution such that the answer to each query may depend on all queries. More precisely, a non signalling strategy with locality is a collection , where each is a distribution over (i.e., over functions ), and for any two subsets of size at most , the restrictions of and to are equal as distributions. This setting stands in contrast to the standard notion of a classical proof, where the answer to each query is deterministic. Note that if the locality is the maximum possible, i.e., , then is a distribution over functions, which is (essentially) equivalent to the classical notion of a proof.

We note that one may think about -non-signalling functions, equivalently, as the class of all feasible solutions to the linear program arising from the ’th level relaxation of the Sherali-Adams hierarchy [SA90]. This implies that computing the maximum acceptance probability of an nsPCP verifier that uses random bits, where the maximum is taken over all -non-signaling proofs, reduces to a linear program with variables and constraints. In particular, if a language has a PCP verifier that on an input of length uses random bits, and is sound against -non-signaling proofs over an alphabet of constant size, then is decidable in time .

Non-signaling strategies have been studied in physics since 1980’s [Ras85, KT85, PR94] in order to better understand quantum entanglement. Indeed, these strategies strictly generalize quantum strategies and capture minimal requirements on “non-local” correlations that rule out instantaneous communication.

PCP systems that are sound against non-signalling proofs have recently found numerous applications in theoretical computer science, including schemes for 1-round delegation of computation from cryptographic assumptions [KRR13, KRR14], and hardness of approximation for linear programming [KRR16]. However, as opposed to the well studied setting of the classical PCP theorem, where there are many constructions achieving best parameters possible, in the non-signalling setting many parameters of the known PCP constructions appear to be far from optimal.

One of the most important parameters associated with a non-signalling proof is the locality parameter, denoted by . Indeed, [KRR13, KRR14] have studied the related notion of multi-prover interactive proofs that are sound against non-signaling strategies (nsMIPs). They have shown that nsPCPs are essentially equivalent to nsMIPs where , the locality of the proof in the nsPCP setting, exactly corresponds to the number of provers in the nsMIP setting.

Despite the importance of the locality parameter, the exact complexity of languages admitting nsPCPs that are sound against -non-signaling proofs is still open for most ’s. Note that as the locality of the proof decreases, there are fewer constraints imposed on the proof, and hence the task of the verifier becomes more challenging. The seminal result of Kalai, Raz, and Rothblum [KRR13, KRR14] showed that every language in has an nsPCP verifier that uses random bits, makes queries to a proof of length , and is sound against -non-signaling proofs. In particular, every language in is captured by a nsMIP with a polynomial time randomized verifier who communicates with non-signaling provers. For the limitations of nsPCPs, Ito [Ito10] proved that for the corresponding linear program is solvable in , which is tight by the result of [IKM09], and hence the class is captured by PCPs that are sounds against -non-signaling proofs. Much less is known about the power of PCP systems that are sound against -non-signaling proofs for . Recently, Holden and Kalai [HK20] proved that -prover non-signalling proofs with negligible soundness is contained in .

All these results give rise to the following question, raised in [CMS19], asking for the non-signaling analogue of the PCP theorem.

Question 1.1.

Is it true that every language in has an nsPCP verifier that uses random bits, makes queries to the proof, and is sound against -non-signalling functions?

Motivated by this problem, Chiesa et. al [CMS19, CMS20] started a systematic study of non-signalling PCPs. They proposed studying the classical (algebraic) PCP constructions and their building blocks (which are very well understood in the classical setting), and adapting each of the building blocks to the non-signaling setting. In particular, focusing on the PCP construction of [ALM98] they made an appropriate definition of linear non-signalling functions and analyzed the linearity test of [BLR93] against non-signalling strategies [CMS20]. Then, building on the linearity test, they proved in [CMS19] that the classical exponential length -query PCP of [ALM98] is sound against -non-signalling proofs. We emphasize, that even for exponential length nsPCPs (corresponding to nsPCPs with randomness), there are no known constructions that are sound against -non-signaling proofs. Given this state of affairs, it is natural to ask the following question, that is simpler than creftype 1.1

Question 1.2.

Is it true that every language in has an nsPCP verifier that uses random bits, makes queries to the proof, and is sound against -non-signalling functions?

One must be careful with the precise formulation of creftype 1.2. Note that if the verifier uses more than random bits, the runtime spent on reading the randomness is more than , which is the time complexity of the problem. To recover a nontrivial question, we require the verifier to be input oblivious. That is, in order to decide whether an instance belongs to the given language , the verifier generates the queries based only on the length of the input and its randomness (but not the input itself), and then rules according to an -time decision predicate (where the predicate does depend on ). Indeed, the [ALM98] verifier studied in [CMS19] is input oblivious.

In this work we build on the work of [CMS19] and provide a positive answer to creftype 1.2 assuming a certain geometric hypothesis. Specifically, we construct an input oblivious nsPCP verifier for any language that uses random bits, makes queries to a given proof, and is sound against -non-signalling functions, with two caveats.

  1. The first is that the alphabet of the nsPCP system is , instead of the binary alphabet employed by [CMS19, KRR14, ALM98]. Still, this means that the verifier reads a total of bits from the proof, which makes our result non-trivial. Also, recall that in the classical setting, we have the alphabet reduction technique using proof composition, and it is plausible that we can apply similar ideas also in the non-signaling setting. Indeed, proof composition is an important building block in the classical PCP literature, and we believe it will also be an important step toward resolving creftype 1.1.

  2. The second caveat is that our result depends on a certain quantitative geometric hypothesis about proximity between almost non-signaling proofs and exactly non-signaling proofs. Equivalently, the hypothesis says that every feasible solution for the noisy Sherali-Adams LP is close (in some precise, rather weak, sense) to a feasible solution for the (exact) Sherali-Adams LP. See creftype 2 for details, and the discussion in Appendix A.

Our work follows the general philosophy of [CMS19, CMS20], who proposed building modular analogues of tools and techniques from the classical PCP literature. A classical tool used in the construction of PCPs is parallel repetition [Raz98, Hol09]. In the classical setting of 2-query PCP, parallel repetition is used to reduce the soundness error. In this work we use parallel repetition for non-signalling proofs to reduce the locality to , while the soundness stays in the “high-probability acceptance regime”. In addition to parallel repetition, we study additional tools from the PCP literature. Specifically, we use the modular approach that is typical for the classical setting. Specifically, we show first that the parallel repetition of the [ALM98] verifier is sound against “nicely structured” proofs. Then, we use linearity test and direct product test, and claim that proofs that satisfy both tests with high probability must be nicely structured, and hence we essentially reduce the analysis to the structured case.

Another interesting feature of our proof is the reduction from the parallel repetition of the [ALM98] verifier to the non-repeated [ALM98] verifier. Specifically, we show that if for some input , the parallel repetition of the [ALM98] verifier accepts a proof with high probability, and the proof is “nicely structured”, then it is possible to “flatten” the repeated proof into a proof over the binary alphabet, that satisfies the (non-repeated) [ALM98] verifier with high probability. Therefore, by applying the result of [CMS19] about the soundness of the [ALM98] verifier, we conclude that the input is in the language.

1.1 Informal statement of the result

Below we discuss the main result of the paper. Our result depends on an hypothesis about approximating almost non-signaling functions using exactly non-signaling functions.

Hypothesis 1 (Informal).

Any almost linear, almost non-signaling function can be well approximated by some non-signaling function of slightly lower locality.

Equivalently, any solution to the noisy Sherali-Adams LP can be well approximated by a solution to the (exact) Sherali-Adams LP of slightly lower level in the hierarchy.

The exact formulation of the hypothesis relies on the precise definitions of non-signaling and almost non-signaling functions (or, equivalently, the related notions of noisy Sherali-Adams LP), as well as the appropriate definitions of distance. For the formal statement of the hypothesis see creftype 2 following the required definitions in Section 2.

We are now ready to state our main theorem.

Theorem 1 (Main theorem - informal).

Assuming creftype 1 every language has an input oblivious nsPCP verifier that on an input of length uses random bits, makes queries to proofs over the alphabet , and is sound against -non-signaling proofs. The query sampler runs in time , and the decision predicate runs in time .

To the best our knowledge, this is the first result that constructs a PCP system that is sound against non-signaling proofs with constant locality.

1.2 Roadmap

The rest of the paper is organized as follows. In Section 2 we formally define the notions that we utilize throughout this work, and use them to formally state our hypothesis and the main theorem in Section 3. In Section 4 we recall the ALMSS verifier, and define our variant of its parallel repetition. In Section 5 we provide an overview of the soundness proof. In Section 6 we prove soundness of our verifier against structured proofs. In Section 7 we discuss our local testing and self-correction, which enables us to reduce soundness against general proofs to soundness against structured proofs. Finally, in Section 8 we prove the main result.

2 Preliminaries

2.1 Probabilistically Checkable Proofs

We start with the definition of Probabilistically Checkable Proofs (PCPs). Recall that a classical PCP verifier for a language is given an input , and an oracle access to a proof. The verifier reads the input, uses randomness, queries the proof in a small number of coordinates, and based on the answers to the queries decides whether to accept or reject. Completeness requires that if , then there exists a proof that makes the verifier always accept. Soundness requires that if , then for any proof the verifier will reject with high probability.

In the non-signaling setting, a non-signaling PCP verifier is a verifier, whose soundness is further required to hold against any non-signaling proof of prescribed locality. More precisely, an nsPCP verifier for a language gets an input and an oracle access to a non-signaling function . The verifier reads the input , uses random bits to decide on a subset on which is queried. Then, based on the answer it decides to accept or reject.

Definition 2.1.

A nsPCP verifier for a language is a randomized algorithm that gets an input and oracle access to a -non-signaling proof . The verifier uses randomness to decide on a subset of size , and queries on . Then, based on the answer it decides to accept or reject. We say that has perfect completeness and soundness error against -non-signaling proofs if the following holds.

Completeness:

For all there exists a (classical) proof such that .

Soundness:

If , then for all -non-signaling proofs it holds that .

We say that verifier is input oblivious if the choice of the query set depends only on the input length , the randomness of the verifier, but is independent of .

Remark 2.2.

Note that in the non-signaling setting the locality parameter upper bounds the number of queries made by the verifier, and it is possible that the actual predicate used by the verifier depends on significantly less than coordinates of the proof. For example, [CMS19] proved that the 11-queries verifier of [ALM98] is sound against -non-signaling proofs, and it is not known whether the verifier is sound against -non-signaling proofs, or even -non-signaling proofs.

2.2 Parallel repetition

In the classical setting a proof is assumed to be a string, or equivalently, a static function committed by the prover. A -parallel repetition of a proof is a mapping that allows accessing locations of the (supposed) proof by making only 1 query to a (longer) proof over a larger alphabet. That is, the intended proof corresponds to some “base” proof defined as . Analogously, given a verifier , a -repeated verifier which is denoted by , runs parallel independent instances of and accepts if and only if all instances accept.

The original motivation for using parallel repetition was to reduce the soundness error of a proof system, while keeping the number of queries fixed. In the classical setting, if the repeated proof is indeed a parallel repetition of some base proof , then it is not hard to see that the soundness error of is exponentially smaller than the soundness error of . The soundness analysis of the repeated proof need not be based on this comparison to the soundness error of the base proof, and analyzing such proofs in both classical and non-signalling settings has been a subject of a long line of research [Ver96, Raz98, Hol09, DS14a, BG15, LW16, HY19].

In this work, we use parallel repetition to improve the minimum locality parameter of non-signaling proofs required for the soundness of the verifier, rather than its soundness error. Next, we formally define non-signaling proofs, and some properties of such proofs that we will need in the paper.

2.3 Non-signaling functions

In this work we consider PCP verifiers that are sound against non-signaling proofs. Below, we formally define the notion of non-signaling functions, and introduce some notation we will use in the paper. Throughout the paper we will use terms non-signaling function, non-signaling proof, and non-signaling strategy interchangeably.

Definition 2.3.

Fix a domain , an alphabet , and a parameter . A -non-signaling function is a collection , where each is a distribution over assignments , such that for every two subsets each of size at most , the marginal distributions of and restricted to are equal.

Unlike a classic function, we can use a -non-signaling function only once in the sense that one has to present the set of at most queries all at once. In other words, it is not possible to use the non-signaling function adaptively.

Remark 2.4.

Throughout the paper we will consider non-signaling functions of two types:

  • functions over the domain for some and alphabet ;

  • functions over the domain and alphabet for some parameters .

Next, we define a relaxed notion of non-signaling functions, that allows the marginal distributions induced by different query sets to be only statistically close rather equal on the intersection. This relaxation arises in our analysis. It has also appeared naturally in other works in this area, especially in cryptographic applications [ABOR00, DLN04, KRR13, KRR14].

Definition 2.5.

Fix a domain , an alphabet , and parameters and . A -non-signaling function over a domain and an alphabet , is a collection , where each is a distribution over assignments , such that for every two subsets each of size at most , the marginal distributions of and restricted to are -close with respect to total variation distance, i.e.,

In particular, a -non-signaling-function coincides with the definition of -non-signaling function from Definition 2.3.

Next we define non-signaling and almost non-signaling counterpart of parallel repeated functions.

Definition 2.6.

Fix a domain , an alphabet , and parameters . A -repeated -non-signaling function is an -non-signaling function . Namely, a -repeated -non-signaling function is a collection , where each is a distribution over assignments , such that for every two subsets each of size at most , the marginal distributions of and restricted to are -close with respect to total variation distance.

We will also need the definition of distance between non-signaling or almost non-signaling functions.

Definition 2.7 (Statistical distance).

Let be two non-signaling or almost non-signaling functions with locality . For the -distance between and is defined as

where is the total variation distance between and .

We say that and are -close in the -distance if , and say that they are -far otherwise.

2.4 Permutation folded repeated non-signaling functions

Folding is a technique used to impose some structure on the given proof without really making extra queries. The idea of using folded proofs was first introduced by [BGS98]. We formally define the permutation folding property, and then explain why we can impose this property without making extra queries.

Definition 2.8.

Let be a

-values vector, and let

be a permutation of the indices . Define to be the vector obtained from by permuting the coordinates according to .

Let be a -repeated -non-signaling function. is said to be permutation folded or permutation invariant if for any with , for any for some permutations , and for any it holds that

Observation 2.9.

It is important to note that we can fold any given -repeated -non-signaling function by partitioning into equivalence classes, where and belong to the same class if for some permutation .

We defined the folding of , denoted by as follows. For any query to , let be a uniformly random permutation, and define the distribution of as the distribution of .

It is easy to see that is indeed -non-signaling and permutation folded. Furthermore, note that if is permutation folded, then .

2.5 Linear non-signaling functions

In this part, we define linear -repeated non-signaling functions. Linear non-signaling boolean functions have been studied in [CMS20, CMS19], and played a key role in the proving that the PCP verifier of [ALM98] is sound against non-signaling proofs. We also use such structured non-signaling proofs in this paper. See Section 4 for details.

Definition 2.10 (Linear -repeated functions).

Let be a -repeated -non-signaling function. We say that is linear if for all , and defined by the coordinate-wise addition modulo 2, and for all containing of size at most , it holds that

Remark 2.11.

Note that in the degenerate case of if a (non-repeated) -non-signaling function satisfies the linearity condition in Definition 2.10 then for all , i.e., satisfies the linearity test of [BLR93] with probability 1. Non-signaling functions satisfying this property have been the subject of work on linearity testing in the non-signaling setting [CMS20].

Next we extend Definition 2.10 by introducing the notion of an almost linear -repeated non-signalling function.

Definition 2.12 (Almost linear -repeated functions).

Let be a -repeated -non-signaling function. We say that is -linear if for all , and defined by the coordinate-wise addition modulo 2, and for all containing of size at most , it holds that

We will allow ourselves to use the informal term almost linear, when referring to a non-signaling function that is -linear for some small .

2.6 Consistent repeated non-signaling functions

In this part, we define the notion of consistency for -repeated -non-signaling function.

Definition 2.13 (Consistent -repeated functions).

Let be a -repeated -non-signaling function. We say that is consistent, if for any it holds that

Similarly to the almost linear property, we define the relaxed notion of almost consistent non-signalling function.

Definition 2.14 (Almost consistent -repeated functions).

Let be a -repeated -non-signaling function. We say that is -consistent, if for any

We will allow ourselves to use the informal term almost consistent, when referring to a non-signaling function that is -consistent for some small .

Claim 2.15.

Let be a -repeated -non-signaling function for , and suppose that is -consistent. Fix and let . Then, for any event it holds that

Proof.

Note that

where the last inequality is by the assumption that is -consistent. By symmetry, we also get the inequality in the other direction, and the claim follows. ∎

We observe that for and (almost) linearity implies (almost) consistency. Specifically, we prove the following claim.

Claim 2.16.

Let be a -repeated -non-signaling function, and suppose that (i) is -linear, and (ii) for all . Then, is -consistent when treated as a -non-signaling function.

Proof.

Let be a set of queries of size . Let , and let . We show below that

Consider the set of queries , where . In particular, for all . By the assumption of the claim we get that . Therefore, using the assumption that is -linear it follows that

Therefore, is -consistent, as required. ∎

2.7 Flattening of a -nsPCP

Below we define the flattening operation, which transforms a given -repeated proof into a non-repeated proof in the natural way. Namely, given a query set to the non-repeated proof, we create a vector containing all the elements of , query the repeated proof on , and respond according to the received answer.

Definition 2.17.

Let be a -non-signaling -repeated proof. Define the flattening of , denoted by as follows. For a query set of size , define a vector whose first entries are and the rest are set arbitrarily, query on the single query , and let the distribution of be

Claim 2.18.

Let be a -non-signaling function that is permutation folded and -consistent for . Then is a -non-signaling function.

Furthermore, fix a query for , a query set of size for , also let such that are distinct and for all . Then, the distribution of and are -close in total variation distance.

Proof.

To prove that is -non-signaling function let be two sets of queries, and suppose . We want to show that for any event it holds that

(1)

Define as in Definition 2.17, let be permutations such that for all it holds that . By non-signaling and permutation invariance of , if we query it on we have:

Then, by creftype 2.15 we get the following:

which proves Eq. 1. Therefore, is a -non-signaling function.

Next we prove the second part of the claim. Given , define as in Definition 2.17, and consider the query set to . Since is permutation folded, we may assume that for all . Therefore, for any we have:

which is upper bounded by by creftype 2.15. This complets the proof of creftype 2.18

The following claim is follows rather immediately from creftype 2.18 above.

Claim 2.19.

Let , and let be a -non-signaling function that is permutation folded, -linear, and -consistent. Then is a (non-repeated) -non-signaling -linear function.

Proof.

By applying creftype 2.18 on , we get that is a -non-signaling function. Next we prove that is -linear. Fix , and let be a query set for such that . We want to prove that

(2)

Let be as in Definition 2.17. By the permutation folding property of we may assume that the first three coordinates of are . That is , and .

By definition of we have . Consider now the vectors , , and . Since is -linear, we get that . Since is -consistent, it follows that

as required. ∎

3 Main result

In this section we formally state the main result of the paper. In order to describe the result we need to first state the hypothesis conditioned on which our main theorem holds.

Hypothesis 2.

Fix integers and , and let . For any -almost non-signaling function that is -linear there exists a -non-signaling function such that , where for some positive absolute constant , and is some function that depends only on such that as .

Remark 3.1.

We make two remarks regarding the hypothesis.

  • A statement analogous to creftype 2 has been proven in [CMS20], showing that there exist a -non-signaling function such that . The multiplicative factor of is too large, which makes it insufficient for our applications.

  • For our applications, we need a much weaker version of creftype 2. We elaborate more on the hypothesis in Appendix A.

For a computable function we denote by the complexity class of all languages having a uniform family of boolean circuits of maximum fan-in 2 with AND, OR, and NOT gates, such that has at most wires for all .111Note that our complexity measure for the size of a circuit is the number of wires, (and not the number of gates, which is more standard) as this measure directly affects the complexity of the PCP construction. However, for circuits with bounded fan-in, the two quantities are equal up to a multiplicative constant factor.

Theorem 2 (Main theorem).

Assuming creftype 2 every language has an input oblivious nsPCP verifier that on input of length uses random bits, makes queries to proofs over the alphabet , and is sound against -non-signaling proofs. The query sampler runs in time , and the decision predicate runs in time . That is,

It is clear that creftype 1 follows from creftype 2 since .

4 The PCP construction

In this section we formally describe our PCP construction. In one sentence, the PCP verifier gets a permutation invariant proof , runs on it linearity test, direct product test, and the parallel repetition of the ALMSS verifier, and accepts if and only if all tests accepts.

We start by recalling the setting of the PCP verifier of [ALM98] (the “linear ALMSS verifier”). Let be a language, and let be a uniform family of boolean circuits with wires that decides . That is, for all inputs of length it holds that if and only if .

For a given length let be the circuit corresponding to the computation on inputs of length . The computation of on the input is viewed as a system of constraints over boolean variables , where are quadratic polynomials (each involving at most three variables in ) and are boolean constants. Each variable represents the value of one of the wires of during the computation on the input . In particular, the first variables, , correspond to the input wires, and the variable corresponds to the output wire. The constraints are of three types:

Input consistency:

For every , and .

Gate consistency:

For every ,

  • If the wire represented by the variable is an output of an AND gate , where the inputs to are given by , then and .

  • If the wire represented by the variable is an output of an OR gate , where the inputs to are given by , then and .

  • If the wire represented by the variable is an output of a NOT gate , where the input to is given by , then and .

Accepting output:

and .

We overload notation, and use to also denote the upper triangular matrix in with