New Algebrization Barriers to Circuit Lower Bounds via Communication Complexity of Missing-String
Abstract
The algebrization barrier, proposed by Aaronson and Wigderson (STOC ’08, ToCT ’09), captures the limitations of many complexity-theoretic techniques based on arithmetization. Notably, several circuit lower bounds that overcome the relativization barrier (Buhrman–Fortnow–Thierauf, CCC ’98; Vinodchandran, TCS ’05; Santhanam, STOC ’07, SICOMP ’09) remain subject to the algebrization barrier.
In this work, we establish several new algebrization barriers to circuit lower bounds by studying the communication complexity of the following problem, called XOR-Missing-String: For , Alice gets a list of strings , Bob gets a list of strings , and the goal is to output a string that is not equal to for any .
-
1.
We construct an oracle and its multilinear extension such that has linear-size -oracle circuits on infinitely many input lengths. That is, proving requires non-algebrizing techniques. This barrier follows from a communication lower bound for XOR-Missing-String. This is in contrast to the well-known algebrizing lower bound .
-
2.
We construct an oracle and its multilinear extension such that has linear-size -oracle circuits on all input lengths. Previously, a similar barrier was demonstrated by Aaronson and Wigderson, but in their result, is only a multiquadratic extension of . Our results show that communication complexity is more useful than previously thought for proving algebrization barriers, as Aaronson and Wigderson wrote that communication-based barriers were “more contrived”. This serves as an example of how XOR-Missing-String forms new connections between communication lower bounds and algebrization barriers.
-
3.
Finally, we study algebrization barriers to circuit lower bounds for . Buhrman, Fortnow, and Thierauf proved a sub-half-exponential circuit lower bound for via algebrizing techniques. Toward understanding whether the half-exponential bound can be improved, we define a natural subclass of that includes their hard language, and prove the following result: For every super-half-exponential function , we construct an oracle and its multilinear extension such that this natural subclass of has -size -oracle circuits on all input lengths. This suggests that half-exponential might be the correct barrier for circuit lower bounds w.r.t. algebrizing techniques.
Keywords and phrases:
circuit lower bound, algebrization barrier, missing string, communication complexityCopyright and License:
2012 ACM Subject Classification:
Theory of computation Complexity classes ; Theory of computation Circuit complexity ; Theory of computation Communication complexityEditor:
Shubhangi SarafSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Proving unconditional circuit lower bounds is one of the major challenges in theoretical computer science, with the holy grail of proving . Unfortunately, our progress toward this goal is barely satisfactory, as it is even open to prove a super-polynomial size lower bound for huge, exponential-time classes such as . Only for even larger complexity classes such as [27], which are in (or beyond) the second level of exponential-time hierarchy, are super-polynomial lower bounds known.
Our lack of progress in proving circuit lower bounds is partially explained by a series of barrier results such as relativization [10], natural proofs [37], and algebrization [3]. Among these barriers, relativization and algebrization are particularly relevant to lower bounds against unrestricted circuits for large complexity classes. For example, Wilson [44] constructed an oracle world where has linear-size circuits, which explains our inability to prove fixed-polynomial size lower bounds for .
Missing-String: a duality-based approach to relativizing circuit lower bounds.
Previous relativization barriers for circuit lower bounds are proved in an ad hoc fashion, which involves carefully analyzing the interaction between the oracle and the machines to be diagonalized [44, 12, 2]. A recent paper by Vyas and Williams [43] introduced the Missing-String problem as a systematic approach to such relativization barriers:
Problem 1 ().
Let be such that . Given (query access to) a list of length- strings , output a length- string that is not in this list.
The query complexity of Missing-String captures relativizing circuit lower bounds in the following sense: relativization barriers to proving are essentially lower bounds for Missing-String. (Here, is the exponential-time version of and means the decision-tree version of .) This connection was made explicit in [43], who demonstrated an equivalence between relativization barriers to exponential lower bounds for and the non-existence of small depth- circuits for Missing-String.111 denotes single-exponential time and denotes exponential time; classes such as and are defined analogously. Exponential time and single-exponential time are basically interchangeable in the context of super-polynomial lower bounds by a padding argument.
Intriguingly, Missing-String connects circuit lower bounds with circuit upper bounds and provides a duality-based approach to both: Decision tree upper bounds for Missing-String imply relativizing circuit lower bounds, and decision tree lower bounds for Missing-String imply relativized worlds with circuit upper bounds (i.e., relativization barrier to circuit lower bounds). Besides providing a clean and systematic method for relativization barriers, this “algorithmic” perspective has indeed made progress in circuit lower bounds: By designing algorithms for the Range Avoidance problem [30, 32, 38], which is the “white-box” version of Missing-String,222In the Range Avoidance problem, we are given the description of a circuit and our goal is to output a string that is not in the range of . It is easy to see that relativizing algorithms for Range Avoidance are equivalent to decision trees for Missing-String. recent work [15, 33] proved an exponential-size, relativizing lower bound for the complexity class (which also implies a quasi-polynomial size depth- circuit upper bound for Missing-String, settling the question in [43]).
The quest of algebrization.
However, the relativization barrier does not capture many circuit lower bounds that follow from nonrelativizing results such as [35, 40] and [8, 9], whose proofs are based on nonrelativizing proof techniques such as arithmetization. This includes circuit lower bounds for [42] and [12, 39], both of which are provably nonrelativizing [12, 2].
To shed light on the limitations of such proof techniques, Aaronson and Wigderson [3] proposed the algebrization barrier: a lower bound statement algebrizes if for all oracles and all low-degree extensions of . Aaronson and Wigderson showed that many arithmetization-based results indeed algebrize; in particular, for every oracle and low-degree extension of [3, Theorem 3.17]. In fact, all super-polynomial lower bounds against general circuits that we are aware of are algebrizing. Thus, algebrization is a more suitable framework than relativization for capturing the limitations of our current techniques.
Unfortunately, our understanding of the algebrization barrier remains primitive. For instance, several aspects of the algebrizing lower bound [12] remain poorly understood even with respect to algebrizing techniques:
-
This lower bound only holds infinitely-often. That is, [12] only exhibited a language where there are infinitely many input lengths on which has high circuit complexity. Recently, the relativizing infinitely-often lower bound for was improved to almost everywhere by [33], and it is tempting to ask whether the same improvement can be made with respect to this lower bound. Does require large circuit complexity on every input length? If so, can we show this via algebrizing proof techniques?
-
This lower bound is only sub-half-exponential. Roughly speaking, a function is half-exponential if . Half-exponential bounds appear naturally in many win-win analyses in complexity theory [36], and [12] is no exception – it is only known how to prove a size- lower bound for when is smaller than half-exponential. The recent “iterative win-win paradigm” [17, 15, 16] provides new techniques for overcoming the half-exponential barrier, which has indeed improved the circuit lower bound for to a near-maximum () one [15]. Can we use similar techniques to prove an exponential size lower bound for ? If so, can we show this via algebrizing proof techniques?
Our lack of understanding on algebrization barriers raises the following question:
Is there a duality-based approach to algebrization barriers?
In particular, can we establish algebrization barriers via lower bounds for Missing-String? It follows from [3] that communication lower bounds for Missing-String imply algebrization barriers to circuit lower bounds.333In fact, lower bounds for Missing-String in the algebraic query model suffices. However, we find the algebraic query model somewhat counter-intuitive to work with (for example, the input to the query algorithms consists of a Missing-String instance along with its low-degree extension). The “transfer principle” [3, Section 4.3] allows us to simulate such query algorithms by communication protocols, hence we choose to study communication complexity. Hence, a naïve attempt is to prove communication lower bounds for Missing-String and translate them into algebrization barriers. Unfortunately, it turns out that Missing-String admits an efficient deterministic communication protocol by a simple binary search.444Suppose that , Alice has inputs and Bob has inputs . For each string , it costs only bits of communication to obtain the value . Hence, we can use binary search to find two (lexicographically) adjacent strings and such that by communicating bits. Clearly, is not in the set .
The main conceptual contribution of this paper is the following communication problem:
Problem 2 ().
Let be such that . Alice receives strings and Bob receives . Their goal is to communicate with each other and output an -bit string such that is not equal to for every . Here denotes the bit-wise XOR operation over strings.
We show that XOR-Missing-String is hard for various communication complexity models, and transfer our communication complexity lower bounds to algebrization barriers. We now discuss our results in more detail.
1.1 Barriers to Circuit Lower Bounds
Our first result is an algebrization barrier to proving , i.e., an almost-everywhere circuit lower bound for . Here, is the class of promise problems decided by a probabilistic exponential-time machine with postselection [23]: conditioned on some event (which may happen with exponentially small probability), the machine outputs the correct answer with high probability. Postselection is a powerful computational resource: contains (thus ) [23] and (polynomial-time quantum computation with postselection) equals [1].555For example, a machine can solve -complete problems as follows. With exponentially small probability, output “No” and halt. If this does not happen, choose an witness uniformly at random and “kill yourself” if this witness is invalid (that is, we postselect on the event that our witness is valid). If the algorithm survives, it outputs “Yes.” Conditioned on survival, with high probability, our algorithm outputs “Yes” on Yes instances and outputs “No” on No instances.
Theorem 3.
There exists an oracle and its multilinear extension such that
In particular, this also implies
The proof of is algebrizing [12, 39, 3]. Our result implies that improving this circuit lower bound to almost-everywhere requires non-algebrizing techniques.
Theorem 3 follows from a communication lower bound for XOR-Missing-String:
Theorem 4.
Let and be integers. Any communication protocol that solves with error must have communication complexity .
Assume that . A trivial protocol for XOR-Missing-String is to output a uniformly random -bit string, which has communication complexity and error . Thus, Theorem 4 states that even if postselection is allowed, if we want to beat the error bound of this trivial protocol (), then the amount of communication needed is close to the maximum ().
Moreover, since the error of any pseudodeterministic666A randomized protocol for a search problem is pseudodeterministic [20] if there is a canonical output that is correct and outputted with probability . The trivial protocol for XOR-Missing-String that outputs a random guess is not pseudodeterministic, since running it two times using different randomness is likely to yield different answers. communication protocol can be reduced by a factor by repeating the protocol times and taking the majority answer, Theorem 4 implies that any pseudodeterministic protocol that solves (with correct probability, say, ) must have communication complexity . This stands in stark contrast to the case without pseudodeterministic constraints, as the trivial protocol is correct with probability . We also remark that lower bounds against pseudodeterministic communication protocols suffice for constructing an oracle such that has small -oracle circuits; however, we will need the full power of Theorem 4 against every low-error protocol to prove that the promise version of has small -oracle circuits.
1.2 Barriers to Circuit Lower Bounds
Our second result is an algebrization barrier to proving , i.e., an infinitely-often circuit lower bound for :
Theorem 5.
There exists an oracle and its multilinear extension such that
Previously, Aaronson and Wigderson [3] constructed an oracle and its multiquadratic extension such that . Their proof works with the algebraic query model directly, and it is unclear how to prove the same result for multilinear extensions using their techniques.
Besides demonstrating the power of our communication- and duality-based approach, an algebrization barrier w.r.t. multilinear extension also aligns better with the notion of affine relativization [7]. A statement is said to affine relativize if for every that is the multilinear extension of some oracle . The crucial difference from algebrization (in the sense of [3]) is that the left-hand side is also required to relativize with the multilinear extension. Affine relativization is arguably a cleaner and more robust notion than algebrization.777For example, algebrization is not necessarily closed under modus ponens: Although it requires non-algebrizing techniques to prove, say, , it might still be possible to exhibit a complexity class and prove both and via algebrizing techniques. In contrast, affine relativization is clearly closed under modus ponens. It is important to only take multilinear extensions, as [7] was only able to show that, e.g., for every multilinear oracle ; it is unclear if such a statement holds when is merely multiquadratic. (This is also why Aaronson and Wigderson [3] choose to relativize with the low-degree extension of but to relativize with itself.) In this regard, Theorem 5 also shows that is not affine relativizing (since ).
To obtain Theorem 5, we prove a lower bound for XOR-Missing-String against multiple pseudodeterministic protocols simultaneously in the following model.
-
There are communication protocols and inputs , , , .
-
The goal of protocol is to solve the input . However, each protocol is given the inputs to other protocols as well. More precisely, in each , Alice gets as inputs and Bob gets as inputs.888We remark that in the case of XOR-Missing-String, each and is already a list of strings, which means Alice and Bob get lists of strings each.
-
We say that the protocols succeed if at least one of the protocols outputs a correct answer.
-
For proving algebrization barriers, each and should have a different size and correspond to different input lengths of the oracle, but we omit this detail in the informal description here. We refer the reader to the full version of our paper for details.
The point of this model is that the protocols are allowed to look at other protocols’ inputs and to perform win-win analyses: the correctness of may rely on the failure of some other protocol .999If the possibility of such win-win analyses sounds surprising, it may help to compare it with the following classic puzzle. There are prisoners, each assigned a (not necessarily distinct) number between and . Each prisoner can see others’ numbers but not their own. Each prisoner must guess their own number simultaneously. If at least one prisoner guesses correctly, they are all set free; if none of them do, they are all executed. There is a simple solution that guarantees the prisoners’ freedom. The -th prisoner () assumes that the total sum of all numbers is congruent to modulo , and then infers their own number as . Exactly one assumption will be correct, so that prisoner will guess their own number correctly. Indeed, this scenario models a variety of win-win analyses in complexity theory; see e.g., [15, Section 1.4.2] and [34, Section 5.2]. Circuit lower bounds for [12, 39] can also be modeled as win-win algebraic query algorithms for Missing-String; see Appendix A of the full version.
We show that efficient pseudodeterministic protocols require large communication complexity to solve XOR-Missing-String, even if they receive multiple instances and are allowed to perform win-win analyses in the above sense.
Theorem 6 (Informal).
In the above model, suppose that each is an instance of but the communication complexity of each is “much less” than . Then there exists a sequence of inputs such that every fails to solve its corresponding instance pseudodeterministically.
1.3 Barriers to Circuit Lower Bounds
Finally, we present algebrization barriers to improving the half-exponential lower bound for [12]. While we are unable to fully resolve the algebrizing circuit complexity of , we show that for a natural subclass of which includes the hard language in [12], non-algebrizing techniques are required to go beyond half-exponential bounds.
Recall that a standard algorithm in defines a hard language if, relative to this particular oracle , satisfies the promise and defines a language without small -oracle circuits; we do not care about the behavior of for other oracles . In contrast, we say that an machine is a robust machine for defining a hard language (or simply “is robust”), if for any oracle and its multilinear extension such that satisfies the promise, the language computed by does not have small -oracle circuits. The use of interactive proofs in [12] naturally leads to hard languages defined by robust machines; see appendix A of the full version for details.101010In fact, the definition of robust resembles closer to the class compared to itself. This is natural since single-valued -constructions of hard truth tables (see, e.g., [15, Section 1.2.1]) give rise to circuit lower bounds for , and indeed the lower bound proved in [12] is for hard languages in . For ease of notation we use “robust ” () instead of “robust ” ().
We use (resp. ) to denote the class of languages computed by robust (resp. ) algorithms with access to oracle . Our main result is that proving a super-half-exponential bound for languages in or robust would require non-algebrizing techniques:
Theorem 7 (Informal).
There exists an oracle and its multilinear extension such that both and admit half-exponential size -oracle circuits.
Why study robust ?
We present two reasons for studying the notion of robust .
Firstly, Theorem 7 is tight in the sense that, in the two cases of the win-win argument in [12], the hard language is either in (i.e., deterministic exponential time), or in robust . Therefore, a slight adaptation of [12] proves that for every oracle and its multilinear extension , does not have sub-half-exponential size -oracle circuits.
Secondly, while the classes and may initially appear arbitrary, they in fact capture two fundamental types of failures for algorithms in :
-
For , if fails to achieve high circuit complexity, it must be due to an input on which is semantically incorrect. That is, the corresponding truth table entry is undefined. We call this a failure due to no positive.
-
In contrast, for , the value is always well-defined for all , regardless of the oracle . If has low circuit complexity, it must be because its truth table is easy for -oracle circuits. We call this a failure due to a false positive.
In general, for an algorithm , failure to achieve high circuit complexity can be attributed to both types, depending on the oracle. Thus, and represent two extreme cases within .
Our proof of Theorem 7 entails techniques that can force the two types of failures to occur. In this sense, the proof says something fundamental about . However, our current methods are limited to handling algorithms that exhibit only a single failure mode. For more general algorithms in that can have mixed types of failures, our understanding remains incomplete.
Proof of Theorem 7 via a communication lower bound.
To prove algebrization barriers to circuit lower bounds for robust , we need to understand the robust communication complexity of XOR-Missing-String. Here, an protocol is called robust if on every input , Merlin (i.e., the prover) cannot convince the protocol to output a non-solution for except with very small probability. Underlying Theorem 7 is the following lower bound stating that efficient protocols for XOR-Missing-String that are robust can only be correct on a tiny fraction of inputs:
Lemma 8.
Let be parameters. Let be a robust communication protocol of complexity attempting to solve . Then the fraction of inputs that solves is at most
Intuitively, since there is no efficient way to verify whether a string is a solution, any protocol that solves a large number of instances of XOR-Missing-String is essentially guessing the answer (similar to the naïve protocol that succeeds with probability ), which means that it must make mistakes. Since robust protocols are not allowed to output false positives, they can only be correct on a tiny fraction of inputs.
Although Lemma 8 is useful for analyzing the behaviors of robust protocols, it does not directly imply any half-exponential bounds. Indeed, we need to carefully diagonalize against both and simultaneously, which leads to a half-exponential bound. We discuss this in more detail in Subsection 1.4.
1.4 Technical Overview
Next, we briefly overview our proof techniques. In fact, the engine behind all of our communication lower bounds is the following observation about XOR-Missing-String:
Lemma 9 (Informal version of Lemma 17).
For every large enough rectangle and every answer , there is a large enough subrectangle ( and ) such that is a wrong answer for the XOR-Missing-String problem on every input .
With this lemma in hand, it is not hard to prove Theorem 4. We characterize a communication protocol as a distribution over labeled rectangles (using approximate majority covers [29]), where for each input , the output of the protocol is given by the label of a randomly selected rectangle that contains . Using Lemma 9, for every large enough labeled rectangle, there exists a large subrectangle in which the label is never a solution to XOR-Missing-String. Lemma 9 thus translates to a lower bound for the success probability of large labeled rectangles (i.e., the probability that the label is a solution, over a random input in the rectangle). This then translates to a lower bound for (weighted) average success probability over a random input, because the distribution consists mostly of large rectangles when the protocol is efficient. This lower bound implies that efficient protocols cannot have very high success probability.
However, more work needs to be done to obtain our other communication lower bounds and algebrization barriers.
BPP communication lower bounds.
We prove our pseudodeterministic communication lower bound in the “win-win model” (Theorem 6) via a reduction to the communication lower bound (Theorem 4). We first use an induction on the number of protocols; assume towards a contradiction that Theorem 6 holds for any sequence of protocols but does not hold for some sequence of protocols . Then the following communication protocol solves XOR-Missing-String efficiently: Given an input , guess inputs uniformly at random, set , and postselect on the event that all of the first protocols fail. That is, for every , fails to solve given . By our induction hypothesis, this event happens with probability strictly greater than . If this happens, then solves correctly. This contradicts Theorem 4.
For clarity, we have made a crucial simplification in the above description: To obtain algebrization barriers, we also need to prove lower bounds against list-solvers for XOR-Missing-String, which are communication protocols that output a small set of answers such that one of the answers is correct. Fortunately, it is not hard to adapt the proof of Theorem 4 to prove a communication lower bound for list solvers; see the full version for details.
communication lower bounds against robust protocols.
A robust protocol can be described as a collection of randomized verifiers , where means that when the input is and is given as proof, the protocol accepts as output. In the formal proof, we apply error reduction on the verifiers, so that when is not a solution to , with extremely small probability.
Thus, if a protocol has large success probability, there must exist some answer string and some proof , such that over a random input , is large. We interpret this as a distribution over labeled rectangles, and apply Lemma 9 to show that conditioned on , the verifier makes many mistakes (i.e., is large). This implies that the protocol must make mistakes on some , so it cannot be robust.
The half-exponential barrier for robust .
We formulate the problem in terms of refuting communication protocols, where we need to refute a finite set of protocols (deterministic or robust) on each input length. More formally, to construct an algebrized world with circuit upper bound , our oracle encodes one instance of for each input length . Each protocol being diagonalized is dedicated to solving the one instance that corresponds to its input length (it can nevertheless see the other instances).
We employ an inductive approach to construct the oracle. At step , we maintain a rectangle111111We interpret our oracles as the concatenation of Alice’s and Bob’s inputs, so it is reasonable to talk about a “rectangle” of oracles. of oracles, such that the rectangle is relatively large, and any protocol that works on input length at most fails to solve its instance on any oracle .
The goal of every step is then to slightly shrink the rectangle into , so that the protocols working on length are refuted. To achieve this, we employ a combination of two different strategies:
-
Refuting deterministic protocols: Given a deterministic protocol working on length and a large enough rectangle , we can always find a large subrectangle such that outputs the same answer on every oracle in (this is by definition of deterministic protocols). By Lemma 9, there exists a large subrectangle , such that for any oracle , does not solve on . We then update to refute .
-
Refuting robust protocols: Given a robust protocol working on length and a large enough rectangle , a random oracle from refutes with high probability. This is true as long as the density of is sufficiently larger than the success probability of on a uniformly random input (as upper bounded in Lemma 8).
On their own, both strategies work extremely well: The first strategy is very similar to the proof of by [3], and can be used to obtain much better circuit upper bounds than half-exponential. For the second strategy, since robust protocols are very weak, a randomly selected oracle would refute all robust protocols with high probability.
However, it is unclear how to combine the two strategies. On the one hand, after refuting a deterministic protocol by the first strategy, the resulting rectangle may be too small for the second strategy to work. On the other hand, although the set of oracles that refutes a robust protocol is large, it may not be a rectangle, so we cannot use it to refute the next deterministic protocol.
To integrate these two strategies, we refute each robust protocol at a carefully chosen time step. Suppose that we refute a robust protocol working on length after all deterministic protocols working on lengths are refuted, where is some function on . Also, recall that we want to prove an algebrized circuit upper bound of size .
-
After refuting the deterministic protocols working on lengths , we end up with a rectangle that contains roughly a fraction of all oracles. This is because the deterministic protocols working on lengths run in time . In contrast, Lemma 8 implies that only solves a fraction of oracles (since it attempts to solve an instance of ). Therefore, if , then we can refute .
-
On the other hand, after refuting , we still need to refute the deterministic protocols working on length . Since these protocols attempt to solve XOR-Missing- String, to apply Lemma 9, this requires our current rectangle to have size at least roughly . Since is equivalent to a deterministic protocol running in time (by enumerating the random bits and Merlin’s proof), after refuting it, we still have a rectangle of density . We thus need that .
Overall, we require that and . This implies that must be super-half-exponential.
1.5 Related Works
Prior work on super-polynomial circuit lower bounds.
Kannan’s seminal work [27] proved a super-polynomial size lower bound for ; since then, a sequence of work has proved circuit lower bounds for various complexity classes such as [31, 11], [14, 13], [42, 2], [12, 39], [26, 24], and more [41, 16]. Such lower bounds are usually proved by Karp–Lipton theorems [28, 9, 18]: If a large uniform class (usually or ) admits polynomial-size circuits, then it collapses to a smaller uniform class (such as ). As explained in [36] and [15, Section 1.4.1], such a strategy naturally yields a half-exponential bound. Recently, [15, 33] proved near-maximum () circuit lower bounds for the classes , , and , improving upon previous half-exponential bounds. Near-maximum circuit lower bounds are also known for several classes with subexponential amount of advice bits, such as [24] and [16].
Algebrization.
The interactive proof results such as [35, 40] and [8] generated much excitement among complexity theorists, as they are the first “truly compelling” ([4]) non-relativizing results in complexity theory. There has been much discussion on the extent to which these results are non-relativizing, and how to adapt the relativization barrier to accommodate these results [6, 19]. Arguably, the most influential work in this direction is that of Aaronson and Wigderson [3] on the algebrization barrier, which nicely captures interactive proof results and arithmetization-based techniques. However, Aaronson and Wigderson’s algebrization barrier has its own subtleties (such as not being closed under modus ponens, see footnote 7), which leads to several proposed refinements of its definition [25, 7]. We also mention the bounded relativization barrier, recently proposed by Hirahara, Lu, and Ren [24], which attempts to capture the interactive proof results entirely within the original Baker–Gill–Solovay [10] framework of relativization.
1.6 Open Problems
We think the most important open problem left in our paper is to study the algebrizing circuit complexity of . Can we strengthen Theorem 7 to hold for all of instead of just “robust” algorithms? If not, can we prove an exponential size lower bound for (potentially with one bit of advice) using algebrizing techniques?
Another open question is to prove a communication lower bound for XOR-Missing- String, which would imply an algebrization barrier to proving almost-everywhere circuit lower bounds for . Such circuit lower bounds are known in the infinitely-often regime [12, 42].
Finally, our work did not examine the regime of fixed-polynomial circuit lower bounds. Using algebrizing techniques, Santhanam [39] proved that for every constant , . Aaronson and Wigderson [3] speculated that it might be possible to eliminate the advice bit and prove using “tried-and-true arithmetization methods,” but there has been no progress in this direction. Is there an algebrizing barrier to proving ?
2 Preliminaries
Definition 10.
A search problem over domain and range is defined using a relation . For any input , the valid solutions for on are those such that (we say that is a solution to ). We say that is a total problem, if for any , there is at least one valid solution.
2.1 Complexity Classes
We assume familiarity with basic complexity classes such as , , and their exponential-time versions , , . The reader is encouraged to consult standard textbooks [5, 21] or the Complexity Zoo121212https://complexityzoo.net/, accessed Nov 28, 2025. for their definition.
Definition 11 ().
A promise problem is in if there exist two polynomial-time algorithms , taking an input and randomness (they take the same randomness), such that the following holds for every .
-
If , then .
-
If , then .
-
.
We say that the algorithm postselects on the event that .
Definition 12 ().
A promise problem is in if there exist two polynomial-time algorithms (verifiers) , taking an input , a proof and randomness (they take different randomness), such that the following holds for every .
-
If , then accepts and rejects .
-
If , then accepts and rejects .
Here, for , we say that
-
accepts , if there exists a proof such that .
-
rejects , if for any proof , we have that .
2.2 Algebrization
In this section, we present some definitions regarding algebrization barriers. The definitions are in accordance with [3], with slight modifications.
Definition 13 (Oracle).
An oracle is a collection of Boolean functions , one for each . Given a complexity class , by we mean the class of languages decidable by a machine that can query for any of its choice.
We say that a separation does not algebrize, if there exist an oracle and a low-degree extension of , such that . Throughout this paper, we only consider multilinear extensions, which are the simplest class of low-degree extensions.
Definition 14 (Multilinear Extension over Finite Fields).
Let be a Boolean function, and let be a finite field. The (unique) multilinear extension of over is the linear function that agrees with on . Given an oracle , the multilinear extension of is the collection of multilinear extensions , one for each positive integer and finite field .
Given a complexity class , by we mean the class of languages decidable by a machine that can query for any of its choice. Moreover, we assume that each query to takes time.
An important property of multilinear extensions is that algorithms having access to can be simulated by communication protocols where Alice and Bob are each given half of as input. This reduces proving algebrization barriers to proving communication lower bounds. Formally, we have the following theorem, which is a simple corollary of [3, Theorem 4.11].
Theorem 15.
Let be an oracle, and let (resp. ) be the subfunction of obtained by restricting the first bit to (resp. ). Let be a deterministic algorithm that has oracle access to and runs in time when given as input. There exists a deterministic communication protocol in which Alice (resp. Bob) is given and the function (resp. ) as input, such that uses bits of communication, and agrees with on any input and any oracle .
We remark that the proof of [3, Theorem 4.11] can be generalized to produce randomized communication protocols from randomized algorithms, communication protocols from algorithms, and so on.
3 An Infinitely-Often Algebrization Barrier for
In this section, we prove the following algebrization barrier:
See 3
3.1 Communication Lower Bounds for XOR-Missing-String
Theorem 3 follows from the following communication lower bound for XOR-Missing-String:
See 4
In this paper, communication protocols are defined as follows:131313There are many different definitions in the literature (see e.g., [22]). Here, we choose a simple definition that is best suited for proving the barrier.
Definition 16 ( communication protocols for search problems).
Let be a search problem over domain and range . A communication protocol for is defined as follows: Let be the length of the public randomness used by , and let be a set of deterministic communication protocols, each having communication complexity . On input , protocol first samples a uniformly random string , then simulates , whose output can be or any value from . The communication complexity of is defined to be .
We say that solves with error , if for any input ,
We say that is pseudodeterministic, if for any input , there exists some answer , such that
The main technical observation for our lower bound is that for any large enough rectangle , no single answer will be correct for every input . In fact, there is always a fraction of inputs in on which is not a valid solution.
To use this result in the lower bound, note that a communication protocol can be seen as a distribution of labeled rectangles (i.e., approximate majority covers, as defined in Subsubsection 3.1.2). If a protocol has small communication complexity, then it must contain many large rectangles, so we can apply the aforementioned lower bound on individual rectangles, which implies that the protocol must have error .
3.1.1 A Lower Bound for One Rectangle
In this section, we prove the main technical lemma for the communication lower bound. It is helpful to draw an analogy from the decision tree version of Missing-String: Suppose that the input is a list of -bit strings. Whenever the decision tree only queries the input on bits, there always exists a string in the input list that is not queried. In this case, regardless of the decision tree’s answer, the adversary can arbitrarily modify the value of that string and make the decision tree fail.
Here, we show that the XOR-Missing-String problem has a similar property: If, conditioned on the communication history, the rectangle formed by the possible inputs is large (this corresponds to the decision tree making a small number of queries), then regardless of the protocol’s answer, there always exists a significant portion of the rectangle, on which the protocol fails.
Lemma 17.
Let be integers. Let be a rectangle (i.e., is of the form , where ) of size at least . Let be any -bit string. Then there exists some , which is a subrectangle of and has size at least , such that for any , is not a solution to XOR-Missing-String on .
Proof.
Without loss of generality, we only have to prove the lemma for the case where . When , we consider a different rectangle , in which every input string for Alice in every input list is replaced by . By the definition of XOR-Missing-String, the lemma holds for and if and only if it holds for and .
To prove the lemma, we need to show that there exists a large enough subrectangle in , in which is never a solution to XOR-Missing-String. Recall that is equal to , where is a set of Alice’s inputs and is a set of Bob’s inputs. For any string , let denote the subset of that contains the string ; is defined similarly.
For any , consider the subrectangle . Since any input list (Alice’s or Bob’s) in the subrectangle always contains , is never a solution in .
In the remaining, we show that there exists some such that is large enough (i.e., has size ) using a counting argument. If we can show this, then the lemma follows by letting .
Let denote the number of occurrences of string in . Note that, if some input contains multiple copies of , is only counted once in . Let be all the -bit strings, sorted in non-increasing order of . Similarly define and . We have the following lower bound on the number of occurrences of :
Claim 18.
For any , is at least
Proof.
Let , i.e., the sum of occurrences of .
Consider the inputs in that only contain strings from . The number of such is at most . Therefore, at least inputs in contain at least one string from . Each of the inputs contribute at least one to the sum . That is,
Since occurs at least as frequently as any string in , we have that . Therefore,
The same bound also applies to . Fix any and consider the strings and . By the pigeonhole principle, there must exist some string that appears in both and . Using Claim 18, we can show that is large, that is,
| (by definition of the lists ) | ||||
| (by Claim 18) | ||||
Let . It now remains to show that, for any such that and , there exists some such that the rectangle chosen above is large enough. That is,
| (1) |
Let be the largest integer such that . Note that , so we must have . In this case, we have that , since if not, then
which is impossible since for any . Therefore, by plugging into (1), we have that
3.1.2 Reducing Communication to Approximate Majority Covers
To use Lemma 17 in the lower bound proof, we use the characterization of communication protocols by distributions of labeled rectangles called approximate majority covers [29].
Definition 19 (approximate majority covers).
Let be a search problem over the domain and range . An approximate majority cover for is a (multi) set of labeled rectangles , where is a rectangle, i.e., is of the form for some , and is the label of . The size of is defined as the number of labeled rectangles.
We say that the approximate majority cover solves with error , if for any , we have that
That is, when we randomly sample from a labeled rectangle that contains , the label is a solution with probability .
Claim 20.
Let be a total search problem over domain and range . If there exists a communication protocol that solves with error and has complexity , then there exists an approximate majority cover that solves with error and has size .
Proof.
Assume that uses bits of randomness. That is, is the uniform distribution over deterministic communication protocols , where each protocol has complexity .
Construct an approximate majority cover as follows: Initially, is empty. Each deterministic protocol partitions the input space into at most pairwise disjoint rectangles, where the answers of in each rectangle are the same. For each such rectangle of , suppose the answer of on is , we add to if and only if .
It is clear that the size of is at most . Moreover, for any , there is a one-to-one correspondence between the rectangles in containing and the protocols for which . Therefore, the value of is distributed the same as the label of a uniformly random rectangle in that contains .
3.1.3 Putting Everything Together
With the components in place, we can now prove Theorem 4.
See 4
Proof.
Let be a communication protocol that solves with error , and let denote the complexity of . We convert into an approximate majority cover using Claim 20. We have that solves with error and has size . We now show that the size of is at least , which proves the lemma.
Let denote the total size of the rectangles. Since is correct, each input must be contained in at least one rectangle, which means that .
Let
Since solves with error , we have that
| (each is correct w.h.p.) | ||||
On the other hand,
It follows from Lemma 17 that the first summand is at most
Let denote the size of , then the second summand is at most
| (since ) |
If , then the second summand is at most , which is at most since . Summing everything together, we have that
which contradicts the previous bound of . Hence it must be the case that .
Lower bounds for pseudodeterministic protocols.
A consequence of Theorem 4 is that it also applies to pseudodeterministic communication protocols for XOR-Missing-String with constant error (say ), as the error probability for such protocols can always be reduced to as small as possible by running it multiple times and outputting the majority answer. In contrast, the error probability of an arbitrary (non-pseudodeterministic) protocol cannot be amplified in general, since it is unclear how to verify whether a string is a valid solution to XOR-Missing-String.
Claim 21.
Let be integers. Let be a pseudodeterministic communication protocol that solves with error and has communication complexity . Then for any , there exists a pseudodeterministic communication protocol that solves with error and has communication complexity .
By setting in the above lemma and applying Theorem 4, we have:
Corollary 22.
Let and be integers. Any pseudodeterministic communication protocol that solves with error probability requires communication complexity .
3.2 Proving the Barrier
See 3
Proof of Theorem 3.
Let be a syntactic enumeration of algorithms each running in time (that is, each may or may not satisfy the promise). If we can prove a barrier for all such algorithms, then we can also prove a barrier for all algorithms running in time by a padding argument. We assume that each machine appears infinitely many times in the list .
Let be a large enough constant and set for every . Let for every . Recall that logarithms are always base . The oracle that we construct will have the following structure: On input strings whose lengths are not of the form , the value of will always be zero. For every , the truth table of on input length will encode an instance of . More specifically, the truth table of restricted to inputs whose first bit is (resp. ) will be equal to (resp. ) padded with zeros. Note that the length of is .
For every , the instance is designed to diagonalize against . More precisely, we want the following property to hold: let be the set of inputs such that the execution of satisfies the semantics of , then there exists a non-solution of the XOR-Missing-String instance such that for every . Note that for some , hence by hardwiring and we can construct an -oracle circuit of size whose truth table is equal to , and it follows that the problem defined by on input length can be computed by linear-size -oracle circuits. Therefore, it suffices to satisfy the aforementioned property.
Note that, when considering the truth table of on input length , the algorithm can only access on inputs of length . Therefore, we only need to show that fails to solve . Since , this implies that the algorithm only sees .
We construct our oracle inductively. Suppose that we have constructed for every , and we need to construct . Let be the following communication protocol that tries to solve . Given an instance , define an oracle such that are the previously fixed values and . Then, Alice and Bob output the “truth table” of on inputs of length , denoted as : for every , Alice and Bob simulate the computation of using (the version of) Theorem 15 repeatedly for times, and output the majority outcome as the -th bit of . (We use boldface to emphasize that is a random variable). Let denote the set of inputs such that the computation of satisfies promise, and let denote the promise problem defined by :
We say that is consistent with if for every , . Since the computation of is repeated times, the probability that is consistent with is at least . On the other hand, note that the behavior of is the same as some algorithm that has oracle access to and runs in time (since it considers possible inputs, simulates for times on each of them, and each simulation takes time), hence Theorem 15 implies that can be implemented by a communication protocol of complexity . It follows from Theorem 4 that cannot solve with success probability more than ; in other words, there exists some such that is a non-solution of w.p. at least . By a union bound, there is a non-zero probability that both of the following hold simultaneously: is consistent with and is a non-solution of . This means that there is a non-solution of such that for every , . Setting , this establishes the property we want for , and we can continue our construction for .
References
- [1] Scott Aaronson. Quantum computing, postselection, and probabilistic polynomial-time. Proceedings of the Royal Society A: Mathematical, Physical and Engineering Sciences, 461(2063):3473–3482, 2005. doi:10.1098/rspa.2005.1546.
- [2] Scott Aaronson. Oracles are subtle but not malicious. In Conference on Computational Complexity (CCC), pages 340–354. IEEE Computer Society, 2006. doi:10.1109/CCC.2006.32.
- [3] Scott Aaronson and Avi Wigderson. Algebrization: A new barrier in complexity theory. ACM Trans. Comput. Theory, 1(1):2:1–2:54, 2009. doi:10.1145/1490270.1490272.
- [4] Eric Allender. Oracles versus proof techniques that do not relativize. In SIGAL International Symposium on Algorithms, volume 450 of Lecture Notes in Computer Science, pages 39–52. Springer, 1990. doi:10.1007/3-540-52921-7_54.
- [5] Sanjeev Arora and Boaz Barak. Computational Complexity - A Modern Approach. Cambridge University Press, 2009. doi:10.1017/CBO9780511804090.
- [6] Sanjeev Arora, Russell Impagliazzo, and Umesh Vazirani. Relativizing versus nonrelativizing techniques: the role of local checkability. Manuscript, 1992. URL: https://people.eecs.berkeley.edu/˜vazirani/pubs/relativizing.pdf.
- [7] Barış Aydınlıoğlu and Eric Bach. Affine relativization: Unifying the algebrization and relativization barriers. ACM Trans. Comput. Theory, 10(1):1:1–1:67, 2018. doi:10.1145/3170704.
- [8] László Babai, Lance Fortnow, and Carsten Lund. Non-deterministic exponential time has two-prover interactive protocols. Comput. Complex., 1:3–40, 1991. doi:10.1007/BF01200056.
- [9] László Babai, Lance Fortnow, Noam Nisan, and Avi Wigderson. has subexponential time simulations unless has publishable proofs. Computational Complexity, 3:307–318, 1993. doi:10.1007/BF01275486.
- [10] Theodore P. Baker, John Gill, and Robert Solovay. Relativizations of the question. SIAM J. Comput., 4(4):431–442, 1975. doi:10.1137/0204037.
- [11] Nader H. Bshouty, Richard Cleve, Ricard Gavaldà, Sampath Kannan, and Christino 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.
- [12] Harry Buhrman, Lance Fortnow, and Thomas Thierauf. Nonrelativizing separations. In CCC, pages 8–12, 1998. doi:10.1109/CCC.1998.694585.
- [13] Jin-yi Cai. . J. Comput. Syst. Sci., 73(1):25–35, 2007. doi:10.1016/j.jcss.2003.07.015.
- [14] Jin-yi Cai, Venkatesan T. Chakaravarthy, Lane A. Hemaspaandra, and Mitsunori Ogihara. Competing provers yield improved Karp–Lipton collapse results. Inf. Comput., 198(1):1–23, 2005. doi:10.1016/j.ic.2005.01.002.
- [15] Lijie Chen, Shuichi Hirahara, and Hanlin Ren. Symmetric exponential time requires near-maximum circuit size. In STOC, pages 1990–1999. ACM, 2024. doi:10.1145/3618260.3649624.
- [16] Lijie Chen, Jiatu Li, and Jingxun Liang. Maximum circuit lower bounds for exponential-time arthur merlin. In STOC, pages 1348–1358. ACM, 2025. doi:10.1145/3717823.3718224.
- [17] Lijie Chen, Zhenjian Lu, Igor C. Oliveira, Hanlin Ren, and Rahul Santhanam. Polynomial-time pseudodeterministic construction of primes. In FOCS, pages 1261–1270. IEEE, 2023. doi:10.1109/FOCS57990.2023.00074.
- [18] Lijie Chen, Dylan M. McKay, Cody D. Murray, and R. Ryan Williams. Relations and equivalences between circuit lower bounds and Karp–Lipton theorems. In CCC, volume 137 of LIPIcs, pages 30:1–30:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.CCC.2019.30.
- [19] Lance Fortnow. The role of relativization in complexity theory. Bull. EATCS, 52:229–243, 1994.
- [20] Eran Gat and Shafi Goldwasser. Probabilistic search algorithms with unique answers and their cryptographic applications. Electronic Colloquium on Computational Complexity (ECCC), 18:136, 2011. URL: https://eccc.weizmann.ac.il/report/2011/136.
- [21] Oded Goldreich. Computational complexity - a conceptual perspective. Cambridge University Press, 2008. doi:10.1017/CBO9780511804106.
- [22] Mika Göös, Toniann Pitassi, and Thomas Watson. The landscape of communication complexity classes. Comput. Complex., 27(2):245–304, June 2018. doi:10.1007/s00037-018-0166-6.
- [23] Yenjo Han, Lane A. Hemaspaandra, and Thomas Thierauf. Threshold computation and cryptographic security. SIAM J. Comput., 26(1):59–78, 1997. doi:10.1137/S0097539792240467.
- [24] Shuichi Hirahara, Zhenjian Lu, and Hanlin Ren. Bounded relativization. In CCC, volume 264 of LIPIcs, pages 6:1–6:45. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.CCC.2023.6.
- [25] Russell Impagliazzo, Valentine Kabanets, and Antonina Kolokolova. An axiomatic approach to algebrization. In STOC, pages 695–704. ACM, 2009. doi:10.1145/1536414.1536509.
- [26] Russell Impagliazzo, Valentine Kabanets, and Ilya Volkovich. The power of natural properties as oracles. In Computational Complexity Conference (CCC), volume 102 of LIPIcs, pages 7:1–7:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.CCC.2018.7.
- [27] Ravi Kannan. Circuit-size lower bounds and non-reducibility to sparse sets. Inf. Control., 55(1-3):40–56, 1982. doi:10.1016/S0019-9958(82)90382-5.
- [28] Richard M. Karp and Richard J. Lipton. Some connections between nonuniform and uniform complexity classes. In Symposium on Theory of Computing (STOC), pages 302–309. ACM, 1980. doi:10.1145/800141.804678.
- [29] H. Klauck. Rectangle size bounds and threshold covers in communication complexity. In 18th IEEE Annual Conference on Computational Complexity, 2003. Proceedings., pages 118–134, 2003. doi:10.1109/CCC.2003.1214415.
- [30] Robert Kleinberg, Oliver Korten, Daniel Mitropolsky, and Christos Papadimitriou. Total functions in the polynomial hierarchy. In ITCS, volume 185 of LIPIcs, pages 44:1–44:18, 2021. doi:10.4230/LIPIcs.ITCS.2021.44.
- [31] Johannes Köbler and Osamu Watanabe. New collapse consequences of having small circuits. SIAM J. Comput., 28(1):311–324, 1998. doi:10.1137/S0097539795296206.
- [32] Oliver Korten. The hardest explicit construction. In Symposium on Foundations of Computer Science (FOCS), pages 433–444. IEEE, 2021. doi:10.1109/FOCS52979.2021.00051.
- [33] Zeyong Li. Symmetric exponential time requires near-maximum circuit size: Simplified, truly uniform. In STOC, pages 2000–2007. ACM, 2024. doi:10.1145/3618260.3649615.
- [34] Zhenjian Lu, Igor C. Oliveira, Hanlin Ren, and Rahul Santhanam. On the complexity of avoiding heavy elements. In FOCS, pages 2403–2412. IEEE, 2024. doi:10.1109/FOCS61266.2024.00140.
- [35] Carsten Lund, Lance Fortnow, Howard J. Karloff, and Noam Nisan. Algebraic methods for interactive proof systems. J. ACM, 39(4):859–868, 1992. doi:10.1145/146585.146605.
- [36] Peter Bro Miltersen, N. V. Vinodchandran, and Osamu Watanabe. Super-polynomial versus half-exponential circuit size in the exponential hierarchy. In COCOON, volume 1627 of Lecture Notes in Computer Science, pages 210–220. Springer, 1999. doi:10.1007/3-540-48686-0_21.
- [37] Alexander A. Razborov and Steven Rudich. Natural proofs. J. Comput. Syst. Sci., 55(1):24–35, 1997. doi:10.1006/JCSS.1997.1494.
- [38] Hanlin Ren, Rahul Santhanam, and Zhikun Wang. On the range avoidance problem for circuits. In FOCS, pages 640–650. IEEE, 2022. doi:10.1109/FOCS54457.2022.00067.
- [39] Rahul Santhanam. Circuit lower bounds for Merlin–Arthur classes. SIAM J. Comput., 39(3):1038–1061, 2009. doi:10.1137/070702680.
- [40] Adi Shamir. . J. ACM, 39(4):869–877, 1992. doi:10.1145/146585.146609.
- [41] Larry J. Stockmeyer and Albert R. Meyer. Cosmological lower bound on the circuit complexity of a small problem in logic. J. ACM, 49(6):753–784, 2002. doi:10.1145/602220.602223.
- [42] N. V. Vinodchandran. A note on the circuit complexity of . Theor. Comput. Sci., 347(1-2):415–418, 2005. doi:10.1016/j.tcs.2005.07.032.
- [43] Nikhil Vyas and R. Ryan Williams. On oracles and algorithmic methods for proving lower bounds. In Innovations in Theoretical Computer Science Conference (ITCS), volume 251 of LIPIcs, pages 99:1–99:26. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.ITCS.2023.99.
- [44] Christopher B. Wilson. Relativized circuit complexity. J. Comput. Syst. Sci., 31(2):169–181, 1985. doi:10.1016/0022-0000(85)90040-6.
