Upper and Lower Bounds for the Linear Ordering Principle
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 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 CollapseCopyright and License:
2012 ACM Subject Classification:
Theory of computation Complexity classes ; Theory of computation Problems, reductions and completeness ; Theory of computation Circuit complexityAcknowledgements:
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ắngSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
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 , the class contains a language that cannot be computed by Boolean circuits of size , i.e. a language outside of . 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 , ) 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 were pushed down to [22] and [36], a new 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 with , 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 or ), 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 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 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.
.
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 !
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 represented as the set of satisfying assignments of a Boolean circuit . 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 (via a Boolean circuit ) and an integer with the promise that either or , 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 . 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 is represented by a non-deterministic circuit! (A non-deterministic circuit accepts if there exists a witness for which .) This more general version of the problem (WSSE, where the set 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 , that is, deterministic algorithms with oracle access to ApproxCount. Indeed, an immediate corollary of the above is that and . At the same, O’Donnell and Say [41] previously showed that , 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:
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 ), 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 times in parallel or (using binary search) 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 is the number of elements in this set that are strictly less than (in particular, is the minimum if and only if ). We can extend this definition to non-empty subsets , where is the average rank of elements in .
We reduce the problem of approximately comparing the average ranks of two sets to approximate counting. To see how, consider a strict linear order implicitly defined on using a Boolean circuit , and observe that for a non-empty subset , the average rank of is exactly the size of the set of pairs divided by the size of . 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 , rapidly converges to the set’s minimum.
Given an element , we first define the set as the set of all the elements less or equal to . Formally, . Observe that . We then iteratively partition into two disjoint sets starting from . By averaging argument, . We then take to be the subset ( or ) with the smaller rank and continue to the next value of . That is, we fix the bits of the elements of one coordinate at a time. Therefore, once , our “final” set contains exactly one element and thus at that point . On the other hand, as the rank of the “initial” was and the overall rank could only decrease, we obtain that . We can then invoke the same procedure this time with as its input. As the there are elements in , this process will converge to the set’s minimum after invoking the procedure at most 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 ).
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 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 , and we leave this question for further research.
The best class for which fixed-polynomial circuit lower bounds can be proved (trivially) is (for any particular fixed ), where -Hard-tt, asks given , to output a truth table of a function of circuit complexity at least (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 . 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 .
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 . 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 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 is in fact an equality?
1.5.3 Some Unresolved Containments
-
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.
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.
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.
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).
is a promise problem if . We say that a language is consistent with , if and .
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 with inputs and outputs.
- Output:
-
.
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 this problem is equivalent to a stretch of (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 given as a Boolean circuit with inputs.
- Output:
-
either the minimum for (that is, such that ) or a counterexample, if is not a strict linear order. A counterexample is either a pair satisfying or a triple satisfying .
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 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 if there is a ternary relation computable in time , where is a polynomial, denoted for , , such that, for every fixed , it defines a linear order on -size strings such that:
-
for every , the minimal element of this order starts with bit 1,
-
for every , the minimal element of this order starts with bit 0.
Definition 6.
A language if there is a polynomial-time computable relation , denoted for , , such that:
-
for every , there exists such that ,
-
for every , there exists such that .
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 belongs to if there is a polynomial-time deterministic Turing machine such that for every , there exist , (called irrefutable certificates) that satisfy:
-
If , then for every , ,
-
If , then for every , .
No assumption on the behaviour of 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 ).
We remind the definition of another oblivious promise class.
Definition 8.
A promise problem belongs to if there is a polynomial-time deterministic Turing machine and, for every , there exists (a witness that serves for every positive instance of length ) that satisfy the following conditions:
-
If , then ,
-
If , then .
Finally, we define also an input-oblivious version of .
Definition 9.
A language belongs to if there is a polynomial , polynomial-time deterministic Turing machine computing a ternary predicate (we use the notation to denote its result), and two sequences of length- bit strings , such that
-
for every , is a strict linear order (define iff ),
-
,
-
.
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 is in if there exist , and a polynomial-time computable predicate such that
-
If then ,
-
If then .
where and is uniformly distributed on .
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 be a Boolean circuit and be an integer given in binary representation. Then , where
If 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 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 on variables and a rational number outputs an integer number satisfying
in time polynomial in , the size of and , 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 . A single-output -input Boolean circuit induces an ordering relation on as If is a strict linear order, we call a linear order circuit.
Observation 16.
There exists a deterministic Turing machine with SAT oracle that, given a circuit on variables, stops in time polynomial in and the size of and does the following: if is a linear order circuit, it outputs “yes”; otherwise, it outputs a counterexample: a pair satisfying or a triple satisfying .
Fix any strict linear order on .
Definition 17.
For an element we define its rank as . We can extend this definition to non-empty subsets of by taking the average rank: define . If is described by a circuit , we use the same notation: .
Below are some useful observations that we will use later.
Observation 18.
-
For a non-empty subset :
-
For any : .
-
Let be two non-empty disjoint subsets of . Then
Proof.
-
-
.
-
.
In the following lemma the is defined w.r.t. the order described by a linear order circuit . 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 on variables, a linear order circuit on variables, and an , outputs a rational number satisfying in time polynomial in , the sizes of and , and in , given oracle access to SSE.
Proof.
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 described by a linear order circuit .
Lemma 20.
There exists a deterministic algorithm Back that given a linear order circuit on variables and an element , outputs an element such that , in time polynomial in and the size of , given oracle access to SSE.
Proof.
Consider the following procedure:
- :
-
After each iteration one more variable gets its value and is substituted into , that is, in the current circuit variables are replaced by the corresponding constants . We claim that after each iteration the rank of the resulting circuit is bounded from the above:
Indeed, by Observation 18, before the first iteration, we have that . Now consider any iteration. If or are empty, then remains the same and . Otherwise, by Lemma 19, for , If then and therefore by Observation 18:
Equivalently, . Similarly, if then Therefore, at each step the rank is multiplied at most by .
Consequently, after the -th iteration, represents the set that contains only the element and we have that
For the runtime, all the steps can be carried out in time polynomial in and .
Note that the procedure Back has a unique fixed point, namely, the minimal element.
Observation 21.
if and only if is the minimal element in .
Proof.
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 be a -input circuit. We give an algorithm for LOP.
-
1.
Check that is indeed a linear order using Observation 16.
-
2.
Let .
-
3.
While repeat: .
-
4.
Output .
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 and let be a deterministic oracle machine that decides correctly given loose oracle access to (i.e. irrespective of the answers to its queries outside of the promise set), in time (for a polynomial ). Consider the polynomial-time deterministic verifier from the definition of . For , let be all possible lengths of oracle queries made by given an input of length . Define as a vector containing the irrefutable certificates (both “yes” and “no”) of for the appropriate input lengths. We now construct a new polynomial-time deterministic verifier that will demonstrate that and will show that, for any , the string constitutes an irrefutable certificate that can be used both as and as .
Given as an input, will simulate . Whenever makes an oracle query to , will compute four bits:
and will proceed with the simulation of as if the oracle answered .
By definition, for any , the machine computes correctly given the correct answers to the queries in the promise set (i.e. ) 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 and .
-
–
If then is a “yes”-irrefutable certificate and hence .
-
–
If then is a “no”-irrefutable certificate and hence .
-
–
-
Suppose and .
-
–
If then is a “yes”-irrefutable certificate and hence .
-
–
If then is a “no”-irrefutable certificate and hence .
-
–
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 , output a pseudorandom generator , that is, an array of strings such that for every -input circuit of size ,
Korten proves that such a generator containing 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 of size at most for a specific polynomial . One can assume perfect completeness for , that is, for in the promise set “YES”, there is such that .
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 . By Prop. 29, such a pseudorandom generator , which is a sequence of pseudorandom strings for bounded by a polynomial in , can constructed (for and error ) using a reduction to Avoid. Subsequently, by Prop. 30, Avoid is reducible to LOP. As a result, can be computed in deterministic polynomial time by querying an oracle.
After is computed, each call to the oracle can be replaced by an query for the circuit that computes the conjunction of the circuits with hardwired and , for every . Note that such queries constructed for 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.
.
-
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. . 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.
