in both cases, being 1? 2=k(n) and 1? O(1=k(n)) respectively; the number of repetition has no eect on this ratio. There is great simplication and conv

Transcription

1 A Classication of the Probabilistic Polynomial Time Hierarchy under Fault Tolerant Access to Oracle Classes Jin-Yi Cai Abstract We show a simple application of Zuckerman's amplication technique to the classication problem of the probabilistic polynomial time hierarchy formed by interleaving all possible oracle classes from BPP, RP, corp and ZPP, in any nite number of levels. In the fault tolerant model introduced by Cai, Hemachandra and Vyskoc, we arrive at a complete classication. Key Words: Computational Complexity, Fault Tolerance, Theory of Computation. 1 Introduction A well-known technique for amplifying the success probability of a randomized algorithm is to run the algorithm independently a polynomial number of times. When the algorithm has a weak success probability, say 1=2+, then by running the algorithm m times independently, and taking the majority vote, we can achieve an error probability e?(2 m). If the original algorithm uses k(n) random bits to achieve success probability 1=2+(n), then the repetition uses O(k(n)`(n)=(n) 2 ) many bits to achieve error probability e?`(n). This is all very good if we only care about the ratio of the number of \bad" witnesses over the number of all witnesses. But in terms of the number of random bits used, this amplication becomes very poor. In order words, if we take the logarithm of the number of \bad" witnesses and the logarithm of the number of all witnesses respectively, we found that the ratio does not get improved at all. For example, let (n) = 1=4 and k(n) = n c, as is customary in BPP algorithms. Then the ratio of the logarithm of the number of \bad" witnesses over the logarithm of the number of all witnesses tends to 1 Department of Computer Science, SUNY at Bualo, Bualo, NY Research supported in part by NSF grant CCR , and a J.S.Guggenheim Fellowship. cai@cs.buffalo.edu 1

2 in both cases, being 1? 2=k(n) and 1? O(1=k(n)) respectively; the number of repetition has no eect on this ratio. There is great simplication and convenience, as we will see, that can be derived in many proofs if we can make this ratio arbitrarily small. This is indeed possible, and follows from the recent construction of optimal samplers by Zuckerman [13]. The basic idea involves using not entirely fresh independent random bits for the trials from which we take majority vote, but rather using only a small number of additional random bits for each additional trial. A precursor to this idea (and still an important technique) is based on random walks on expander graphs. Here one takes an appropriate expander graph on 2 k(n) nodes. Aer initially using k(n) random bits to choose a uniformly chosen point in the graph, we continue by taking random walks in the expander graph to generate subsequent pseudorandom strings. For constant degree expanders, we can reach a fairly random next vertex using only O(log n) true random bits. The properties of the expander graph will allow us to conclude that a much smaller number of random bits are needed to achieve the same success probability by majority vote than if we were to sample points independently each time, costing k(n) bits each time. Using expander graphs, the current best ratio one can achieve between the logarithm of the number of \bad" points and the logarithm of the number of all sample points is a constant less than 3=4 + (see e.g. [7]). Zuckerman [13] improved this to any arbitrarily close to 0. Theorem 1.1 (Zuckerman) For any constant > 0, there is a deterministic polynomial time algorithm Z such that, for any BPP algorithm, which uses k(n) random bits on input of size n and achieves error probability 1=4, Z transforms the witness space f0; 1g k(n) to f0; 1g`(n), where `(n) = k(n) O(1) = n O(1), so that the total number of \bad" witnesses is less than 2 `(n). Zuckerman's amplication technique can simplify proofs signicantly. We now illustrate this technique by giving a particularly simple proof to a known result [3] that the class MA with one-sided error coincides with MA with twosided error. We say a language L in MA with one-sided error if for any x 2 L, Merlin has a proof y which always convinces Arthur without error. (If x 62 L, for any proof y, Arthur will reject x with high probabilty. Small error probability of accepting is allowed in this case.) We say a language L in MA with two-sided error if a small error probability is allowed in both cases. Let L 2 MA with two-sided error. By Theorem 1.1, we may assume that a P-time predicate A exists such that the following holds: x 2 L ) (9y; jyj = jxj c )jfz 2 f0; 1g p(jxj) : A(x; y; z) = 0gj 2 p(jxj)=4 ; x 62 L ) (8y; jyj = jxj c )jfz 2 f0; 1g p(jxj) : A(x; y; z) = 1gj 2 p(jxj)=4 : Consider all prexes z 1 2 f0; 1g p(jxj)=2 of z. There are 2 p(jxj)=2 many segments S z1 = fz 2 f0; 1g p(jxj) : z = z 1 z 2 forsomez 2 2 f0; 1g p(jxj)=2 g. Let x 2 L. 2

3 Since there are at most 2 p(jxj)=4 \bad witnesses" z altogether, far more than the number of segments S z1, it follows that there exists a \proof" ^y = y z 1, such that 8z 2 S z1, A(x; y; z) = 1. On the other hand, for x 62 L, 8y and 8z 1, there could still be at most 2 p(jxj)=4 \bad witnesses" in S z1, so that P r z22f0;1g p(jxj)=2[a(x; y; z 1z 2 ) = 1] 2p(jxj)=4 2 p(jxj)=2 = 2?p(jxj)=4 : The above result is known and can be proved using standard techniques such as those from Lautemann [10]. But as one can see, Zuckerman's technique simplies the proof considerably. By this technique, one has a much stronger control on the total number of errors. A number of interesting applications were pointed out in the paper [8]. For example, they reproved the theorem that BPP is contained in MA (with one-sided error), and MA is contained in ZPP NP. Even though these results were proved before by other techniques [11, 10, 2], the proofs presented in [8] were very elegant and simple. In this paper we follow their approach to derive a classication of the probabilistic polynomial time hierarchy under the fault tolerant access model. 2 A Probabilistic Polynomial Time Hierarchy Based on Fault Tolerant Access In this note, we apply Zuckerman's amplication to the classication problem of the probabilistic polynomial time hierarchy formed by interleaving all possible oracle classes from BPP, RP, corp and ZPP. Our techniques only achieve a complete classication of this hierarchy in a model proposed by Cai, Hemachandra and Vyskoc in [5]. In this model, one allows a certain error in the way a query is answered to a problem in a promise class such as RP. In the standard model of BPP RP for example, there is a bottom level machine M and an oracle language L 2 RP, and any query M makes must be of the form \q 2 L?". Note that this is a global requirement: there must be a NTM for L which has RP behavior on every string q, namely either it is accepted on more than half of computation paths or none at all, regardless of whether q is queried or not. Specically, it is not necessarily sucient that there exists an NTM which exhibits RP behavior on every queried string. Cai, Hemachandra and Vyskoc [5] felt that while the standard model is certainly a valid model, this requirement might be too stringent and does not necessarily reect the intuition we ascribe to the notion of \access to RP computations by queries". A number of relaxations were introduced in [5]. Call a non-deterministic polynomial time computation N on x an RP computation if either more than half of computation paths are accepting or none are. To remove the global constraint that aects non-queried strings, one can allow for instance any query of the form \q 2 L(N)?", as long as it is guaranteed 3

4 that the computation of N on q is an RP computation. Further relaxing, we can have the \fault tolerant" model of RP queries (see [5]), where, for an NP machine N and a query of the form \q 2 L(N)?", it is only required that the query machine receive the correct answer if the computation of N on q in fact is an RP computation. In case this constraint is not satised, any adversarial oracle answer is allowed. It is in this model of fault tolerant access we can achieve a complete classication of the hierarchy formed by all possible interleaving of oracle classes from BPP, RP, corp and ZPP in any nite number of levels. It is most convenient to dene formally the hierarchy in terms of the notion of promise problems introduced by Evan, Selman and Yacobi. Denition 2.1 [6] A pair of languages (Q; L) is called a promise problem. A solution to a promise problem (Q; L) is a 0-1 function f, such that whenever x 2 Q, f(x) = L (x). In terms of promise problems, BPP can be generalized as follows: Denition 2.2 A promise problem (Q; L) belongs to BPP i there is a nondeterministic polynomial time machine (we will call it NP machine) N, such that if x 2 Q then there are more than 3/4 or less than 1/4 of all computation paths of N(x) accepting, and for x 2 Q, [ x 2 L, more than 3/4 of paths are accepting paths. ] We will use BPP to denote the promise class version of the language class BPP. This is a generalization of the language class BPP, since ( ; L) 2 BPP, L 2 BP P. We can dene similarly the generalized RP, corp and ZPP classes in terms of promise problems. Denition 2.3 We dene the promise classes RP, corp and ZPP as follows: A promise problem (Q; L) 2 RP i there is a NP machine N, such that if x 2 Q then there are more than half or no computation paths accepting in N(x), and for x 2 Q, [ x 2 L, more than half the paths are accepting. ] A promise problem (Q; L) 2 corp i there is a NP machine N, such that if x 2 Q then all or less than half of computation paths are accepting in N(x), and for x 2 Q, [ x 2 L, all paths are accepting. ] A promise problem (Q; L) 2 ZPP i there is a NP machine N with three types computation paths labeled f+;?;?g, such that if x 2 Q then either more than half are \+" paths and no \?" paths, or more than half are \?" paths and no \+" paths, and for x 2 Q, [ x 2 L, more than half are \+" paths. ] It is clear that the constants 1=4 and 3=4, or 1=2 are of no essential consequence. They can be replaced by any quantity bounded away from 1=2 and 4

5 bounded away from zero, 1=2? 1=n O(1), 1=2 + 1=n O(1) and 1=n O(1) respectively. Note that for a promise problem (Q; L) to be in any one of the above classes, only the sets Q \ L and Q \ L c matter. In other words if L 0 is another language such that L 0 j Q = L j Q then (Q; L 0 ) also belongs to the same promise class. The following lemma is easy to prove. Lemma 2.1 For the promise classes BPP, RP, corp and ZPP dened above, the following containments still hold: ZPP RP, corp, RP, corp BPP; (Q; L) 2 ZPP, (Q; L c ) 2 ZPP, (Q; L) 2 RP, (Q; L c ) 2 corp, (Q; L) 2 BPP, (Q; L c ) 2 BPP; ZPP = RP \ corp. For example, to prove that ZPP = RP\coRP, let any (Q; L) 2 ZPP. There is a NP machine N with three types of computation paths labeled f+;?;?g satisfying the requirement of the denition. To obtain a machine witnessing (Q; L) 2 RP, we take the same machine N, relabeling \+" paths as accepting, \?" and \?" paths as rejecting. Similarly, to show (Q; L) 2 corp, we relabel \+" and \?" paths as accepting, \?" paths as rejecting. Now let any (Q; L) 2 RP \ corp. We have a pair of machines N 1 and N 2 witnessing membership in RP and corp respectively. We design a new NP machine N as follows: On any input x it runs N 1 and N 2 on x, where any path of N corresponds to a pair of paths ( 1 ; 2 ) of N 1 and N 2, respectively. Such a path is labeled \+" i both paths 1 and 2 are accepting; it is labeled \?" i both paths are rejecting; and it is labeled \?" otherwise. One can easily verify that N witnesses (Q; L) 2 ZPP. Let N be (an oracle) machine with accepting or rejecting paths, or f+;?;?gpaths, and let S be any oracle set. Dene #[Acc(N S (x))] and #[Rej(N S (x))] to be the number of accepting (+) and rejecting (?) paths of N S (x) respectively. Dene #[N S (x)] to be the total number of computation paths. Dene P r:[acc(n S (x))] = #[Acc(N S (x))]=#[n S (x)]. Similarly dene P r:[rej(n S (x))]. If there are no \?"-paths, then of course P r:[acc(n S (x))] + P r:[rej(n S (x))] = 1. More generally, let (Q; L) be any promise problem, let N (Q;L) (x) denote a computation of N on x, where any query q along any path is handled as follows. If q 2 Q then L (x) is returned by the oracle. If however q 62 Q then any possible answer is possible. This includes the possibility that the same query q is answered dierently along dierent paths. We say P r:[acc(n (Q;L) (x))] > (respectively, < or = ) if for any possible answers given to any query q 62 Q the probability of accepting is greater than (respectively, < or = ). Similarly for P r:[rej(n (Q;L) (x))] > or < or =. 5

6 This notion of fault tolerant access to promise problems was introduced in [5], and appears to be exactly the right notion in order to prove our main classication theorem (Theorem 2.1). There is another notion of oracle access to promise problems which is based on the notion of a solution to a promise problem, due to Grollmann and Selman [9]. In this notion, while arbitrary answers to a query q 62 Q is allowed, the answers given to the same q along dierent paths of the computation must be consistent, namely f(x), where f is a \a solution" to the promise problem (Q; L). In the fault tolerant access model no such global constraint is imposed. We note that if we adopt the other notion of access to promise problems (via \solutions" f), some of our lemmas still hold such as the crucial Lemma 2.7; but it is not clear our main theorem still holds in this case, in particular whether for example Lemma 2.4 still holds is unclear. Now we formally dene relativized computation with fault tolerant access to these promise classes. Denition 2.4 L 1 = fbpp; RP; corp; ZPPg, the 4 classes of promise problems dened above. Suppose L k has been dened, for some k 1; we dene L k+1 as follows. For any C 2 L k we rst dene the promise classes BPP C ; RPC ; corpc and, here the subscript indicates the fault tolerant model of oracle access. ZPP C A promise problem ( Q; b L) b is in BPP C i there are NP oracle machine N, where each path is accepting or rejecting, and some promise problem (Q; L) 2 C, such that bq fx j P r:[acc(n (Q;L) (x))] > 3=4 or P r:[acc(n (Q;L) (x))] < 1=4g; h i and if x 2 Q, b then x 2 L b, P r:[acc(n (Q;L) (x))] > 3=4. A promise problem ( Q; b L) b is in RP C above, such that i there are N and (Q; L) 2 C as bq fx j P r:[acc(n (Q;L) (x))] > 1=2 or P r:[acc(n (Q;L) (x))] = 0g; and if x 2 b Q, then h i x 2 L b, P r:[acc(n (Q;L) (x))] > 1=2. A promise problem ( Q; b L) b is in corp C above, such that i there are N and (Q; L) 2 C as bq fx j P r:[acc(n (Q;L) (x))] = 1 or P r:[acc(n (Q;L) (x))] < 1=2g; h i and if x 2 Q, b then x 2 L b, P r:[acc(n (Q;L) (x))] = 1. 6

7 A promise problem ( Q; b L) b is in ZPP C i there are NP oracle machine N with computation paths labeled f+;?;?g, and some (Q; L) 2 C, such that bq fx j P r:[acc(n (Q;L) (x))] > 1=2 and P r:[rej(n (Q;L) (x))] = 0g [ fx j P r:[rej(n (Q;L) (x))] > 1=2 and P r:[acc(n (Q;L) (x))] = 0g; and if x 2 b Q, then h i x 2 L b, P r:[acc(n (Q;L) (x))] > 1=2. Finally, L k+1 = fbpp C ; RPC ; corpc ; ZPPC j C 2 L kg: Thus, for example, for a promise problem ( b Q; b L) to be in the class ZPP RP, an NP machine can query any string, but if its input x 2 b Q, then it must guarantee that the majority of paths are correct, and no path makes any denite mistake (other than \?"), even though the answers to any query outside of the promise set Q of its oracle (Q; L) could be totally arbitrary, (but for queries q 2 Q the correct answer is returned, and there is an RP computation on any q 2 Q). The following lemmas Lemma 2.2 to 2.6 are easy to prove, and we omit most proofs. Lemma 2.2 The inclusions and equalities in Lemma 2.1 all relativize. In particular as a class function C D is monotonic increasing in both arguments C and D. Also C D C and CD D. Lemma 2.3 BPP BPP = BPP. Hence every class C 2 S L k1 k is a subclass of BPP. Moreover, if there is an appearance of BPP anywhere in the denition of C, then it is equal to BPP. Lemma 2.4 ZPP ZPP = ZPP. Hence, every class C 2 S L k1 k whose denition involves only appearances of ZPP is equal to ZPP. Proof: (of Lemma 2.4) By Lemma 2.2, we only need to show ZPP ZPP ZPP. Let ( Q; b L) b 2 ZPP ZPP. There are a NP oracle machine N with computation paths labeled from the set f+;?;?g and a promise problem (Q; L) 2 ZPP satisfying the denition. Let N 0 witness (Q; L) 2 ZPP. Let x 2 Q b be of length n. Suppose p(n) bounds the running time of N on every path. We rst amplify the success probability of N 0 so that for any q 2 Q, where jqj p(n), the error (of type \?") of running N 0 on q is bounded by 2?n. To show that ( Q; b L) b 2 ZPP, we consider the following NP machine N. b On any input x of length n, N b simulates N, where any query q is handled as follows. Run N 0 on q probabilistically. If an indenite answer \?" is reached, then terminate this path as a \?"-path. Otherwise use the simulation result \+" or \?" as oracle answers. Now it is not hard to see that this computation satises the requirement in the denition of ZPP for any x 2 Q. b 2 7

8 Here we note that had we adopted the model of oracle access to a promise problem via a \solution" f to the promise problem (Q; L), namely answers to q 62 Q is f(q), the above proof no longer works. This is because even though f(q) may not equal to L (q) for q 62 Q, it nonetheless requires that the answer be the same f(q) across all computation paths. It is not clear how to enforce this by the simulating machine b N. In our proof, the simulating machine may produce a computation tree not corresponding to any computation tree of N using a \solution" f. Lemma 2.5 RP ZPP = RP, and corp ZPP = corp. Lemma 2.6 For any class in S k1 L k, any appearance of corp on a level at least 2 can be replaced by RP. Lemma 2.7 BPP ZPP RP. This is where we will make use of Zuckerman's amplication from Theorem 1.1. Proof: Take any (Q; L) 2 BPP. There is a NP machine N such that if x 2 Q, then either P r:[acc(n(x))] > 3=4 or P r:[acc(n(x))] < 1=4. We may apply Zuckerman's amplication procedure to arrive at a sample space f0; 1g p(jxj), for some polynomial p(n), and a new NP machine b N, such that out of 2 p(jxj) many paths, P r:[acc(n(x))] > 3=4 ) #[Rej( b N(x))] < 2 p(jxj)=4 ; and P r:[acc(n(x))] < 1=4 ) #[Acc( b N(x))] < 2 p(jxj)=4 : Dene the following promise problem. Denote by b N(x; ) the computation path with non-deterministic move sequence, where jj = p(jxj). Q 1 = f(x; y; +) j jyj = p(jxj)=2; and, either more than half or none of bn(x; yz) are accepting, where jzj = p(jxj)=2g [ f(x; y;?) j jyj = p(jxj)=2; and, either more than half or none of bn(x; yz) are rejecting, where jzj = p(jxj)=2g: L 1 = f(x; y; +) j jyj = p(jxj)=2; and, more than half of b N(x; yz) are accepting, where jzj = p(jxj)=2g [ f(x; y;?) j jyj = p(jxj)=2; and, more than half of b N(x; yz) are rejecting, where jzj = p(jxj)=2:g Claim: (Q 1 ; L 1 ) 2 RP. Consider the following NP machine N. Upon input (x; y; +) where jyj = p(jxj)=2, N guesses z, where jzj = p(jxj)=2, and accepts if 8

9 bn(x; yz) accepts, and rejects if N(x; b yz) rejects. Similarly, upon input (x; y;?) where jyj = p(jxj)=2, N guesses z, where jzj = p(jxj)=2, and accepts if N(x; b yz) rejects, and rejects if N(x; b yz) accepts. If (x; y; +) 2 Q 1, then N accepts (x; y; +) for more than half or none of z, and for (x; y; +) 2 Q 1, [(x; y; +) 2 L 1, N accepts for more than half of z's ]. Similarly it can be veried for inputs (x; y;?) 2 Q 1 that N on (x; y;?) is an RP computation. The Claim is proved. Now we describe a \ZPP" machine N 0. This is a NP machine with three types of computation paths labeled f+;?;?g. On x, for any y, jyj = p(jxj)=2, it follows the path labeled by y and asks both questions (x; y; +) and (x; y;?) to the oracle (Q 1 ; L 1 ). If the answers are (yes, no), then N 0 accepts x, if the answers are (no, yes), then N 0 rejects x, and otherwise, i.e., the answer is (yes, yes) or (no, no), N 0 ends in \?" on this path. Let x 2 Q. First suppose x 2 L. Then by Zuckerman's amplication, #[Rej( N(x))] b < 2 p(jxj)=4. Thus, for every y, jyj = p(jxj)=2, the segment S y = f j = yz; jzj = p(jxj)=2g has mostly accepting paths. More precisely, with probability more than 1? 2?p(jxj)=4 a random y has no rejecting path in S y at all, and for every y, a random z 2 S y is a rejecting path with probability less than 2?p(jxj)=4. Thus, with probability 1?2?p(jxj)=4, both promises for (x; y; +) and (x; y;?) in Q 1 are fullled, and we get the right answer (yes, no). In the unlikely event that there are some z 2 S y which are rejecting (which occurs with probability less than 2?p(jxj)=4 ), still the promise for (x; y; +) in Q 1 holds. Hence, we either get the answer (yes, yes) or (yes, no). In the former case, N 0 returns \?" making no denite mistake, and in the latter case, N 0 returns the correct answer \+" accepting x. Now suppose x 62 L. Again, the error #[Acc( N(x))] b < 2 p(jxj)=4. So, with probability 1? 2?p(jxj)=4, both promises for (x; y; +) and (x; y;?) in Q 1 are fullled, and we get the right answer (no, yes). In the unlikely event that there are some z 2 S y which are accepting (which occurs with probability less than 2?p(jxj)=4 ), still the promise for (x; y;?) in Q 1 holds. Hence, we either get the answer (yes, yes) or (no yes). So we either make no denite mistake by returning \?" or the correct answer \?" rejecting x. (Note that under the promise x 2 Q, we never receive oracle answer (no, no) for our queries (x; y; +) and (x; y;?).) 2 Theorem 2.1 The hierarchy S L k1 k is completely classied as follows: 1. If C has an appearance of BPP anywhere in its denition, then C = BPP. Otherwise, 2. If there is no appearance of RP or corp anywhere in the denition of C, then C = ZPP. Otherwise, 3. If there is no appearance of RP or corp at any level at least 2, then C is equal to the bottom level class, which must be either RP or corp. Otherwise, 9

10 4. C = BPP. Proof: If C has an appearance of BPP anywhere in its denition, then the conclusion C = BPP follows from Lemma 2.3. Suppose now there is no appearance of BPP anywhere in the denition C. If further there is no appearance of RP or corp anywhere, then the conclusion C = ZPP follows from Lemma 2.4. Suppose now there is no appearance of BPP but there is some appearance of RP or corp, however the only such appearance is at the bottom level. Then, it is either RP or corp without any oracle class, or, by what we have already shown, the oracle class is equal to ZPP. Hence, by Lemma 2.5, C = RP or corp, whichever the bottom class is. Finally, we assume there is no appearance of BPP, and some appearances of RP or corp at level at least 2. By Lemma 2.2, and by Lemma 2.6, C ZPP RP, which by Lemma 2.7 contains BPP. Hence by Lemma 2.3, C = BPP. 2 Theorem 2.1 can also be stated equivalently and more succinctly as follows. Theorem 2.2 The hierarchy S k1 L k is completely classied as follows: 1. If C has no appearance of any class other than ZPPat level 2 or higher, the C coincides with the bottom level class. 2. Otherwise C = BPP. Fortnow informed me that essentially the same result as in Lemma 2.7 was obtained independently by Buhrman and Fortnow in [4], where several additional interesting results were also proved. The model of oracle access in [4] is however slightly dierent, based on the notion of a \solution" to a promise problem as discussed earlier. Generally speaking, with fault tolerant access a class C D is a more restrictive class than the corresponding class based on solutions to promise problems. Thus the corresponding statement of Lemma 2.7 in the other model follows from our Lemma 2.7. The proof in [4] could prove our Lemma 2.7 as well. However, as remarked earlier, statement such as ZPP ZPP ZPP (Lemma 2.4) does not imply its counter part in the other model. In fact, it is not clear this is still valid in the other model. We needed both types of containment as crucial ingredients in the proof of our main classication theorem. Acknowledgment I thank L. Hemaspaandra, A. Nerurkar, A. Pavan, K. Regan, A. Selman, D. Sivakumar, S. Toda, O. Watanabe for interesting discussions. I thank the anonymous referees for many constructive comments, which have improved the presentation of this paper. In pareticular I thank the referee for the more succinct statement 10

11 in Theorem 2.2. I also thank L. Fortnow for informing me of his recent result with H. Buhrman [4]. References [1] A. Andreev, A. Clementi, J. Rolim and Luca Trevisan. Weak Random Sources, Hitting Sets, and BPP Simulations In Proceedings of the 38th IEEE Symposium on Foundations of Computer Science, pp. To appear in SIAM Journal on Computing. [2] V. Arvind and J. Kobler. On Pseudorandomness and Resource-Bounded Measure. In the Proceedings of 17th Conference on the Foundations of Soware Technology and Theoretical Computer Science(FST&TCS), LNCS, Springer, vol 1346, pages 235{249, [3] L. Babai and Moran. Arthur-Merlin Games.??? [4] H. Buhrman and L. Fortnow. One-sided versus two-sided randomness. To appear in The 16th Annual Symposium on Theoretical Aspects of Computer Science (STACS), [5] J.-Y. Cai, L. Hemachandra and J. Vyskoc. Promise Problems and Guarded Access to Unambiguous Computation. Complexity Theory Current Research edited by Klaus Ambos-Spies, Steve Homer, Uwe Schoning and Klaus Ambos- Spies, Cambridge University Press, pp [6] S. Even, A. Selman, and Y. Yacobi. The complexity of promise problems with applications to public-key cryptography. Information and Control, 61(2):159{173, [7] O. Goldreich. A sample of samplers A computational perspective on samplers. Available ECCC, Electronic Colloquium on Computational Complexity, TR97-020, May [8] O. Goldreich and D. Zuckerman. Another proof that BP P PH (and more). Available ECCC, Electronic Colloquium on Computational Complexity, TR97-045, Sept [9] J. Grollmann and A. Selman. Complexity measures for public-key cryptosystems. SIAM Journal on Computing, 17(2):309{335, [10] C. Lautemann. BPP and the Polynomial Hierarchy. Information Processing Letters, 17, pages 215{217, [11] M. Sipser. A complexity theoretic approach to randomness. In the Proceedings of the 15th Symposium on Theory of Computing, 1983, 330{

12 [12] S. Zachos and M. Furer. A decisive characterization of BPP. Information and Control, Vol. 69, pages 125{135, [13] D. Zuckerman. Simulating BPP using a general weak random source. Algorithmica, Vol. 16, pages 367{391,