Polynomial-Time Random Oracles and Separating Complexity Classes

01/22/2018 ∙ by John M. Hitchcock, et al. ∙ University of Wyoming Northern Michigan University 0

Bennett and Gill (1981) showed that P^A != NP^A != coNP^A for a random oracle A, with probability 1. We investigate whether this result extends to individual polynomial-time random oracles. We consider two notions of random oracles: p-random oracles in the sense of martingales and resource-bounded measure (Lutz, 1992; Ambos-Spies et al., 1997), and p-betting-game random oracles using the betting games generalization of resource-bounded measure (Buhrman et al., 2000). Every p-betting-game random oracle is also p-random; whether the two notions are equivalent is an open problem. (1) We first show that P^A != NP^A for every oracle A that is p-betting-game random. Ideally, we would extend (1) to p-random oracles. We show that answering this either way would imply an unrelativized complexity class separation: (2) If P^A != NP^A relative to every p-random oracle A, then BPP != EXP. (3) If P^A = NP^A relative to some p-random oracle A, then P != PSPACE. Rossman, Servedio, and Tan (2015) showed that the polynomial-time hierarchy is infinite relative to a random oracle, solving a longstanding open problem. We consider whether we can extend (1) to show that PHA is infinite relative to oracles A that are p-betting-game random. Showing that PHA separates at even its first level would also imply an unrelativized complexity class separation: (4) If NP^A != coNP^A for a p-betting-game measure 1 class of oracles A, then NP != EXP. (5) If PH^A is infinite relative to every p-random oracle A, then PH != EXP.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

Bennett and Gill [3] initiated the study of random oracles in computational complexity, proving that for a random oracle , with probability 1. Subsequent work showed that this holds for individual random oracles. Book, Lutz, and Wagner [4] showed that for every oracle that is algorithmically random in the sense of Martin-Löf [14]. Lutz and Schmidt [13] improved this further to show for every oracle that is pspace-random [11].

We investigate whether this extends to individual polynomial-time random oracles [11, 2]. To show that for p-random oracles , we need to show that if , then there is a polynomial-time martingale that succeeds on . This means that if makes , then is somehow predictable or simple.

Allender and Strauss [1] proved that has p-measure 0, which implies that for every p-random oracle . This strengthens another result of Bennett and Gill [3] that holds for a random oracle , with probability 1. Allender and Strauss’s proof relies on derandomization [17] and is a different approach than Bennett and Gill. For vs oracles, the best known is the pspace-randomness result of Lutz and Schmidt [13]. In related work, Kautz and Miltersen [10] showed that if is an algorithmically random oracle, then does not have p-measure 0. Because the class has Hausdorff dimension 1 [8], there is a fundamental limit to how strongly a martingale can succeed on the class.

Each oracle is associated with a test language . This language is tally and if and only if in the tribes of strings following , there is at least one tribe contained in . (See Section 3 for a precise definition of . Bennett and Gill used a slightly different, but equivalent formulation of the test language.) It is clear that . From [3], we know that has Lebesgue measure 0. Since implies , it follows that has measure 0. We would like to show has p-measure 0.

Intuitively, if , we would like to predict membership of strings in . This would be relatively simple if the algorithm asked only nonadaptive queries. However, since the queries may be adaptive, there are potentially exponentially many queries – too many to be considered by a polynomial-time martingale.

The difficulty is martingales are forced to bet on strings in lexicographic order. Buhrman et al. [5] introduced an extension of resource-bounded measure using betting games. Betting games are similar to martingales but they may adaptively choose the order in which they bet on strings. Whether betting games are equivalent to martingales is an open question [5]. The adaptiveness in betting games allows us to simulate algorithms. We show in Section 3 that there is a p-betting game succeeding on . Therefore for every p-betting-game random oracle .

In Section 4, we consider whether there are limitations to extending the betting games result. We show that determining whether or not has polynomial-time measure 0 (with respect to martingales) would imply a separation of complexity classes:

  • If has -measure 0, then .

  • If does not have -measure 0, then .

This shows that determining the -measure of , or resolving whether for all -random , is likely beyond current techniques.

Bennett and Gill [3] also showed that for a random oracle , with probability 1. Rossman, Servedio, and Tan [18] answered a longtime open question [7] by extending Bennett and Gill’s result to separate every level of the polynomial-time hierarchy. They proved an average case depth hierarchy theorem for Boolean circuits which implies that the polynomial-time hierarchy is infinite relative to a random oracle. Can we show that is infinite relative to polynomial-time random oracles as well? We show that extending our main result to separate at even the first level would separate from :

  • If has -betting-game measure 0, then .

  • If is infinite relative to every -random oracle , then .

2 Preliminaries

We use standard notation. The binary alphabet is , the set of all binary strings is , the set of all binary strings of length is , and the set of all infinite binary sequences is . The empty string is denoted by . We use the standard enumeration of strings, , and the standard lexicographic ordering of strings corresponds to this enumeration. The characteristic sequence of a language is the sequence , where . We refer to as the characteristic bit of in . A language can alternatively be seen as a subset of , or as an element of via identification with its characteristic sequence . Given strings we denote by the set of all strings such that . For any string and number , is the string ; e.g. . Similarly we denote by the substring of the characteristic sequence that corresponds to the characteristic bits of the strings in .

2.1 Martingales and Betting Games

We now give a brief overview of martingales and betting games, and how they are applied in computational complexity to define resource-bounded measures and randomness notions. For further details, we refer to [11, 12, 2, 5, 6].

Betting games, which are also called nonmonotonic martingales, originated in the field of algorithmic information theory. In that setting they yield the notion of Kolmogorov-Loveland randomness (generalizing Kolmogorov-Loveland stochasticity) [16, 15]. The concept was introduced to computational complexity by Buhrman et al. [5]. First, we recall the definition of a martingale:

Definition.

A martingale is a function such that for all , we have the following averaging condition:

Intuitively, a martingale is betting in order on the characteristic sequence of an unknown language. The martingale starts with finite initial capital . The quantity represents the current capital the martingale has after betting on the first bits of a sequence that begins with . The quantities and represent the fraction of its current capital that the martingale is wagering on and , respectively, being the next bit of the sequence. This next bit is revealed and the martingale has in the case of a 0 and in the case of a 1.

Betting games are a generalization of martingales and have the additional capability of selecting which position in a sequence, or equivalently, which string in a language, to bet upon next. A betting game is permitted to select strings in a nonmonotone order, that is, it may bet on longer strings, then shorter strings, then longer strings again (with the important restriction that it may not bet on the same string twice). Like martingales, betting games must also satisfy the averaging law, i.e. the average of the betting game’s capital after betting on a string when belongs and when doesn’t belong to the language is the same as its capital before betting on . We use the following definition of a betting game from [5].

Definition.

A betting game

is an oracle Turing machine that maintains a “capital tape” and a “bet tape,” in addition to its standard query tape and worktapes. The game works in rounds

as follows. At the beginning of each round , the capital tape holds a nonnegative rational number . The initial capital is some positive rational number. computes a query string to bet on, a bet amount , and a bet sign . The computation is legal so long as does not belong to the set of strings queried in earlier rounds. ends round by entering a special query state. For a given oracle language , if and , or if and , then the new capital is given by , else by . We charge for the time required to write the numerator and denominator of the new capital down. The query and bet tapes are blanked, and G proceeds to round .

It is easy to see from the above definition that and can easily be computed from the current capital of the betting game. Therefore, we can equivalently define a betting game by describing the computation of the current capital without explicitly specifying the computation of and . We do this because it is clearer and more intuitive to describe the computation of the current capital of the betting game presented in the next section.

Definition.

If a betting game earns unbounded capital on a language (in the sense that for every constant there is a point at which the capital exceeds when betting on ), we say that succeeds on . The success set of a betting game , denoted , is the set of all languages on which succeeds. A betting game succeeds on a class of languages if .

By adding a resource bound on the computation of a betting game or martingale, we get notions of resource-bounded measure on . For this paper the resource bounds we use are , and . We say a class has -betting-game measure 0, if there is a -computable betting game that succeeds on every language in it. It has -measure 0 if the betting game is also a martingale [11]. A class has -betting-game measure 1 if has -betting-game measure 0. Similarly, has -measure 1 if has -measure 0. A language is -betting-game random if there is no -computable betting game that succeeds on . Similarly, is -random if there is no -computable martingale that succeeds on .

The ability of the betting game to examine a sequence nonmonotonically makes determining its running time complicated, since each language can induce a unique computation of the betting game. In other words, the betting game may choose to examine strings in different orders depending upon the language it is wagering against. Buhrman et al. looked at a betting game as an infinite process on a language, rather than a finite process on a string. They used the following definition:

Definition.

A betting game runs in time if for all languages , every query of length made by occurs in the first steps of the computation.

Specifically, once a -time-bounded betting game uses computational steps, it cannot go back and select any string of length . Most importantly, no polynomial-time betting game can succeed on the class .

2.2 Martingales and Betting Games: Intuitive view

Intuitively, a betting game can be viewed as the strategy of a gambler who bets on infinite sequence of strings. The gambler starts with initial capital , then begins to query strings to bet on. The gambler’s goal is to grow the capital without bound. The same view holds for martingales with the restriction that the gambler must bet on the strings in the standard ordering.

3 Betting Game Random Oracles

In this section we show that for every -betting-game random oracle.

Theorem 3.1.

The class has -betting-game measure 1. In particular, for every -betting-game random oracle .

Proof.

Given a language we define the test language

where is defined as follows. Given , first we view as concatenation of length strings ; i.e. is if and only if for some . Secondly, we view as the substring of the characteristic sequence of some language . With both views in mind, we define a tribe to be the set of strings whose characteristic bits are encoded by some . For example, given any , the set of strings is a tribe because its characteristic bits are encoded by . Since the strings in any tribe have length , an oracle machine can easily verify the membership of any , therefore . Now we define a betting game that succeeds on the set , thereby proving the theorem. Our betting game is going to simulate oracle Turing machines on some strings in the set . Let be an enumeration of all oracle TMs, where runs in time at most on inputs of length . The initial capital of is and we view it as composed of infinite “shares” that are used by to bet on some of the strings it queries.

Before we go into the details of the implementation of , we give a high level view. The strategy of to succeed on is quite simple. For any language , the cardinality of is either finite or infinite. When it is finite, after seeing a finite number of strings all following strings will belong to . uses “shares” reserved at its initialization to bet in this situation. On the other hand when it is infinite and we can find an oracle TM that decides . Most importantly this TM rejects its input infinitely often and it is only in this situation that we bet with the “shares”. Details follow.

First we specify the order in which queries strings followed by which strings it bets on. operates sequentially in stages . In stage , queries , where is the smallest integer such that all the strings queried in stage have length less than . then runs the oracle TM on , where is the number of TMs simulated in the previous stages whose output was inconsistent with in one of the previous stages. During the simulation of , answers any queries made by the TM either by looking up the string from its history, or if the string isn’t in its history, then queries it. After the simulation, queries in the standard lexicographic order all the strings in the tribes that follow that haven’t already been queried. Finally, to complete stage , queries all the remaining strings of length at most the length of the longest string queried by so far.

Now we specify which strings bets on and how it bets with the ’s and ’s. In stage , let and be such that is the Turing machine simulated in this stage and is the input it will be simulated on. The only strings bets on will be the strings following ; i.e. the tribes. We use and , two of the infinite “shares” of our initial capital reserved by for betting, where is the smallest positive integer such that . As will be shown later we do this because loses all of whenever . The “shares” and are dynamic and may have their values updated as we bet with them. Therefore, the current capital of after each bet is . Though we describe separately how bets with and , we may bet with both simultaneously. We bet with some for every stage, but with the ’s we bet only when the output of the simulated TM is . Therefore every time we bet with we also simultaneously bet with . First let us see how bets in stage using the and then with .

Betting with : Our choice of ensures that . In fact, will either increase, or reduce to after betting. If we lose in the current stage, then we use to bet in the next stage. uses to bet that at least one of the tribes that follow is completely contained in ; i.e. . Call this event . It is easy to see that for sufficiently large , when strings are included independently in with probability , the probability of event is

bets in such a way that whenever the sequence of strings seen satisfies the event , increases by a factor of approximately . If the sequence of strings does not satisfy event then loses all of and will bet with in the next stage.

We now elaborate on how increases by a factor of approximately when event occurs. Let represent the current status of strings in , indicates the status of string , indicates the string has not been queried by yet, and bits and have their usual meaning. Define

where is the probability a random language satisfies event , and is the conditional probability of the event given the current status of the strings as encoded by , i.e. given the strings in whose membership in has already been revealed, what is the probability that randomly assigning membership to other strings causes event to occur. This probability is rational and easy to compute in time by examining the status of the strings in each of the tribes in . is essentially a martingale. Whenever the membership of any string in is revealed, is then updated to . Given and , let denote with its symbol set to . It is easy to see that

For all sufficiently large ,

for any string that satisfies event and for those that do not satisfy . It is important to note that can always bet with no matter the order in which it requests the strings in that it bets on. But as will be shown next the ordering of these strings is important when betting with .

Betting with : Finally, we specify how bets with “share” which is reserved for betting with . only bets with when the simulation of on returns . In this situation bets that at least tribes of the tribes that follow are not contained in . For simplicity, does not bet on the tribes that queried. We denote by the event that all the tribes not queried by are not contained in . Event occurs with probability at most , and is almost the complement of . In this case bets similarly to how it bets with and increases by a factor of whenever the sequence of strings that follow satisfies . If the sequence does not satisfy then loses all of .

We now argue that succeeds on . Suppose and is the set of input strings simulates on some TMs in stages . Then there are two possibilities:

  1. Finitely many strings in do not belong to ,

  2. Infinitely many strings in do not belong to .

Denote by the string in . In the first case, there must be a such that for every stage , . Once we reach stage , uses a “share” of its capital to bet on belonging to for all . Therefore will increase by a factor of approximately for all but finitely many stages . Therefore the capital of will grow without bound in this case.

In the second case, we must reach some stage at which we use the correct oracle TM that decides on inputs in . From this stage onward will never change the TM it simulates on the strings in we have not seen yet. In this case we are guaranteed this simulation will output infinitely often. It follows by the correctness of and the definition of that whenever the output of is the “share” of the capital reserved for betting on will be increased by a factor of approximately . Since this condition is met infinitely often, it follows that the capital of increases without bound in this case also.

Finally we show that can be implemented as a -betting game; i.e. after time, will have queried all strings of length . First, we bound the runtime of each round of the betting game; i.e. the time required to bet on a string. This should not be confused with the stages of which include several rounds of querying. In each round, we have to compute the current capital of . This sum can easily be computed in time. This is because for each round we change at most two “shares” and to some rational numbers that can be computed in time. The remaining and “shares” with indices less than and respectively have values and those with indices grater than and respectively retain their initial values. We may also simulate a TM in each round. Since each simulated TM has it takes time for the simulation of on . Therefore, each round is completed in time. After the simulation requests all the remaining strings in that were not queried during the simulation. Therefore, it takes time for to have requested all strings of length . ∎

4 Limitations

In this section we examine the possibility of extending Theorem 3.1. We show that it cannot be improved to -random oracles or improved to separate the polynomial-time hierarchy without separating or from , respectively. On the other hand, showing that Theorem 3.1 cannot be improved to -random oracles would separate from .

4.1 Does for every -random oracle ?

We showed in Theorem 3.1 that for a -betting-game random oracle. It is unknown whether -betting games and -martingales are equivalent. If they are, then [5]. This is based on the following theorem and the result that -complete languages for have -betting-game measure 0 [5].

Theorem 4.1 (Buhrman et al. [5]).

If the class of -complete languages for has -measure zero then .

We show improving Theorem 3.1 to -random oracles would also imply . First, we prove the following for -measure.

Theorem 4.2.

If has -measure 1, then .

Proof.

If is any -complete language for , then

Therefore the class of -complete languages for is a subset of . If has -measure 0 then so does the class of -complete languages of . Theorem 4.1 implies that . ∎

We have the following for -random oracles by the universality of -measure for -measure [11].

Corollary 4.3.

If for every -random oracle , then .

Proof.

The hypothesis implies that every with is not -random, i.e. there is a -martingale that succeeds on . Let be a -martingale that is universal for all -martingales [11]: for every -martingale . Then succeeds on . ∎

4.2 Is it possible that for some -random oracle ?

Given Theorem 4.2, we consider the possibility of whether does not have -measure 0. Because Lutz and Schmidt [13] showed that this class has -measure 0, it turns out that if it does not have -measure 0, then we have a separation of from .

Theorem 4.4 (Lutz and Schmidt [13]).

The class has -measure 0.

We note that because every -betting game may be simulated by a -martingale [5], Theorem 4.4 follows as a corollary to Theorem 3.1.

Lemma 4.5.

If , then for every -martingale , there is a -martingale with .

Proof.

Let be a -martingale. Without loss of generality also assume that is exactly computable [9] and its output is in for some polynomial . Consider the language . Clearly and hence also in by our hypothesis. We can therefore compute is polynomial time using . ∎

Theorem 4.6.

If does not have -measure 0, then .

Proof.

Assume Theorem 4.4 and Lemma 4.5 imply that has -measure 0. ∎

Corollary 4.7.

If there is a -random oracle such that , then .

4.3 Is infinite relative to -betting-game random oracles?

Bennett and Gill [3] showed that for a random oracle , with probability 1. Thus does not collapse to its first level. Rossman, Servedio, and Tan [18] showed that is infinite relative to a random oracle, with probability 1.

Can we improve Theorem 3.1 to show that does not collapse for a -betting-game random oracle? This also has complexity class separation consequences:

Theorem 4.8.

For , let . If has -betting-game measure zero, then .

Proof.

We prove the contrapositive. Suppose , then . Given , then the following containments hold:

turn implies that . Since does not have -betting-game measure zero [5] then neither does . Hence, the Theorem follows. ∎

In particular, we have the following for the first level of PH:

Corollary 4.9.

If has p-betting-game measure 1, then .

Because it is open whether betting games have a union lemma [5], it is not clear whether Corollary 4.9 may be extended to show that if for every p-betting-game random oracle , then . This extension would hold if there is a -betting game that is universal for all -betting games. However, we do have the following for -random oracles.

Corollary 4.10.

If for every -random oracle , then .

Corollary 4.11.

If is infinite for every -random oracle , then .

5 Conclusion

We have shown that for every p-betting-game random oracle (Theorem 3.1). Establishing whether this also holds for p-random oracles would imply either (Corollary 4.3) or (Corollary 4.7). These results, together with Theorems 4.4 and 4.8, motivate investigating the status of relative to pspace-random oracles. In particular:

  1. Does have -measure 0?

  2. More generally, does have -measure 0?

References

  • [1] E. Allender and M. Strauss. Measure on small complexity classes with applications for BPP. In Proceedings of the 35th Symposium on Foundations of Computer Science, pages 807–818. IEEE Computer Society, 1994.
  • [2] K. Ambos-Spies and E. Mayordomo. Resource-bounded measure and randomness. In A. Sorbi, editor, Complexity, Logic and Recursion Theory, Lecture Notes in Pure and Applied Mathematics, pages 1–47. Marcel Dekker, New York, N.Y., 1997.
  • [3] C. H. Bennett and J. Gill. Relative to a random oracle , with probability 1. SIAM Journal on Computing, 10:96–113, 1981.
  • [4] R. V. Book, J. H. Lutz, and K. W. Wagner. An observation on probability versus randomness with applications to complexity classes. Mathematical Systems Theory, 27:201–209, 1994.
  • [5] H. Buhrman, D. van Melkebeek, K. W. Regan, D. Sivakumar, and M. Strauss. A generalization of resource-bounded measure, with application to the BPP vs. EXP problem. SIAM Journal on Computing, 30(2):576–601, 2001.
  • [6] R. C. Harkins and J. M. Hitchcock. Exact learning algorithms, betting games, and circuit lower bounds. ACM Transactions on Computation Theory, 5(4):article 18, 2013.
  • [7] J. Håstad. Almost optimal lower bounds for small depth circuits. In

    Proceedings of the Eighteenth Annual ACM Symposium on Theory of Computing

    , pages 6–20, 1986.
  • [8] J. M. Hitchcock. Hausdorff dimension and oracle constructions. Theoretical Computer Science, 355(3):382–388, 2006.
  • [9] D. W. Juedes and J. H. Lutz. Weak completeness in and . Theoretical Computer Science, 143(1):149–158, 1995.
  • [10] S. M. Kautz and P. B. Miltersen. Relative to a random oracle, NP is not small. Journal of Computer and System Sciences, 53(2):235–250, 1996.
  • [11] J. H. Lutz. Almost everywhere high nonuniform complexity. Journal of Computer and System Sciences, 44(2):220–258, 1992.
  • [12] J. H. Lutz. The quantitative structure of exponential time. In L. A. Hemaspaandra and A. L. Selman, editors, Complexity Theory Retrospective II, pages 225–254. Springer-Verlag, 1997.
  • [13] J. H. Lutz and W. J. Schmidt. Circuit size relative to pseudorandom oracles. Theoretical Computer Science, 107(1):95–120, March 1993.
  • [14] P. Martin-Löf. The definition of random sequences. Information and Control, 9:602–619, 1966.
  • [15] W. Merkle, J. S. Miller, A. Nies, J. Reimann, and F. Stephan. Kolmogorov-Loveland randomness and stochasticity. Annals of Pure and Applied Logic, 138(1–3):183–210, 2006.
  • [16] A. A. Muchnik, A. L. Semenov, and V. A. Uspensky. Mathematical metaphysics of randomness. Theoretical Computer Science, 207(2):263 – 317, 1998.
  • [17] N. Nisan and A. Wigderson. Hardness vs randomness. Journal of Computer and System Sciences, 49(2):149–167, 1994.
  • [18] B. Rossman, R. A. Servedio, and L.-Y. Tan. An average-case depth hierarchy theorem for boolean circuits. In Foundations of Computer Science (FOCS), 2015 IEEE 56th Annual Symposium on, pages 1030–1048. IEEE, 2015.