Black box simulation barrier (Part 1)


Cryptography 2019-05-08

I haven’t been writing posts since this semester. Yesterday I was surprised that this site was discovered by a fellow alumnus from Tsinghua University (See his blog: Gee Law). So I decided to spend some time continuing the topic I planned to write.

Enjoy reading!


The material from this post is mainly from Goldreich and Krawczyk 1996. Also note that some technical details are omitted.

The Barrier: AMbb-ZKBPP

Recall that in the paper, the authors proved that,

The following condition hold for an IP for a language L if and only if L BPP.

  1. It is constant-round, i.e. the number of rounds of exchanging messages is bounded by a constant;
  2. It is Arthur-Merlin, i.e. the verifier does not have hidden randomness from the prover;
  3. It admits black-box simulation. That is to say, for any , there is a simulator which is an oracle machine that treats as a black-box, and that produces a simulated view that is computationally indistinguishable from a real execution by .

Last time we considered the almost-trivial case where there is only a single message from the prover. The existence of the simulator alogrithm itself gives us a way to find the appropriate proof in PPT time.

Today we will describe the 3 round case. (The proof is from section 6.1 and 6.2 from the paper.)

(Btw, after reading the paper more carefully, I realized that there are a lot of technical details that I missed. I will add them in whenever it is necessary. Comments will be appreciated.)

AMbb-ZKBPP.

If there exists an IP with the above properties and, in particular has 3 rounds, for some language L. Then L BPP.

By IP we mean, more specifically,

  1. Completeness: If L, there is an honest prover which succeeds in convincing the verifier to accept with probability at least negl where negl is an negligible function;
  2. Soundness: If L, then for any prover, the probability of convincing the verifier is negligible;

(The probability above is over both the random coins by the prover and the verifier.)

The ZK protocol

We can illustrate any 3-round AM protocol for as follows. (Let .)

  1. Prover sends a message to Verifier.
  2. Verifier sends random coins to prover. (We will assume by padding.)
  3. Prover upon receiving , selects a message (which depends on ) to convince the verifier.

Finally the verifier locally runs a (possibly randomized) predicate to determine if it should accept.

Let be the PPT simulator that, when fed in as the input, as the random coins used by the simulator, and as a black box, outputs a simulated transcript describing the interaction between and . Note that is capable of simulating the view of (non-uniform) deterministic verifiers and this property suffices for our proof.

The attack plan

The idea behind the reduction is similar to the 1-round case in its core, but is more technical due to interaction. We will use as a subroutine to generate some transcript, and we show that

  1. If is in L, an accepting transcript with high probability is found;
  2. Otherwise, with negligible probability will we find such an accepting transcript.

This will directly give us a BPP algorithm because after having such a transcript, we can use the predicate to decides .

How can we use to build a transcript?

Recall that the simulator might query the verifier in a blach box way by performing a sqeuence of trials on it: sending the first message and receiving the corresponding random coins , and repeatedly for a total of rounds. And finally outputs a transcript .

Here is where AM comes into play : we simply feed in a freshly generated random coins to whenever requested. This way our algorithm runs in PPT time because is bounded by a polynomial. However there are some technical issues.

Using the simulator

The plan outlined in the previous section seems straightforward, but actually there are some complication to argue that the generated transcript have the desired property. (Because might exhibits undefined behavior when we give it too much garbage — who knows?)

Consistency of the random coins

To respond to the request made by , we should store a list of ’s and only give out a new random when a query that is distinct from the previous queries has been made.

The reason is that we want our algorithm to be acting as a virtual deterministic verifier from the perspective of . As a deterministic verifier, the random coins sent is determined when given , so we need to maintain the consistency, i.e. send the same , whenever the same is given twice.

Appearance of final output in the sequence

We will assume that explicitly requests the generated and receives in one of the trials (i.e. for some ) before outputting as the simulated transcript.

Concrete discription of the BPP algorithm

Having the above assumption, the input to our BPP algorithm can be described as follows.

Proof of correctness

Note that the generated transcript by is uniquely determined by the vector . Call such a vector good if the resulting transcript is accepting, and call it -good if .

Then our goal is to show that a randomly selected vector has high probability of being good if , while on the other hand a randomly selected vector has only negligible probability of being good if .

The case when

Suppose on the contrary, for infinitely many , the fraction of good vectors is non-negligible. For each of such , there exists an such that the fraction of -good vector is non-negligible. (This can be seen because the set of all good vectors are partitioned into polynomially many classes, i.e. -good for . So at least one of these classes contains a noticeable fraction.)

Specifically, for some there are noticeable fraction of allowing the existence of making an accepting transcript.

This contradicts to the soundness requirement. Because for infinitely many , a cheating prover can send some as the first message, and with non-negligible probability the verifier replies a good which makes the final transcript accepting. (Note that we are dealing with interactive proofs, i.e. we allow a computationally unbounded prover who can find the string .)

The case when

We need to show that a noticeable fraction the vectors are good. The strategy is as follows.

  1. We first show that our replies to will behave in an identical way as some cheating verifier (which is deterministic), so the outputted is close to a simulated transcript for (By computational zero-knowledge simulation of ).
  2. The interaction between and is equivalent to an interaction between and .

Universal hash family

Recall that is the running time bound of . In the following we will need a family of hash functions which maps -bit strings to -bit strings, such that for a random function , we have

Note that these functions can be described by a string , i.e. polynomial in .

Constructing the (non-uniform)

For any , the cheating verifier replies every query by . By -independence, the uniformly chosen vector is equivalent to interacting with for some from ’s perspective.

Interaction between and is equivalent to with

For any from , the reply from , is uniformly random. So the behvaior of and an honest is equivalent. Therefore the probability of the transcript between eing accepted is 1-negl.

Putting the pieces together

The outputted transcript is (within a negligible difference) close to a real interaction between , but this transcript has probability 1-negl of accepting. Hence there is a noticeable fraction of good vectors.

Summary

To summarize, for L we have a noticeable fraction of good vectors and for L we have negligible fraction of good vectors. So the proposed algorithm is a BPP algorithm for L.


The proof here is essentially the same from the paper in the reference, with some modification. After writing the post I saw on the slides by Alon Rosen that the use of universal hash can be replaced by PRFs, which might give a cleaner presentation.

I am not very certain (yet) if some modifications are indeed valid so please feel free to comment! And I will probably try to use the step-by-step approach of writing proofs next time:)

Hmpf.. I didn’t expect to be writing for so long. I will try to write about the case for constant round AM sometime later. It seems to be a long journey until I can finally share about the Boaz’s construction, which I am in fact not very familiar yet.

Reference:

Alon Rosen: Lower Bounds and Limitations on Zero Knowledge. (Day 2 of BIU school)

Oded Goldreich, Hugo Krawczyk 1996: On the Composition of Zero-Knowledge Proof Systems.