Abstract 1 Introduction 2 Definitions 3 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏 4 Which Karp–Lipton–style Collapse is Better? 5 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏 References

Upper and Lower Bounds for the Linear Ordering Principle

Edward A. Hirsch ORCID Department of Computer Science, Ariel University, Israel Ilya Volkovich ORCID Boston College, Chestnut Hill, MA, USA
Abstract

Korten and Pitassi (FOCS, 2024) defined a new111Note that this notation had been used in the past [45] for a very different class, which has been apparently forgotten after that. complexity class 𝐋𝟐𝐏 as the polynomial-time Turing closure of the Linear Ordering Principle (a total function extending finding the minimum of an order [18] to the case where the order is not linear). They put it between 𝐌𝐀 (Merlin–Arthur protocols) and 𝐒𝟐𝐏 (the second symmetric level of the polynomial hierarchy).

In this paper we sandwich 𝐋𝟐𝐏 between 𝐏𝐩𝐫𝐌𝐀 and 𝐏𝐩𝐫𝐒𝐁𝐏. (The oracles here are promise problems, and 𝐒𝐁𝐏 is the only known class between 𝐌𝐀 and 𝐀𝐌.) The containment in 𝐏𝐩𝐫𝐒𝐁𝐏 is proved via an iterative process that uses a 𝐩𝐫𝐒𝐁𝐏 oracle to estimate the average order rank of a subset and find the minimum of a linear order.

Another containment result of this paper is 𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏 (where 𝐎𝟐𝐏 is the input-oblivious version of 𝐒𝟐𝐏). These containment results altogether have several byproducts:

  • We give an affirmative answer to an open question posed by Chakaravarthy and Roy (Computational Complexity, 2011) whether 𝐏𝐩𝐫𝐌𝐀𝐒𝟐𝐏, thereby settling the relative standing of the existing (non-oblivious) Karp–Lipton–style collapse results of [15] and [12],

  • We give an affirmative answer to an open question of Korten and Pitassi whether a Karp–Lipton–style collapse can be proven for 𝐋𝟐𝐏,

  • We show that the Karp–Lipton–style collapse to 𝐏𝐩𝐫𝐎𝐌𝐀 is actually better than both known collapses to 𝐏𝐩𝐫𝐌𝐀 due to Chakaravarthy and Roy (Computational Complexity, 2011) and to 𝐎𝟐𝐏 also due to Chakaravarthy and Roy (STACS, 2006). Thus we resolve the controversy between previously incomparable Karp–Lipton collapses stemming from these two lines of research.

Keywords and phrases:
Complexity Classes, Structural Complexity Theory, Linear Ordering Principle, Symmetric Alternation, Merlin-Arthur Protocols, Karp-Lipton Collapse
Copyright and License:
[Uncaptioned image] © Edward A. Hirsch and Ilya Volkovich; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Complexity classes
; Theory of computation Problems, reductions and completeness ; Theory of computation Circuit complexity
Related Version:
Full Version: https://arxiv.org/abs/2503.19188
Acknowledgements:
The authors are grateful to Yaroslav Alekseev for discussing and to Dmitry Itsykson for discussing and proofreading a preliminary version of this paper. This research was conducted with the support of the State of Israel, the Ministry of Immigrant Absorption, and the Center for the Absorption of Scientists.
Editors:
Meena Mahajan, Florin Manea, Annabelle McIver, and Nguyễn Kim Thắng

1 Introduction

The seminal theorem of Richard M. Karp and Richard J. Lipton [32] connected non-uniform and uniform complexity by demonstrating a collapse of the Polynomial Hierarchy (𝐏𝐇) assuming 𝐍𝐏 has polynomial-size Boolean circuits. This collapse has since been very instrumental in transferring lower bounds against Boolean circuits of fixed-polynomial222That is, for any k, the class contains a language that cannot be computed by Boolean circuits of size nk, i.e. a language outside of 𝖲𝗂𝗓𝖾[nk]. size to smaller classes of 𝐏𝐇. Since then, these results were strengthened in many ways leading to “minimial” complexity classes that have such lower bounds and to which 𝐏𝐇 collapses.

1.1 Background

1.1.1 Classes Based on Symmetric Alternation

An important notion in this context is that of symmetric alternation. Namely, one of the best collapses was based on the following idea ([12], attributed to Sengupta): if polynomial-size circuits for SAT exist, two provers (defending the answers “yes” and “no”, respectively) send such circuits to a polynomial-time bounded verifier who can, in turn, use them to verify membership in any language in 𝐏𝐇. The corresponding class 𝐒𝟐𝐏 [13, 43] was thus shown to have fixed-polynomial circuit lower bounds. (In Section 2 we provide formal definitions for all less known classes we use.)

Indeed, since 𝐍𝐏𝐒𝟐𝐏, if SAT requires superpolynomial circuits, we are done. Otherwise, the Polynomial Hierarchy, which is known to contain “hard” languages (that is, for every k, 𝐏𝐇𝖲𝗂𝗓𝖾[nk]) by Kannan’s theorem [31], collapses to 𝐒𝟐𝐏 and so do these hard languages. This technique has been known as a win-win argument in the literature [31, 8, 34, 50, 12, 44, 15, 51, 26]. Chen et al. [17] prove that there is a bidirectional relationship between fixed-polynomial lower bounds and Karp–Lipton–style theorems. In the linear-exponential regime, while the win-win argument can be extended to obtain superpolynomial lower bounds for 𝐒𝟐𝐄 (the linear-exponential version of 𝐒𝟐𝐏), it falls short of achieving truly exponential lower bounds, as it encounters the so-called “half-exponential” barrier (see [40]).

Upon further inspection, one can observe that the presumed polynomial-size circuits for SAT do not actually depend on the input itself, but rather on its length. Based on this observation, the collapse was deepened to the input-oblivious version of 𝐒𝟐𝐏, called 𝐎𝟐𝐏 [14]. Yet, since 𝐎𝟐𝐏 is not known and, in fact, not believed to contain 𝐍𝐏, the fixed-polynomial lower bounds do not (immediately) carry over to 𝐎𝟐𝐏.

This state of affairs remained unchanged for about fifteen years until a significant progress was made when Kleinberg et al. [33] initiated the study of total functions beyond 𝐓𝐅𝐍𝐏. While Karp–Lipton’s theorem has not been improved, lower bounds against 𝖲𝗂𝗓𝖾[nk] were pushed down to 𝐎𝟐𝐏 [22] and 𝐋𝟐𝐏 [36], a new1 important class which we describe in more detail below. At the same time, truly exponential lower bounds were established for 𝐒𝟐𝐄 [38] (as it turns out, 𝐒𝟐𝐄=𝐎𝟐𝐄 [22]) and 𝐋𝟐𝐄 [36].

An important feature of these new results was that they were based on reducing finding a hard function to a total search problem. Namely, the works of Korten [35] and Li [38] reduced the question to the so-called Range Avoidance problem: given a function f:{0,1}n{0,1}m with m>n, represented by a Boolean circuit, find a point outside its image (this problem is known under the name dWPHP in the bounded arithmetic community and has implications in proof complexity, see [42, 28] and [37] for survey). In [16, 38], Range Avoidance has been reduced to symmetric alternation. Subsequently, Korten and Pitassi [36] reduced Range Avoidance to the Linear Ordering Principle: given an implicitly described ordering relation, either find the smallest element or report a breach of the linear order axioms (for the case of a linear order it is known as MIN in the bounded arithmetic community [18]). A polynomial-time Turing closure of this principle gave rise to a new class 𝐋𝟐𝐏𝐒𝟐𝐏: a version of 𝐒𝟐𝐏 where the two provers provide points of a polynomial-time verifiable linear order on binary strings of a certain length (each point starting with the corresponding answer 0 or 1), and the prover that provides the smaller element wins.

1.1.2 Classes Based on Merlin-Arthur Protocols

In a parallel line of research, the same questions were considered for classes based on Merlin–Arthur proofs: Santhanam [44] has shown fixed-polynomial lower bounds for promise problems possessing such proofs (i.e. the class 𝐩𝐫𝐌𝐀). In [15], Chakaravarthy and Roy have shown a Karp–Lipton–style collapse and thus fixed-polynomial size lower bounds for the class 𝐏𝐩𝐫𝐌𝐀. In particular, they presented a new upper bound for 𝐒𝟐𝐏 by showing that 𝐒𝟐𝐏𝐏𝐩𝐫𝐀𝐌. Nonetheless, the relationship between 𝐏𝐩𝐫𝐌𝐀 and the classes of symmetric alternation (including 𝐒𝟐𝐏, 𝐎𝟐𝐏, and then-unknown 𝐋𝟐𝐏) remained open.

Combining their upper bound for 𝐒𝟐𝐏 with a result of [3], that 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲 implies an “internal collapse” 𝐌𝐀=𝐀𝐌 (which goes through for the promise versions of the classes as well), [15] concluded that the Polynomial Hierarchy collapses all the way to 𝐏𝐩𝐫𝐌𝐀. Subsequently, by applying the win-win argument, they obtained fixed-polynomial bounds for 𝐏𝐩𝐫𝐌𝐀, which (unlike 𝐩𝐫𝐌𝐀) is a class of languages. It is to be noted though that since 𝐩𝐫𝐌𝐀 is not a class of languages – while 𝐏𝐩𝐫𝐌𝐀 is, there is no immediate way to carry any lower bound against 𝐩𝐫𝐌𝐀 over to 𝐏𝐩𝐫𝐌𝐀: it is not clear how to leverage (even) Turing reductions to construct a specific language consistent with a given promise problem.

Babai, Fortnow, and Lund [5] prove that if 𝐄𝐗𝐏𝐏/𝐩𝐨𝐥𝐲, then 𝐄𝐗𝐏=𝐌𝐀. Although this is a much larger class, the proof has the advantage that it does not relativize. More collapses in the exponential regime have been proved since then [27, 11], and the win-win argument yields superpolynomial lower bounds for some of them: 𝐌𝐀𝐄𝐗𝐏𝐏/𝐩𝐨𝐥𝐲 [10].

1.2 Promise Problems as Oracles

An important note is due on the use of a promise problem as an oracle, because the literature contains several different notions for this. The collapse result of Chakaravarthy and Roy that we use follows the loose oracle access mode adopted in [15]. Namely, oracle queries outside of the promise set are allowed and no particular behaviour of the computational model defining the promise class is expected on such queries. At the same time, the answer of the base machine using this oracle must be correct irrespective of the oracle’s answers to such queries, no assumption is made on the internal consistency of the answers outside of the promise set.

For deterministic polynomial-time oracle machines this approach is equivalent to querying any language consistent with the promise problem, that is, a language that contains all the “yes” instances and does not contain the “no” instances of the promise problem. One can also extend it to complexity classes: a class 𝒞 of languages is consistent with a class 𝒟 of promise problems if for every problem Π𝒟 there is a language L𝒞 consistent with Π. The equivalence between the approaches follows from the works of [24, 9], where the latter approach has been adopted. Nonetheless, we include a formal proof of this equivalence in the full version of the paper for the sake of completeness.

1.3 Our Contribution

In this paper we prove the inclusions 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏 and 𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏, which not only give new upper and lower bounds for 𝐋𝟐𝐏, but also demonstrate that the Karp–Lipton–collapse to 𝐏𝐩𝐫𝐎𝐌𝐀 is currently the best one both for symmetric–alternation–based and Merlin–Arthur–based classes of languages.

1.3.1 A New Lower Bound for 𝐋𝟐𝐏 and the Strongest Non-Input-Oblivious Karp–Lipton Collapse

Two open questions regarding symmetric alternation have been stated explicitly:

  • whether 𝐏𝐩𝐫𝐌𝐀 is contained in 𝐒𝟐𝐏 [15] (note that for these two classes Karp–Lipton style theorems have been proved by [15] and by Samik Sengupta [unpublished], respectively),

  • whether a Karp–Lipton–style theorem holds for 𝐋𝟐𝐏 [36].

In this paper we resolve both these questions affirmatively by showing the following containment. (Recall that 𝐋𝟐𝐏𝐒𝟐𝐏.)

Theorem 31.

𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏.

Combining this theorem with a result of Chakaravarthy and Roy [15] that 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲 implies the collapse 𝐏𝐇=𝐏𝐩𝐫𝐌𝐀, we obtain a Karp–Lipton–style collapse theorem for 𝐋𝟐𝐏, thus resolving an open question posed in [36].

Corollary.

If 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲, then 𝐏𝐇=𝐋𝟐𝐏=𝐏𝐩𝐫𝐌𝐀.

Together with the result of [12], it lines up all known non-input-oblivious classes for which a Karp–Lipton–style collapse has been shown: 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏𝐒𝟐𝐏𝐙𝐏𝐏𝐍𝐏𝚺𝟐𝐏.

1.3.2 A New Upper Bound for 𝐋𝟐𝐏

Another important result of this work is a new upper bound on 𝐋𝟐𝐏: we prove that 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏. The best known upper bound prior to our result followed from [36, 15]: 𝐋𝟐𝐏𝐒𝟐𝐏𝐏𝐩𝐫𝐀𝐌.

Theorem 22.

𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏.

Our two new inclusions (Th. 31 and 22) yield the non-input-oblivious part of Fig. 1.

Figure 1: Containments of classes based on Merlin–Arthur protocols and on symmetric alternation.

1.3.3 Aggregation of 𝐩𝐫𝐎𝟐𝐏 Queries and the Strongest Input-Oblivious Karp–Lipton Collapse

Th. 31 shows that 𝐏𝐩𝐫𝐌𝐀 is currently the smallest non-input-oblivious class for which a Karp–Lipton–style collapse is known. On the other hand, such a collapse was also shown for 𝐎𝟐𝐏 [14], which is input-oblivious. However, since the precise relationship between 𝐎𝟐𝐏 and 𝐏𝐩𝐫𝐌𝐀 remains unknown, one may ask: what is the strongest Karp–Lipton–style collapse? Our next result assists in navigating this question.

Theorem 25.

𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏.

We note that the “non-promise” version of this inclusion, i.e. 𝐏𝐎𝟐𝐏𝐎𝟐𝐏, was already established in [14]. However, this result does not carry over to the promise case. A similar phenomenon arises in the non-input-oblivious analogue of this question: while we know that 𝐏𝐒𝟐𝐏𝐒𝟐𝐏 [14], it still remains open whether 𝐏𝐩𝐫𝐒𝟐𝐏𝐒𝟐𝐏.

With this tool in hand, we can identify and show the strongest Karp–Lipton–style collapse that currently known. Namely, the collapse can be extended to 𝐏𝐩𝐫𝐎𝐌𝐀𝐏𝐩𝐫𝐌𝐀, where 𝐩𝐫𝐎𝐌𝐀 is the input-oblivious version of 𝐩𝐫𝐌𝐀 and therefore is contained in 𝐩𝐫𝐌𝐀. At the same time, Th. 25 allows us to show that 𝐏𝐩𝐫𝐎𝐌𝐀 is also contained in 𝐎𝟐𝐏, thus making 𝐏𝐩𝐫𝐎𝐌𝐀 smaller than both 𝐏𝐩𝐫𝐌𝐀 and 𝐎𝟐𝐏!

Th. 25 also helps us to tighten the chain of containments between 𝐏𝐩𝐫𝐎𝐌𝐀 and 𝐎𝟐𝐏 using a newly defined 𝐎𝐋𝟐𝐏 class, an input-oblivious analogue of 𝐋𝟐𝐏 (see Fig. 1).

1.4 Our Techniques

1.4.1 𝐒𝐁𝐏,𝐁𝐏𝐏𝐩𝐚𝐭𝐡, Approximate Counting, and Set Size Estimation

Computing the number of accepting paths of a given non-deterministic Turing machine is a fundamental problem captured by the “counting” class #𝐏. Yet, this class appears to be too powerful since, by Toda’s Theorem [49], even a single query to it suffices to decide any language in the polynomial hierarchy, 𝐏𝐇𝐏#𝐏[𝟏]! Given that, it is natural to explore approximations. To this end, one can consider the problem of Approximate Counting (ApproxCount for short) which refers to the task of approximating the number of accepting paths (within a constant factor). Equivalently, this problem can be framed as approximating the size of a set S represented as the set of satisfying assignments of a Boolean circuit C. Previously, it was shown that this task could be carried out by a randomized algorithm using an 𝐍𝐏 oracle (𝐅𝐁𝐏𝐏𝐍𝐏) [48, 30] and by a deterministic algorithm using a 𝐩𝐫𝐀𝐌 oracle (𝐅𝐏𝐩𝐫𝐀𝐌) [47, 23]. Shaltiel and Umans [46] show how to accomplish this task in 𝐅𝐏𝐍𝐏, yet under a derandomization assumption. We note that all of these algorithms can be implemented using parallel (i.e. non-adaptive) oracle queries. That is, in 𝐅𝐁𝐏𝐏𝐍𝐏,𝐅𝐏𝐩𝐫𝐀𝐌 and 𝐅𝐏𝐍𝐏, respectively. Jeřábek studies approximate counting in the context of bounded arithmetic and reduces to it many problems associated with complexity classes [29]. Approximate counting has also recently attracted considerable attention in the quantum literature [41, 1, 2, 39].

The decision version of the problem is to distinguish between two constant-factor estimates of the set size. For concreteness, consider the following problem called set-size estimation (or SSE for short): Given a set S (via a Boolean circuit C) and an integer m with the promise that either |S|m or |S|m/2, our goal is to decide which case holds. Interestingly, this problem is complete for the class 𝐒𝐁𝐏 (strictly speaking for the corresponding class of promise problems 𝐩𝐫𝐒𝐁𝐏) introduced in [7] by Böhler et al. as a relaxation of the class 𝐁𝐏𝐏 to the case when the acceptance probability is not required to be bounded away from 0. This relaxation, as was shown in [7], yields additional power: 𝐌𝐀𝐒𝐁𝐏𝐀𝐌. The class 𝐒𝐁𝐏, which stands for small bounded-error polynomial-time, thus sits strictly between the two fundamental classes based on Arthur–Merlin protocols, yet its definition is very different. Moreover, 𝐒𝐁𝐏 remains the only known natural class that lies between 𝐌𝐀 and 𝐀𝐌.

In terms of upper bounds, in a seminal paper [23], Goldwasser and Sipser have exhibited an Arthur–Merlin protocol not only for this problem, but also for the case when the set S is represented by a non-deterministic circuit! (A non-deterministic circuit C(x,w) accepts x if there exists a witness w for which C(x,w)=1.) This more general version of the problem (WSSE, where the set S is given via a non-deterministic circuit), is complete for the class 𝐩𝐫𝐀𝐌. (See Definition 12 for the formal definition of the problems; in fact, the factor-of-two gap in the estimates is arbitrary and can be replaced by any positive constant.) In fact, Goldwasser–Sipser’s protocol proves the containment both for languages (𝐒𝐁𝐏𝐀𝐌) and for promise problems (𝐩𝐫𝐒𝐁𝐏𝐩𝐫𝐀𝐌). At the same time, it is important to highlight the distinction between the two versions of the problem – i.e. for the “standard” (SSE) vs non-deterministic (WSSE) Boolean circuits – which appears to be (at the very least) non-trivial. Notably, the work of [7] established an oracle separation between 𝐒𝐁𝐏 and 𝐀𝐌.

On a similar note, by combining some of the previous techniques, we observe that ApproxCount can be carried out in 𝐅𝐏𝐩𝐫𝐒𝐁𝐏 rather than 𝐅𝐏𝐩𝐫𝐀𝐌, and, in fact, even in 𝐅𝐏𝐩𝐫𝐒𝐁𝐏. We describe the main idea in more details in Section 1.4.2. We defer the formal proof of this fact to the full version of the paper. Given this observation, it is natural to study the computational power of 𝐏ApproxCount, that is, deterministic algorithms with oracle access to ApproxCount. Indeed, an immediate corollary of the above is that 𝐏ApproxCount=𝐏𝐩𝐫𝐒𝐁𝐏 and 𝐏ApproxCount=𝐏𝐩𝐫𝐒𝐁𝐏. At the same, O’Donnell and Say [41] previously showed that 𝐏ApproxCount=𝐁𝐏𝐏𝐩𝐚𝐭𝐡, a complexity class defined earlier by Han et al. [25]. One can think of 𝐁𝐏𝐏𝐩𝐚𝐭𝐡 as a version of 𝐁𝐏𝐏 in which different computational paths (of the same probability) may have different lengths. Incidentally, it was established in [7] that 𝐁𝐏𝐏𝐩𝐚𝐭𝐡 can be obtained from 𝐁𝐏𝐏 via the so-called “postselection” and that 𝐒𝐁𝐏𝐁𝐏𝐏𝐩𝐚𝐭𝐡 (and resp. 𝐩𝐫𝐒𝐁𝐏𝐩𝐫𝐁𝐏𝐏𝐩𝐚𝐭𝐡). Putting all together, one arrives at the following three clusters of complexity classes associated with approximate counting:

𝐒𝐁𝐏𝐁𝐏𝐏𝐩𝐚𝐭𝐡=𝐏ApproxCount=𝐏𝐩𝐫𝐒𝐁𝐏𝐏ApproxCount=𝐏𝐩𝐫𝐒𝐁𝐏=𝐏𝐩𝐫𝐁𝐏𝐏𝐩𝐚𝐭𝐡,

where both inclusions are believed to be strict.

1.4.2 Approximate Counting and the Order Rank Approximation

The upper bound 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏 is obtained by developing a process that, given an arbitrary element in a linearly ordered set, rapidly converges to the set’s minimum.

Approximate counting using a 𝐩𝐫𝐒𝐁𝐏 oracle

We show how to deterministically approximate the number of satisfying assignments of a Boolean circuit, given oracle access to 𝐩𝐫𝐒𝐁𝐏 (i.e. in 𝐅𝐏𝐩𝐫𝐒𝐁𝐏), using parallel queries. Our algorithm is based on 𝐒𝐁𝐏 amplification that was used in [7, 52]. A crucial observation is that, as we need a multiplicative approximation (up to the factor 1+ε), it suffices to place the desired number between two consecutive powers of two; the correct place then could be found by either querying a 𝐩𝐫𝐒𝐁𝐏 oracle O(n/ε) times in parallel or (using binary search) O(log2(n/ε)) times sequentially. This result (Lemma 15) could be of independent interest.

Approximating the rank w.r.t. a linear order

The rank of an element α of a linearly ordered set U is the number of elements in this set that are strictly less than α (in particular, α is the minimum if and only if rank(α)=0). We can extend this definition to non-empty subsets SU, where rank(S) is the average rank of elements in S.

We reduce the problem of approximately comparing the average ranks of two sets to approximate counting. To see how, consider a strict linear order <E implicitly defined on U={0,1}n using a Boolean circuit E, and observe that for a non-empty subset SU, the average rank of S is exactly the size of the set of pairs {(υ,α)U×S|υ<Eα} divided by the size of S. Hence, this task can be carried out using a 𝐩𝐫𝐒𝐁𝐏 oracle.

An upper bound for the Linear Ordering Principle

As was mentioned, we develop a process that, given an arbitrary element in a linearly ordered set U={0,1}n, rapidly converges to the set’s minimum.

Given an element αU, we first define the set S as the set of all the elements less or equal to α. Formally, S:={x|xα}. Observe that rank(S)=rank(α)/2. We then iteratively partition S into two disjoint sets S0={xS|xi=0} and S1={xS|xi=1}, starting from i=1. By averaging argument, min{rank(S0),rank(S1)}rank(S). We then take S to be the subset (S0 or S1) with the smaller rank and continue to the next value of i. That is, we fix the bits of the elements of S one coordinate at a time. Therefore, once i=n, our “final” set S contains exactly one element β and thus at that point rank(S)=rank(β). On the other hand, as the rank of the “initial” S was rank(α)/2 and the overall rank could only decrease, we obtain that rank(β)rank(α)/2. We can then invoke the same procedure this time with β as its input. As the there are 2n elements in U, this process will converge to the set’s minimum after invoking the procedure at most n times, given any initial element.

The algorithm described above requires computing (or at least comparing) the average ranks of two sets. Our analysis demonstrates that a procedure for approximate comparison, developed before, is sufficient for the implementation of this idea (though the factor at each step will be a little bit less than 2).

1.4.3 Derandomization in 𝐋𝟐𝐏

In [36], Korten and Pitassi show that 𝐌𝐀𝐋𝟐𝐏. The inclusion 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏 essentially follows their argument with the additional observation that since 𝐋𝟐𝐏 is a syntactic class, not only it contains 𝐌𝐀 but it is also consistent with 𝐩𝐫𝐌𝐀. Thus one can first construct a pseudorandom generator using an 𝐋𝟐𝐏 oracle [35, 36] and then leverage it to derandomize the 𝐩𝐫𝐌𝐀 oracle not just in 𝐩𝐫𝐍𝐏, but actually in 𝐍𝐏𝐋𝟐𝐏! Therefore, 𝐏𝐩𝐫𝐌𝐀𝐏𝐋𝟐𝐏=𝐋𝟐𝐏.

We also observe that since the pseudorandom generator depends only on the input length (and not the input itself), derandomization also helps settling the relations between input-oblivious classes to a certain extent. The main difference is that unlike their non-oblivious counterparts, they do not posses all the desired properties w.r.t. Turing closure and natural containments. However, Th. 25 (its technique is described below) eventually helps us building the chain from 𝐏𝐩𝐫𝐎𝐌𝐀 to 𝐎𝟐𝐏 in two different ways: both directly and through derandomization and intermediate classes using 𝐎𝐋𝟐𝐏.

1.4.4 Input-Oblivious Symmetric Alternation

A Karp–Lipton–style collapse to 𝐏𝐩𝐫𝐎𝐌𝐀 follows from [15] by combining several previously known techniques. However, is this collapse stronger than the known collapse to 𝐎𝟐𝐏 [14]? The inclusion 𝐩𝐫𝐎𝐌𝐀𝐩𝐫𝐎𝟐𝐏 can be transferred from a somewhat similar statement that was proven in [14]; however, in order to prove 𝐏𝐩𝐫𝐎𝐌𝐀𝐎𝟐𝐏 we need also the inclusion 𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏, which seems novel. The main idea is that the two provers corresponding to the oracle give their input-oblivious certificates prior to the whole computation, and the verification algorithm performs a cross-check not only between the certificates of different provers but also between the certificates of the same prover, which allows us to simulate all oracle queries to 𝐩𝐫𝐎𝟐𝐏 in a single 𝐎𝟐𝐏 algorithm. Indeed, our approach is made possible by the input-oblivious nature of the computational model: while the oracle queries may be adaptive and not known in advance (due to potential queries outside of the promise set), the certificates are universal for the whole computation and nothing else is required.

1.5 Discussion and Further Research

1.5.1 Connections to “hard” functions

Starting from Karp–Lipton’s paper [32], Kannan’s fixed-polynomial circuit complexity lower bounds [31] have been improving accordingly to new collapses: if a new collapse 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲𝐏𝐇=𝒞 is shown for a class 𝒞 containing 𝐍𝐏, it immediately implies lower bounds for this class, because if 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲, we are already done.

However, a collapse to 𝐎𝟐𝐏 [14] did not imply lower bounds for 𝐎𝟐𝐏, because 𝐍𝐏 is unlikely to be contained in it (after all, 𝐎𝟐𝐏𝐏/𝐩𝐨𝐥𝐲). It was not until nearly two decades later that lower bounds for 𝐎𝟐𝐏 have been shown by Gajulapalli, Li, and Volkovich [22] building on recent progress for the range avoidance problem [35, 38], thus matching the progress on the two questions again.

Korten and Pitassi [36] have shown fixed-polynomial lower bounds for their new class 𝐋𝟐𝐏 without showing a collapse result, thereby introducing a misalignment once again, yet this time in the opposite direction. Our paper’s inclusion 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏 restores the balance.

However, the observation that in the input-oblivious world the currently best collapse 𝐏𝐩𝐫𝐎𝐌𝐀 reopens this question. Does this class possess fixed-polynomial circuit lower bounds? One can observe that Santhanam’s proof [44] of 𝖲𝗂𝗓𝖾[nk] lower bounds for promise problems in 𝐩𝐫𝐌𝐀 is input-oblivious. Indeed, the presented hard promise problems are actually in 𝐩𝐫𝐎𝐌𝐀! However, these promise problems do not yield a language in 𝐏𝐩𝐫𝐎𝐌𝐀 that is hard for 𝖲𝗂𝗓𝖾[nk], and we leave this question for further research.

The best class for which fixed-polynomial circuit lower bounds can be proved (trivially) is 𝐏ε-Hard-tt (for any particular fixed ε>0), where ε-Hard-tt, asks given 12n, to output a truth table of a function {0,1}n{0,1} of circuit complexity at least 2εn (Korten [35] defines a smoother version of it where the input length is not necessarily a power of two.) Can one prove a collapse to this class? Note that for the purpose of fixed-polynomial lower bounds even a limited version of ε-Hard-tt suffices where the truth table is non-empty for a number of entries greater than any polynomial and its complexity is only superpolynomial.

Switching to the linear-exponential regime, in [36], Korten and Pitassi have shown that 𝐋𝟐𝐄 – the exponential version of 𝐋𝟐𝐏 – contains a language of circuit complexity 2n/n. By translation, our upper bound scales as 𝐋𝟐𝐄𝐄𝐩𝐫𝐒𝐁𝐏=𝐄𝐩𝐫𝐁𝐏𝐏𝐩𝐚𝐭𝐡. As a corollary we obtain a new circuit lower bound for 𝐄𝐩𝐫𝐒𝐁𝐏 (and hence for 𝐄𝐩𝐫𝐁𝐏𝐏𝐩𝐚𝐭𝐡). To the best of our knowledge, the strongest previously established bound for this class was “half-exponential” that followed from the bound on 𝐌𝐀𝐄𝐗𝐏 [40].

Corollary.

𝐄𝐩𝐫𝐒𝐁𝐏 contains a language of circuit complexity 2n/n.

It is to be noted that this corollary could be viewed as an unconditional version of a result of Aydinliog̃lu et al. [4] as it recovers and strengthens their conclusion. In particular, [4] have shown the following (stated using slightly different terminology): if 𝐏𝐍𝐏 is consistent with 𝐩𝐫𝐀𝐌 or even 𝐩𝐫𝐒𝐁𝐏, then 𝐄𝐍𝐏 contains a language of circuit complexity 2n/n. Indeed, given the premises we obtain that 𝐄𝐩𝐫𝐒𝐁𝐏𝐄𝐏𝐍𝐏=𝐄𝐍𝐏 from which the claim follows directly by the corollary.

1.5.2 The smallest classes based on or containing Avoid

Similarly to 𝐋𝟐𝐏, one could define a class of languages reducible to Avoid. A similar class of search problems, 𝐀𝐏𝐄𝐏𝐏, has been defined by [33, 35] (and Korten [35] proved that constructing a hard truth table is a problem that is complete for this class under 𝐏𝐍𝐏-reductions); however, we are asking about a class of languages. Korten and Pitassi have shown that 𝐋𝟐𝐏 can be equivalently defined using many-one, Turing, or 𝐏𝐍𝐏-reductions, thus there are several options. One can observe that the containment 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏 (Th. 31) is essentially proved via the intermediate class 𝐏Avoid,𝐍𝐏 that uses both an oracle for Range Avoidance (a single-valued or an essentially unique [36] version) and an oracle for SAT. Can one prove that one of the containments in 𝐏𝐩𝐫𝐌𝐀𝐏Avoid,𝐍𝐏𝐋𝟐𝐏 is in fact an equality?

One can define an input-oblivious version 𝐎𝐋𝟐𝐏 of 𝐋𝟐𝐏, however, contrary to 𝐍𝐏𝐋𝟐𝐏, it is not obvious whether 𝐎𝐍𝐏𝐎𝐋𝟐𝐏 or even 𝐎𝐍𝐏𝐏𝐩𝐫𝐎𝐋𝟐𝐏. Still 𝐏𝐎𝐋𝟐𝐏𝐎𝟐𝐏𝐋𝟐𝐏. Nevertheless, one can extend the proof of 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏 to show 𝐏𝐩𝐫𝐌𝐀𝐏𝐎𝐋𝟐𝐏,𝐍𝐏𝐋𝟐𝐏 and 𝐏𝐩𝐫𝐎𝐌𝐀𝐏𝐎𝐋𝟐𝐏,𝐩𝐫𝐎𝐍𝐏𝐎𝟐𝐏𝐋𝟐𝐏. (These containments are included in Fig. 1, they give also an alternative proof of 𝐏𝐩𝐫𝐎𝐌𝐀𝐎𝟐𝐏 that still uses Th. 25.)

1.5.3 Some Unresolved Containments

  1. 1.

    Can one strengthen our inclusion 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏 to 𝐒𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏? One can try combining our techniques with the proof of 𝐒𝟐𝐏𝐏𝐩𝐫𝐀𝐌 by Chakaravarthy and Roy [15].

    Note that in the other direction it is open even whether 𝐒𝐁𝐏𝐒𝟐𝐏.

  2. 2.

    Chakaravarthy and Roy [15] asked whether 𝐏𝐩𝐫𝐌𝐀 and 𝐏𝐩𝐫𝐒𝟐𝐏 are contained in 𝐒𝟐𝐏. While we resolved the first question, the second one remains open. We note that, although in the input-oblivious world both inclusions hold (𝐏𝐩𝐫𝐎𝐌𝐀𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏, Cor. 26), the proof of the latter inclusion (Th. 25) is essentially input-oblivious (one needs to give all the certificates for the oracle non-adaptively, and queries cannot be predicted because oracle answers cannot be predicted for promise problems).

  3. 3.

    As was mentioned, the 𝐅𝐏𝐩𝐫𝐒𝐁𝐏 procedure for approximate counting can be implemented in 𝐅𝐏𝐩𝐫𝐒𝐁𝐏 – that is, using parallel (i.e. non-adaptive) oracle queries. On the other hand the containment 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏, which uses approximate counting as a black-box subroutine, seems to require sequential, adaptive queries. Could one implement the latter containment using parallel queries (i.e. show that 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏)? In particular, as 𝐏𝐏 is consistent with 𝐩𝐫𝐒𝐁𝐏 [7] and is closed under non-adaptive Turing reductions [20], this would imply that 𝐋𝟐𝐏𝐏𝐏. Note that it is unknown even whether 𝐏𝐍𝐏𝐏𝐏, while 𝐏𝐍𝐏𝐋𝟐𝐏. Moreover, there is an oracle separating the former two classes [6].

  4. 4.

    A recent work of Gajulapalli et al. [21] places 𝐋𝟐𝐏 in the class 𝐔𝐄𝐎𝐏𝐋𝐍𝐏 (where 𝐔𝐄𝐎𝐏𝐋 consists of problems that are many-one polynomial-time reducible to Unique-End-of-Potential-Line, see [19, 21]), which appears to be incomparable to our result (Th. 22). Can one determine the relative status of 𝐔𝐄𝐎𝐏𝐋𝐍𝐏 and 𝐏𝐩𝐫𝐒𝐁𝐏?

1.6 Organization of the Paper

The paper is organized as follows: In Section 2 we give the necessary definitions. Section 3 contains the proof of Th. 22 – a new upper bound on 𝐋𝟐𝐏. Section 4 contains the proof of Th. 25 which implies that collapse to 𝐏𝐩𝐫𝐎𝐌𝐀 subsumes both collapses to 𝐏𝐩𝐫𝐌𝐀 and to 𝐎𝟐𝐏. In Section 5 we prove Th. 31 answering open questions of [36] and [15].

2 Definitions

2.1 Promise Classes as Oracles

A promise problem is a relaxation of (the decision problem for) a language.

Definition 1 (promise problem).

Π=(ΠYES,ΠNO) is a promise problem if ΠYESΠNO=. We say that a language O is consistent with Π, if ΠYESO and ΠNOO¯.

Similarly to [15], when an oracle is described as a promise problem, we use loose access to the oracle. The outer Turing machine is allowed to make queries outside of the promise set, and the oracle does not need to conform to the definition of the promise oracle class for such queries. However, the outer Turing machine must return the correct answer irrespective of oracle’s behavior for queries outside of the promise set in particular, the oracle does not need to be consistent in its answers to the same query.

2.2 Problems Avoid and LOP

Definition 2 (Avoid [33, 35]).

Avoid is the following total search problem.

Input:

circuit C with n inputs and m>n outputs.

Output:

y{0,1}mImC.

This problem in a slightly different formulation is known for decades in the bounded arithmetic community under the name dWPHP (see [37] for survey).

Korten [35] proved that for a stretch of n+1 this problem is equivalent to a stretch of O(n) (and, of course, vice versa) using 𝐏𝐍𝐏 reductions.

The following definition is due to Korten and Pitassi [36]. It extends the definition of the search problem MIN of [18] by the case where the input relation is not a linear order.

Definition 3 (LOP, Linear Ordering Principle).

LOP is the following total search problem.

Input:

ordering relation <E given as a Boolean circuit E with 2n inputs.

Output:

either the minimum for <E (that is, x such that y{0,1}n{x}x<Ey) or a counterexample, if <E is not a strict linear order. A counterexample is either a pair satisfying x<Ey<Ex or a triple satisfying x<Ey<Ez<Ex.

2.3 Complexity Classes

The following two definitions have been suggested by Korten and Pitassi who also proved their equivalence [36].

Definition 4 (𝐋𝟐𝐏 via reductions).

A language L𝐋𝟐𝐏 if it can be reduced to LOP using a 𝐏𝐍𝐏-Turing reduction. (Polynomial-time Turing reductions and polynomial-time many-one reductions have the same effect, as proved in [36].)

The following is an alternative definition of 𝐋𝟐𝐏, which was shown in [36] to be equivalent.

Definition 5 (𝐋𝟐𝐏 via symmetric alternation).

A language L𝐋𝟐𝐏 if there is a ternary relation R{0,1}n×{0,1}s(n)×{0,1}s(n) computable in time s(n), where s is a polynomial, denoted Rx(u,v) for x{0,1}n, u,v{0,1}s(n), such that, for every fixed x, it defines a linear order on s(|x|)-size strings such that:

  • for every xL, the minimal element of this order starts with bit 1,

  • for every xL, the minimal element of this order starts with bit 0.

It is obvious that this version is a particular case of the definition of 𝐒𝟐𝐏 [13, 43]:

Definition 6.

A language L𝐒𝟐𝐏 if there is a polynomial-time computable relation R{0,1}n×{0,1}s(n)×{0,1}s(n), denoted Rx(u,v) for x{0,1}n, u,v{0,1}s(n), such that:

  • for every xL, there exists w(1) such that vRx(w(1),v)=1,

  • for every xL, there exists w(0) such that uRx(u,w(0))=0.

We now formally define the class 𝐎𝟐𝐏 [14], which is the input-oblivious version of 𝐒𝟐𝐏. Since we will need also a promise version of it, we start with defining this generalization.

Definition 7.

A promise problem Π=(ΠYES,ΠNO) belongs to 𝐩𝐫𝐎𝟐𝐏 if there is a polynomial-time deterministic Turing machine A such that for every n, there exist wn(0), wn(1) (called irrefutable certificates) that satisfy:

  • If xΠYES, then for every v, A(x,wn(1),v)=1,

  • If xΠNO, then for every u, A(x,u,wn(0))=0.

No assumption on the behaviour of A is made outside the promise set except that it stops (accepts or rejects) in polynomial time.

𝐎𝟐𝐏 is the respective class of languages (that is, it corresponds to the case of ΠYES=ΠNO¯).

We remind the definition of another oblivious promise class.

Definition 8.

A promise problem Π=(ΠYES,ΠNO) belongs to 𝐩𝐫𝐎𝐌𝐀 if there is a polynomial-time deterministic Turing machine A and, for every n, there exists wn (a witness that serves for every positive instance of length n) that satisfy the following conditions:

  • If xΠYES, then rA(x,r,wn)=1,

  • If xΠNO, then wPrr[A(x,r,w)=1]<1/2.

Finally, we define also an input-oblivious version of 𝐋𝟐𝐏.

Definition 9.

A language L belongs to 𝐎𝐋𝟐𝐏 if there is a polynomial p, polynomial-time deterministic Turing machine V computing a ternary predicate {0,1}n×{0,1}p(n)×{0,1}p(n) (we use the notation Vx(u,v) to denote its result), and two sequences of length-p(n) bit strings (yn)n, (zn)n such that

  • for every x, Vx is a strict linear order (define u<xv iff Vx(u,v)=1),

  • xL{0,1}n1yn=min<x,

  • xL¯{0,1}n0zn=min<x.

 Remark 10.

Note that unlike 𝐍𝐏𝐋𝟐𝐏, it is unclear whether 𝐎𝐍𝐏𝐎𝐋𝟐𝐏. Therefore, when we need both these input-oblivious classes, we need to specify both oracles.

We also define 𝐒𝐁𝐏 for the sake of self-completeness.

Definition 11 ([7]).

A language L is in 𝐒𝐁𝐏 if there exist ε>0, k, and a polynomial-time computable predicate B(x,r) such that

  • If xL then Prr[B(x,r)=1](1+ε)12nk,

  • If xL then Prr[B(x,r)=1](1ε)12nk.

where n=|x| and r is uniformly distributed on {0,1}n.

3 𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏

In this section we prove Th. 22. Our proof strategy is as follows: Given a point in a linear order, we aim to move “down the order” (i.e. towards “smaller” points). At each stage we will skip over a constant fraction of the points remaining on our way to the minimum. In order to find the next point, we will employ a binary-search-like procedure to determine the bits of the desired point, one coordinate at a time. Here is where our 𝐩𝐫𝐒𝐁𝐏 oracle comes into play: At each step, we look at the remaining set of points partitioned into two subsets: the points where the appropriate bit is 0 and where that bit is 1, and select the subset with the (approximately) smaller average rank.

Before we proceed with the main algorithm, we show how to approximate the size of a set using a 𝐩𝐫𝐒𝐁𝐏 oracle. This procedure could be of independent interest.

3.1 Approximate Counting

In this section we observe that one can approximate deterministically the number of satisfying assignments for a Boolean circuit with a 𝐩𝐫𝐒𝐁𝐏 oracle (in 𝐅𝐏𝐩𝐫𝐒𝐁𝐏). Previously, it was shown that this task could be carried out by a randomized algorithm with an 𝐍𝐏 oracle (𝐅𝐁𝐏𝐏𝐍𝐏) [48, 30] and by a deterministic algorithm with a 𝐩𝐫𝐀𝐌 oracle (𝐅𝐏𝐩𝐫𝐀𝐌) [47, 23]. Note that 𝐩𝐫𝐒𝐁𝐏/𝐩𝐫𝐀𝐌 queries can be thought of as queries to specific promise problems.

Definition 12 (Set-Size Estimation, SSE and WSSE).

Let C be a Boolean circuit and m1 be an integer given in binary representation. Then SSE:=(SSEYES,SSENO), where SSEYES={(C,m)|#xC(x)m},SSENO={(C,m)|#xC(x)m/2}.

If C is a non-deterministic circuit, we denote the corresponding problem by WSSE.

These two promise problems are complete for promise classes 𝐩𝐫𝐒𝐁𝐏 and 𝐩𝐫𝐀𝐌, respectively. This is proved essentially in [7] and [23] and formulated explicitly in [52].

Lemma 13 (Implicit in [7]).

SSE is 𝐩𝐫𝐒𝐁𝐏-complete.

Lemma 14 (Implicit in [23]).

WSSE is 𝐩𝐫𝐀𝐌-complete.

In particular, these complete problems showcase that 𝐩𝐫𝐒𝐁𝐏𝐩𝐫𝐀𝐌. The following lemma implies that ApproxCount𝐅𝐏𝐩𝐫𝐒𝐁𝐏 and, in fact, provides a slightly stronger result in the form of one-sided approximation.

Lemma 15.

There exists a deterministic algorithm that given a Boolean circuit C on n variables and a rational number ε>0 outputs an integer number t satisfying

#xCt4ε/3#xC(1+ε)#xC

in time polynomial in n, the size of C and 1ε, making non-adaptive oracle queries to SSE.

The result appears to follow from a combination of previous techniques (and is considered “folklore”). We provide the proof in the full version of the paper.

3.2 Estimating the Average Rank w.r.t. a Linear Order

Let U={0,1}n. A single-output 2n-input Boolean circuit E induces an ordering relation <E on U as x<EyE(x,y)=1. If <E is a strict linear order, we call E a linear order circuit.

Observation 16.

There exists a deterministic Turing machine with SAT oracle that, given a circuit E on 2n variables, stops in time polynomial in n and the size of E and does the following: if E is a linear order circuit, it outputs “yes”; otherwise, it outputs a counterexample: a pair satisfying x<Ey<Ex or a triple satisfying x<Ey<Ez<Ex.

Fix any strict linear order < on U.

Definition 17.

For an element αU we define its rank as rank(α):=|{xU|x<α}|. We can extend this definition to non-empty subsets SU of U by taking the average rank: define rank(S):=xSrank(x)|S|. If S={xU|C(x)=1} is described by a circuit C, we use the same notation: rank(C)=rank(S).

Below are some useful observations that we will use later.

Observation 18.
  • For a non-empty subset SU: |{(υ,α)U×S|υ<α}|=|S|rank(S).

  • For any αU: rank{υU|υα}=rank(α)/2.

  • Let S0,S1U be two non-empty disjoint subsets of U. Then

    rank(S0S1)=|S0|rank(S0)+|S1|rank(S1)|S0|+|S1|.
Proof.
  • |{(υ,α)U×S|υ<α}|=αS|{(υ,α)|Uυ<α}|=αSrank(α)=|S|rank(S).

  • rank{υU|υα}=1rank(α)+1υαrank(υ)=1rank(α)+1rank(α)(rank(α)+1)2=rank(α)2.

  • rank(S0S1)=1|S0|+|S1|(xS0rank(x)+yS1rank(y))=|S0|rank(S0)+|S1|rank(S1)|S0|+|S1|.

In the following lemma the rank is defined w.r.t. the order <E described by a linear order circuit E. This lemma allows us to estimate the rank of a set using a 𝐩𝐫𝐒𝐁𝐏 oracle.

Lemma 19.

There exists a deterministic algorithm that given a Boolean circuit C on n variables, a linear order circuit E on 2n variables, and an ε>0, outputs a rational number r satisfying 4εrank(C)r4εrank(C) in time polynomial in n, the sizes of C and E, and in 1ε, given oracle access to SSE.

Proof.

Consider a circuit D(x,y):=C(y)E(x,y). That is, y is accepted by C and x<Ey. By Observation 18, #(x,y)D=#xCrank(C). By Lemma 15 we can compute integers tC and tD that approximate the numbers #xC and #(x,y)D, respectively. Formally,

#xCtC4ε#xC and #(x,y)DtD4ε#(x,y)D.

Therefore we obtain: 4εrank(C)#(x,y)D4ε#xCtDtC4ε#(x,y)D#xC=4εrank(C).

3.3 Finding the Minimum Using a 𝐩𝐫𝐒𝐁𝐏 Oracle

We use the approximation algorithms developed above in order to find an element that is much closer to the minimum than a given element. The following lemma describes the procedure Back that given an element α finds another element β whose rank is smaller by a constant factor. We will use this procedure afterwards in order to find the minimum in a polynomial number of iterations.

The procedure proceeds by computing the bits of the new element, one at a time, using a 𝐩𝐫𝐒𝐁𝐏 oracle. The rank is w.r.t. the order <E described by a linear order circuit E.

Lemma 20.

There exists a deterministic algorithm Back that given a linear order circuit E on 2n variables and an element α{0,1}n, outputs an element β{0,1}n such that rank(β)rank(α)2, in time polynomial in n and the size of E, given oracle access to SSE.

Proof.

Consider the following procedure:

Back(E,α):

After each iteration one more variable xi gets its value βi and is substituted into C, that is, in the current circuit C variables x1,,xi are replaced by the corresponding constants β1,,βi. We claim that after each iteration the rank of the resulting circuit is bounded from the above: rank(C)42εirank(α)2.

Indeed, by Observation 18, before the first iteration, we have that rank(C)=rank(α)2. Now consider any iteration. If C1 or C0 are empty, then rank(C) remains the same and 42εi42ε(i+1). Otherwise, by Lemma 19, for b{0,1}, 4εrank(Cb)rb4εrank(Cb). If r1r0 then rank(C1)r14εr04εrank(C0)42ε and therefore by Observation 18: rank(C)=#xC0rank(C0)+#xC1rank(C1)#xC0+#xC1#xC0rank(C0)+#xC1rank(C0)42ε#xC0+#xC1rank(C0)42ε.

Equivalently, rank(C0)rank(C)42ε. Similarly, if r1<r0 then rank(C1)rank(C)42ε. Therefore, at each step the rank is multiplied at most by 42ε.

Consequently, after the n-th iteration, C represents the set that contains only the element β and we have that rank(β)42εnrank(α)/22rank(α)/2=rank(α)/2.

For the runtime, all the steps can be carried out in time polynomial in n and 1ε=O(n).

Note that the procedure Back has a unique fixed point, namely, the minimal element.

Observation 21.

Back(E,α)=α if and only if α is the minimal element in E.

Proof.

rank(α)=0rank(α)rank(α)/2.

We are now ready to prove the main result of this section.

Theorem 22.

𝐋𝟐𝐏𝐏𝐩𝐫𝐒𝐁𝐏.

Proof.

It suffices to provide a deterministic polynomial-time algorithm that solves LOP given oracle access to 𝐩𝐫𝐒𝐁𝐏. Let E be a 2n-input circuit. We give an algorithm for LOP.

  1. 1.

    Check that E is indeed a linear order using Observation 16.

  2. 2.

    Let α:=0n,β:=1n.

  3. 3.

    While αβ repeat: α:=β,β:=Back(E,α).

  4. 4.

    Output α.

Given Observation 16, we can assume w.l.o.g. that E is a linear order circuit. We claim that the algorithm will output the minimal element after at most 2n iterations. Indeed, by Lemma 20, the rank of the element α after 2n iterations satisfies rank(α)rank(1n)22n2n12n<1, thus the “While” cycle will terminate before that.

4 Which Karp–Lipton–style Collapse is Better?

Chakaravarthy and Roy proved two Karp–Lipton–style collapses: down to 𝐎𝟐𝐏 [14] and down to 𝐏𝐩𝐫𝐌𝐀 [15]. These two classes seem to be incomparable thereby rising the question: which collapse result is stronger? We observe that the collapse to 𝐏𝐩𝐫𝐌𝐀 can actually be deepened to 𝐏𝐩𝐫𝐎𝐌𝐀, where 𝐩𝐫𝐎𝐌𝐀 is the oblivious version of 𝐩𝐫𝐌𝐀 – and subsequently show that latter class is contained in both previous classes. That is, 𝐏𝐩𝐫𝐎𝐌𝐀𝐏𝐩𝐫𝐌𝐀𝐎𝟐𝐏. Indeed, the “internal collapse” of 𝐩𝐫𝐌𝐀 (and, in fact, even 𝐩𝐫𝐀𝐌) to 𝐩𝐫𝐎𝐌𝐀, under the assumption that 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲, is implicit in [3]. Nonetheless, we include a formal proof of this fact in the full version of the paper.

Proposition 23.

If 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲, then 𝐩𝐫𝐀𝐌𝐩𝐫𝐎𝐌𝐀 and 𝐏𝐇=𝐏𝐩𝐫𝐎𝐌𝐀.

We prove that this class is not only included in 𝐏𝐩𝐫𝐌𝐀 but also in 𝐎𝟐𝐏 in two steps: (1) 𝐩𝐫𝐎𝐌𝐀𝐩𝐫𝐎𝟐𝐏, (2) 𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏. The first inclusion is essentially proved in [14, Theorem 3], which says that 𝐌𝐀𝐍𝐎𝟐𝐏. One needs to notice that the proof goes through for promise classes with all certificates being input-oblivious.

Proposition 24.

𝐩𝐫𝐎𝐌𝐀𝐩𝐫𝐎𝟐𝐏.

The second inclusion seems novel and we prove this result now:

Theorem 25.

𝐏𝐩𝐫𝐎𝟐𝐏𝐎𝟐𝐏.

 Remark.

Formally, we show that 𝐏Π𝐎𝟐𝐏 for every promise problem Π𝐩𝐫𝐎𝟐𝐏.

Proof.

Let L𝐏Π and let M be a deterministic oracle machine that decides L correctly given loose oracle access to Π (i.e. irrespective of the answers to its queries outside of the promise set), in time p(n) (for a polynomial p). Consider the polynomial-time deterministic verifier A(q,u,v) from the definition of Π𝐩𝐫𝐎𝟐𝐏. For n, let 1,,p(n) be all possible lengths of oracle queries made by M given an input of length n. Define Wn:=(w1(0),,wp(n)(0),w1(1),,wp(n)(1)) as a vector containing the irrefutable certificates (both “yes” and “no”) of A for the appropriate input lengths. We now construct a new polynomial-time deterministic verifier A(x,U,V) that will demonstrate that L𝐎𝟐𝐏 and will show that, for any x, the string W|x| constitutes an irrefutable certificate that can be used both as U=(u1(0),,up(n)(0),u1(1),,up(n)(1)) and as V=(v1(0),,vp(n)(0),v1(1),,vp(n)(1)).

Given (x,U,V) as an input, A will simulate M. Whenever M makes an oracle query q to Π, A will compute four bits:

a:=A(q,u|q|(1),v|q|(0)), b:=A(q,v|q|(1),u|q|(0)),
c:=A(q,u|q|(1),u|q|(0)), d:=A(q,v|q|(1),v|q|(0)),

and will proceed with the simulation of M as if the oracle answered :=(ac)(bd).

By definition, for any x, the machine M computes L(x) correctly given the correct answers to the queries in the promise set (i.e. qΠYESΠNO) and irrespective of the oracle’s answers outside of the promise set. Thus it suffices to prove that the oracle’s answers to the queries in the promise set are computed correctly, which we show by inspecting the four possible cases:

  • Suppose xL and U=W|x|.

    • If qΠYES then u|q|(1) is a “yes”-irrefutable certificate and hence a=c=1=1.

    • If qΠNO then u|q|(0) is a “no”-irrefutable certificate and hence b=c=0=0.

  • Suppose xL and V=W|x|.

    • If qΠYES then v|q|(1) is a “yes”-irrefutable certificate and hence b=d=1=1.

    • If qΠNO then v|q|(0) is a “no”-irrefutable certificate and hence a=d=0=0.

Corollary 26.

𝐏𝐩𝐫𝐎𝐌𝐀𝐎𝟐𝐏.

 Remark 27.

When a semantic class without complete problems is used as an oracle, it may be ambiguous. However, 𝐩𝐫𝐀𝐌 does have a complete problem WSSE (see Definition 12). By inspecting the proof of the collapse (Prop. 23) one can observe that WSSE actually belongs to 𝐩𝐫𝐎𝐌𝐀 under 𝐍𝐏𝐏/𝐩𝐨𝐥𝐲, and the oracle Turing machine that demonstrates 𝐏𝐇=𝐏𝐩𝐫𝐎𝐌𝐀 still queries a specific promise problem.

For the inclusion of 𝐏𝐩𝐫𝐎𝐌𝐀 in 𝐎𝟐𝐏, the first part (Prop. 24) transforms one promise problem into another promise problem, thus in the inclusion 𝐏𝐩𝐫𝐎𝐌𝐀𝐏𝐩𝐫𝐎𝟐𝐏 it is also the case that a single oracle is replaced by (another) single oracle.

5 𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏

In this section we prove Th. 31 by, essentially, expanding the proof of 𝐌𝐀𝐋𝟐𝐏 in [36]. We use the following statements from that paper and an earlier paper by Korten [35]. We then proceed to the input-oblivious setting.

5.1 The non-input-oblivious setting

Definition 28 ([35, Definitions 6, 7]).

PRG is the following search problem: given 1n, output a pseudorandom generator R=(x1,,xm), that is, an array of strings xi{0,1}n such that for every n-input circuit C of size n, |PrxU(R){C(x)=1}PryU({0,1}n){C(y)=1}|1n.

Korten proves that such a generator containing m=n6 strings can be constructed with a single oracle query to Avoid (he refer to it as “Empty”), and Korten and Pitassi demonstrate that Avoid (which they call Weak Avoid) can be solved with one oracle query to LOP.

Proposition 29 ([35, Th. 2]).

PRG reduces in polynomial time to a single Avoid query.

Proposition 30 ([36, Th. 1]).

Avoid is polynomial-time many-one reducible to LOP.

The main result of this section is the following theorem.

Theorem 31.

𝐏𝐩𝐫𝐌𝐀𝐋𝟐𝐏.

Proof.

We show how to replace 𝐩𝐫𝐌𝐀 by 𝐋𝟐𝐏. Since 𝐏𝐋𝟐𝐏=𝐋𝟐𝐏 by Def. 4, the result follows.

One can assume that calls to the 𝐩𝐫𝐌𝐀 oracle are made for input lengths such that Arthur can be replaced by a circuit A(x,w,r) of size at most s(n) for a specific polynomial s. One can assume perfect completeness for A, that is, for x in the promise set “YES”, there is w such that rA(x,w,r)=1.

Before simulating the 𝐩𝐫𝐌𝐀 oracle, our deterministic polynomial-time Turing machine will make oracle calls to 𝐋𝟐𝐏 in order to build a pseudorandom generator sufficient to derandomize circuits of size s(n). By Prop. 29, such a pseudorandom generator G, which is a sequence G(1s(n)) of pseudorandom strings g1,,gm{0,1}s(n) for m bounded by a polynomial in s(n), can constructed (for m=s(n)6 and error 1s(n)) using a reduction to Avoid. Subsequently, by Prop. 30, Avoid is reducible to LOP. As a result, {gi}i=1m can be computed in deterministic polynomial time by querying an 𝐋𝟐𝐏 oracle.

After G is computed, each call to the 𝐩𝐫𝐌𝐀 oracle can be replaced by an 𝐍𝐏𝐋𝟐𝐏 query wC(w) for the circuit C that computes the conjunction of the circuits A(x,w,gi) with hardwired x and gi, for every i. Note that such queries constructed for x outside of the promise set are still valid 𝐍𝐏 queries even if Arthur does not conform to the definition of 𝐌𝐀 in this case. These oracle answers are irrelevant, because the original 𝐏𝐩𝐫𝐌𝐀 machine must return the correct (in particular, the same) answer irrespectively of the oracle’s answer.

5.2 The input-oblivious setting

Korten proves (Prop. 29) that PRG (Def. 28) reduces to Avoid, and Korten and Pitassi [36] compute Avoid in 𝐋𝟐𝐏=𝐏𝐋𝟐𝐏. Since PRG has a unary input, one can observe that PRG can be computed using an input-oblivious oracle. This gives raise to tighter containments. Indeed, in the non-input oblivious setting this containments become equalities. However, input-oblivious classes lack some of the nice closure properties and therefore require a special treatment.

Lemma 32.

PRG can be computed in deterministic polynomial time with an 𝐎𝐋𝟐𝐏 oracle.

Corollary 33.

.

  1. 1.

    𝐏𝐩𝐫𝐌𝐀𝐏𝐎𝐋𝟐𝐏,𝐍𝐏𝐋𝟐𝐏.

  2. 2.

    𝐏𝐩𝐫𝐎𝐌𝐀𝐏𝐎𝐋𝟐𝐏,𝐩𝐫𝐎𝐍𝐏𝐎𝟐𝐏𝐋𝟐𝐏.

References

  • [1] S. Aaronson, R. Kothari, W. Kretschmer, and J. Thaler. Quantum lower bounds for approximate counting via Laurent polynomials. In 35th Computational Complexity Conference, CCC 2020, July 28-31, 2020, Saarbrücken, Germany (Virtual Conference), volume 169 of LIPIcs, pages 7:1–7:47. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.CCC.2020.7.
  • [2] S. Aaronson and P. Rall. Quantum approximate counting, simplified. In Martin Farach-Colton and Inge Li Gørtz, editors, 3rd Symposium on Simplicity in Algorithms, SOSA 2020, pages 24–32. SIAM, 2020. doi:10.1137/1.9781611976014.5.
  • [3] V. Arvind, J. Köbler, U. Schöning, and R. Schuler. If NP has polynomial-size circuits, then MA=AM. Theor. Comput. Sci., 137(2):279–282, 1995. doi:10.1016/0304-3975(95)91133-B.
  • [4] B. Aydinliog̃lu, D. Gutfreund, J. M. Hitchcock, and A. Kawachi. Derandomizing arthur-merlin games and approximate counting implies exponential-size lower bounds. Comput. Complex., 20(2):329–366, 2011. doi:10.1007/s00037-011-0010-8.
  • [5] L. Babai, L. Fortnow, and C. Lund. Non-deterministic exponential time has two-prover interactive protocols. Computational Complexity, 1:3–40, 1991. doi:10.1007/BF01200056.
  • [6] R. Beigel. Perceptrons, PP, and the polynomial hierarchy. Computational Complexity, 4:339–349, 1994. doi:10.1007/BF01263422.
  • [7] E. Böhler, C. Glaßer, and D. Meister. Error-bounded probabilistic computations between MA and AM. J. Comput. Syst. Sci., 72(6):1043–1076, 2006. doi:10.1016/J.JCSS.2006.05.001.
  • [8] N. H. Bshouty, R. Cleve, R. Gavaldà, S. Kannan, and C. Tamon. Oracles and queries that are sufficient for exact learning. J. Comput. Syst. Sci., 52(3):421–433, 1996. doi:10.1006/JCSS.1996.0032.
  • [9] H. Buhrman and L. Fortnow. One-sided versus two-sided error in probabilistic computation. In STACS, pages 100–109, 1999.
  • [10] H. Buhrman, L. Fortnow, and T. Thierauf. Nonrelativizing separations. In Proceedings of the 13th Annual IEEE Conference on Computational Complexity (CCC), pages 8–12, 1998.
  • [11] H. Buhrman and S. Homer. Superpolynomial circuits, almost sparse oracles and the exponential hierarchy. In Foundations of Software Technology and Theoretical Computer Science, 12th Conference, New Delhi, India, December 18-20, 1992, Proceedings, pages 116–127, 1992. doi:10.1007/3-540-56287-7_99.
  • [12] J.-Y. Cai. S2PZPPNP. Journal of Computer and System Sciences, 73(1):25–35, 2007.
  • [13] R. Canetti. More on BPP and the polynomial-time hierarchy. Inf. Process. Lett., 57(5):237–241, 1996. doi:10.1016/0020-0190(96)00016-6.
  • [14] V. T. Chakaravarthy and S. Roy. Oblivious symmetric alternation. In STACS, pages 230–241, 2006.
  • [15] V. T. Chakaravarthy and S. Roy. Arthur and Merlin as oracles. Comput. Complex., 20(3):505–558, 2011. doi:10.1007/s00037-011-0015-3.
  • [16] L. Chen, S. Hirahara, and H. Ren. Symmetric exponential time requires near-maximum circuit size. In Proceedings of the 56th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2024, to appear. Association for Computing Machinery, 2024.
  • [17] L. Chen, D. M. McKay, C. D. Murray, and R. R. Williams. Relations and equivalences between circuit lower bounds and Karp-Lipton theorems. In CCC-2019, LIPICS, pages 30:1–21, 2019.
  • [18] M. Chiari and J. Krajíček. Witnessing functions in bounded arithmetic and search problems. The Journal of Symbolic Logic, 63(3):1095–1115, 1998. doi:10.2307/2586729.
  • [19] John Fearnley, Spencer Gordon, Ruta Mehta, and Rahul Savani. Unique end of potential line. Journal of Computer and System Sciences, 114:1–35, 2020. doi:10.1016/J.JCSS.2020.05.007.
  • [20] L. Fortnow and N. Reingold. PP is closed under truth-table reductions. Inf. Comput., 124(1):1–6, 1996. doi:10.1006/inco.1996.0001.
  • [21] K. Gajulapalli, S. Ghentiyala, Z. Li, and S. Saraogi. Downward self-reducibility in the total function polynomial hierarchy. Electron. Colloquium Comput. Complex., TR25-121, 2025. URL: https://eccc.weizmann.ac.il/report/2025/121.
  • [22] K. Gajulapalli, Z. Li, and I. Volkovich. Oblivious complexity classes revisited: Lower bounds and hierarchies. In 44th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science, FSTTCS 2024, volume 323 of LIPIcs, pages 23:1–23:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.FSTTCS.2024.23.
  • [23] S. Goldwasser and M. Sipser. Private coins versus public coins in interactive proof systems. In Proceedings of the 18th Annual ACM Symposium on Theory of Computing (STOC), pages 59–68, 1986.
  • [24] J. Grollmann and A. L. Selman. Complexity measures for public-key cryptosystems. SIAM J. Comput., 17(2):309–335, 1988. doi:10.1137/0217018.
  • [25] Y. Han, L. A. Hemaspaandra, and T. Thierauf. Threshold computation and cryptographic security. SIAM J. Comput., 26(1):59–78, 1997. doi:10.1137/S0097539792240467.
  • [26] R. Impagliazzo, V. Kabanets, and I. Volkovich. Synergy between circuit obfuscation and circuit minimization. In APPROX/RANDOM 2023, volume 275 of LIPIcs, pages 31:1–31:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.APPROX/RANDOM.2023.31.
  • [27] R. Impagliazzo, V. Kabanets, and A. Wigderson. In search of an easy witness: exponential time vs. probabilistic polynomial time. J. of Computer and System Sciences, 65(4):672–694, 2002. doi:10.1016/S0022-0000(02)00024-7.
  • [28] E. Jeřábek. Dual weak pigeonhole principle, boolean complexity, and derandomization. Annals of Pure and Applied Logic, 129:1–37, 2004. doi:10.1016/J.APAL.2003.12.003.
  • [29] E. Jeřábek. Approximate counting in bounded arithmetic. Journal of Symbolic Logic, 72(3):959–993, 2007. doi:10.2178/JSL/1191333850.
  • [30] M. Jerrum, L. G. Valiant, and V. V. Vazirani. Random generation of combinatorial structures from a uniform distribution. Theor. Comput. Sci., 43:169–188, 1986. doi:10.1016/0304-3975(86)90174-X.
  • [31] R. Kannan. Circuit-size lower bounds and non-reducibility to sparse sets. Information and Control, 55(1-3):40–56, 1982. doi:10.1016/S0019-9958(82)90382-5.
  • [32] R. M. Karp and R. J. Lipton. Some connections between nonuniform and uniform complexity classes. In Proceedings of the 12th Annual ACM Symposium on Theory of Computing, April 28-30, 1980, Los Angeles, California, USA, pages 302–309, 1980. doi:10.1145/800141.804678.
  • [33] R. Kleinberg, O. Korten, D. Mitropolsky, and C. Papadimitriou. Total Functions in the Polynomial Hierarchy. In James R. Lee, editor, 12th Innovations in Theoretical Computer Science Conference (ITCS 2021), volume 185 of Leibniz International Proceedings in Informatics (LIPIcs), pages 44:1–44:18, Dagstuhl, Germany, 2021. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ITCS.2021.44.
  • [34] J. Köbler and O. Watanabe. New collapse consequences of NP having small circuits. SIAM J. Comput., 28(1):311–324, 1998. doi:10.1137/S0097539795296206.
  • [35] O. Korten. The hardest explicit construction. In 2021 IEEE 62nd Annual Symposium on Foundations of Computer Science (FOCS), pages 433–444. IEEE, 2022.
  • [36] O. Korten and T. Pitassi. Strong vs. Weak Range Avoidance and the Linear Ordering Principle. Electron. Colloquium Comput. Complex., TR24-076, 2024. URL: https://eccc.weizmann.ac.il/report/2024/076.
  • [37] J. Krajíček. Proof Complexity Generators. London Mathematical Society Lecture Note Series. Cambridge University Press, 2025.
  • [38] Z. Li. Symmetric exponential time requires near-maximum circuit size: Simplified, truly uniform. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, pages 2000–2007. ACM, 2024. doi:10.1145/3618260.3649615.
  • [39] S. C. Marshall, S. Aaronson, and V. Dunjko. Improved separation between quantum and classical computers for sampling and functional tasks. In 40th Computational Complexity Conference, CCC 2025, August 5-8, 2025, Toronto, Canada, volume 339 of LIPIcs, pages 5:1–5:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPIcs.CCC.2025.5.
  • [40] P. B. Miltersen, N. V. Vinodchandran, and O. Watanabe. Super-polynomial versus half-exponential circuit size in the exponential hierarchy. In COCOON, pages 210–220, 1999.
  • [41] R. O’Donnell and A. C. C. Say. The weakness of CTC qubits and the power of approximate counting. ACM Trans. Comput. Theory, 10(2):5:1–5:22, 2018. doi:10.1145/3196832.
  • [42] J. Paris, A. Wilkie, and A. R. Woods. Provability of the pigeonhole principle and the existence of infinitely many primes. J. Symb. Log., 53(4):1235–1244, 1988. doi:10.1017/S0022481200028061.
  • [43] A. Russell and R. Sundaram. Symmetric alternation captures BPP. Comput. Complex., 7(2):152–162, 1998. doi:10.1007/s000370050007.
  • [44] R. Santhanam. Circuit lower bounds for Merlin–Arthur classes. SIAM J. Comput., 39(3):1038–1061, 2009. doi:10.1137/070702680.
  • [45] U. Schöning. A low and a high hierarchy within NP. Journal of Computer and System Sciences, 27:14–28, 1983. doi:10.1016/0022-0000(83)90027-2.
  • [46] R. Shaltiel and C. Umans. Pseudorandomness for approximate counting and sampling. Comput. Complex., 15(4):298–341, 2006. doi:10.1007/s00037-007-0218-9.
  • [47] M. Sipser. A complexity theoretic approach to randomness. In Proceedings of the 15th Annual ACM Symposium on Theory of Computing, 25-27 April, 1983, Boston, Massachusetts, USA, pages 330–335. ACM, 1983. doi:10.1145/800061.808762.
  • [48] L. J. Stockmeyer. On approximation algorithms for #P. SIAM J. Comput., 14(4):849–861, 1985. doi:10.1137/0214060.
  • [49] S. Toda. PP is as hard as the polynomial time hierarchy. SIAM J. Comput., 20(5):865–877, 1991. doi:10.1137/0220053.
  • [50] N. V. Vinodchandran. A note on the circuit complexity of PP. Theor. Comput. Sci., 347(1-2):415–418, 2005. doi:10.1016/j.tcs.2005.07.032.
  • [51] I. Volkovich. On learning, lower bounds and (un)keeping promises. In Proceedings of the 41st ICALP, pages 1027–1038, 2014.
  • [52] I. Volkovich. The untold story of SBP. In Henning Fernau, editor, The 15th International Computer Science Symposium in Russia, CSR, volume 12159 of Lecture Notes in Computer Science, pages 393–405. Springer, 2020. doi:10.1007/978-3-030-50026-9_29.