Provability of the Circuit Size Hierarchy and Its Consequences
Abstract
The Circuit Size Hierarchy () states that if then the set of functions on variables computed by Boolean circuits of size is strictly larger than the set of functions computed by circuits of size . This result, which is a cornerstone of circuit complexity theory, follows from the non-constructive proof of the existence of functions of large circuit complexity obtained by Shannon in 1949.
Are there more โconstructiveโ proofs of the Circuit Size Hierarchy? Can we quantify this? Motivated by these questions, we investigate the provability of in theories of bounded arithmetic. Among other contributions, we establish the following results:
-
(i)
Given any , is provable in Bussโs theory .
-
(ii)
In contrast, if there are constants such that is provable in the theory , then there is a constant such that requires non-uniform circuits of size at least .
In other words, an improved upper bound on the proof complexity of would lead to new lower bounds in complexity theory.
We complement these results with a proof of the Formula Size Hierarchy () in with parameters and . This is in contrast with typical formalizations of complexity lower bounds in bounded arithmetic, which require or stronger theories and are not known to hold even in .
Keywords and phrases:
Bounded Arithmetic, Circuit Complexity, Hierarchy TheoremsCopyright and License:
![[Uncaptioned image]](x1.png)
Dimitrios Tsintsilidas; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Complexity theory and logic ; Theory of computation Proof complexity ; Theory of computation Circuit complexity ; Theory of computation Proof theoryAcknowledgements:
We thank Emil Jeลรกbek for a discussion about witnessing theorems in bounded arithmetic. We are also grateful to Hanlin Ren for a suggestion that improved our bounds in Corollary 10.Funding:
This work received support from the Royal Society University Research Fellowship URFR1191059; the UKRI Frontier Research Guarantee Grant EP/Y007999/1; the Centre for Discrete Mathematics and its Applications (DIMAP) at the University of Warwick, and the Natural Sciences and Engineering Research Council of Canada.Editor:
Raghu MekaSeries and Publisher:

1 Introduction
1.1 Context and Motivation
The existence of Boolean functions requiring large circuits can be shown by a non-constructive counting argument, as established by Shannon in 1949 [24]. It follows from Shannonโs seminal result and a simple padding argument that if there are functions computable by circuits of size that cannot be computed by circuits of size . In other words, the classification of Boolean functions by their minimum circuit size forms a strict hierarchy.
Obtaining a โconstructiveโ form of these results has been a holy grail in computational complexity theory for several decades due to its connections to derandomization and as an approach to separating and . For instance, if there is a polynomial-time algorithm that given outputs the truth-table of a function that requires circuits of size , then [9]. In results of this form, a constructive form of the (non-constructive) proof of the existence of hard functions is interpreted computationally as the existence of an algorithm of bounded complexity that computes a hard function.
In this paper, rather than focusing on the existence of algorithms to capture the constructiveness of a statement, we explore this notion from the perspective of mathematical logic, specifically concerning its provability in certain mathematical theories. We are interested in identifying the weakest theory capable of establishing the aforementioned circuit size hierarchy for Boolean circuits and related results.
As one of our contributions, we present a tight connection between the computational and proof-theoretic perspectives. We demonstrate that proving the non-uniform circuit size hierarchy in a theory known as implies the existence of a function in that requires Boolean circuits of size at least . The latter is a frontier question in complexity theory (see, e.g.,ย [5]). Thus, in a precise sense, developing more constructive proofs of the circuit size hierarchy would lead to significant progress on explicit circuit lower bounds.
We now proceed to describe this result and other contributions of this work in detail.
1.2 Results
We will be concerned with standard theories of bounded arithmetic. These theories are designed to capture proofs that manipulate and reason with concepts from a specified complexity class. Notable examples include Cookโs theory [7], which formalizes polynomial-time reasoning; Jeลรกbekโs theory [10, 11, 13], which extends by incorporating the dual weak pigeonhole principle for polynomial-time functions and formalizes probabilistic polynomial-time reasoning; and Bussโs theories [2], which incorporate induction principles corresponding to various levels of the polynomial-time hierarchy.
For an introduction to bounded arithmetic, we refer to [3]. For its connections to computational complexity and a discussion on the formalization of complexity theory, we refer to [23].111In particular, the reference [23] contains a detailed discussion of some aspects of the formalization of the statements appearing below. Here we only recall that theory corresponds essentially to [12], and that correspond to the first levels of Bussโs hierarchy. A brief overview of the theories is provided in Section 2.
For a given , we use to denote the set of Boolean functions computed by circuits of size at most . Similarly, when referring to formula size, we write . We use to denote the set of languages that admit a sequence of circuits of size at most .
Circuit Size Hierarchy
For rationals and , we consider the following sentence:222The abbreviation denotes that is the length of a variable (see, e.g.,ย [23] for more details).
In other words, states that whenever .
Next, we state our first result.
Theorem 1.
The following results hold:
-
(i)
For every choice of rationals and with , and for every large enough ,
-
(ii)
If there are rationals and a constant such that
then there is a constant and a language such that .
-
(iii)
Similarly to the previous item, if , there is such that .
To put it another way, we can establish a circuit size hierarchy within the theory . If this result could also be proven in the theory , it would lead to a significant breakthrough in circuit lower bounds. Thus, by enhancing the proof complexity upper bound for the provability of the circuit size hierarchy, we can achieve new circuit lower bounds.
The proof technique of Item (ii) also applies to the theory , which combined with Item (i) gives us a superlinear lower bound for a language in , but this is already known by Kannanโs theorem [15].
Note that in Theorem 1 Items (ii) and (iii) we obtain a lower bound against circuits of size , where the constant depends on the proof of in the corresponding theory. In other words, while the sentence claims the existence of hardness against circuits of size , we are only able to extract a weaker lower bound for an explicit problem.
In our next result, we describe a setting where we can extract all the hardness from a proof of the corresponding sentence.
Succinct Circuit Size Hierarchy
We define what we call the succinct version of the circuit size hierarchy, where we substitute the upper bound circuit with a collection of labelled examples for the function, which can always represent a circuit. For rationals and , we consider the following sentence:
In other words, states that for every there is a collection of labelled examples such that every circuit of size at most disagrees with at least one of its labels. The truth of this statement can be validated by a counting argument, similarly with the circuit size hierarchy proof.
We obtain the following results on the proof complexity of the succinct circuit size hierarchy.
Theorem 2.
The following results hold:
-
(i)
For every choice of rationals and for every large enough ,
-
(ii)
If there are rationals and a constant such that
then there is a language such that .
In our final result, we investigate the provability of size hierarchies for more restricted computational models in and weaker theories.
Formula Size Hierarchy
For rationals and , we consider the following sentence:
In other words, states that whenever .
We establish that for some parameters a formula size hierarchy is provable already inย .
Theorem 3.
Consider rationals and , and let be a large enough positive integer. Then
1.3 Techniques
The proofs of Items (ii) and (iii) in Theorem 1 are inspired by arguments from [18, 17] that rely on a combination of a witnessing theorem with a term elimination strategy. Recall that the witnessing theorem allows us to extract computational information from a proof of the sentence in the theory. Roughly speaking, in our context this implies that the first existential quantifier in the sentence , which corresponds to a circuit computing a hard function, can be witnessed by a finite number of terms of the corresponding theory. In , a term yields a polynomial-time function, while in a term yields a polynomial-time function with access to an oracle. The main difficulty is that (1) for a given input length it is not clear which term among succeeds in constructing a hard function, and (2) for a term to succeed we must provide counter-examples to the candidate witnesses provided by previous terms.
As in previous papers, we assume that the conclusion of the theorem does not hold, and use this assumption to rule out the correctness of each term. This leads to a contradiction, meaning that the original sentence is not provable in the corresponding theory. Implementing this plan requires a careful argument, and we are currently only able to carry it out under a complexity inclusion in as opposed to . The proof of the result is given in Section 3.1.
On the other hand, in the case of the succinct circuit size hierarchy, the argument for Item (ii) of Theorem 2 is simpler and allows us to start with the weaker assumption that . Without getting into the technical details, the main reason for not losing hardness in this result is that given a labelled list of examples and access to an oracle, we can efficiently compute a minimum size circuit that agrees with this list of inputs. Consequently, we can check if a candidate labelled list provided by a term is indeed hard, or produce a counter-example when this is not the case. The same computation is not available in the case of Theorem 1, since it is not clear how to efficiently compute with access to an oracle if a given circuit admits a smaller equivalent circuit. The proof of Item (ii) of Theorem 2 appears in Section 3.2.
The proofs of Theorem 1 Item (i) and Theorem 2 Item (i) are given in Section 3.3. The formalization of these hierarchies in is easily done with access to the dual Weak Pigeonhole Principle for polynomial-time functions, a principle which is known to be available in . In more detail, follows from in , while can be established in theory , which is contained in .
Finally, in the proof of Theorem 3 we formalize in that the parity function on bits can be computed by formulas of size and require formulas of size . This yields in a proof of for any choice of parameters , large enough , and . The upper bound on the complexity of parity follows from a straightforward formalization of the correctness of the formula obtained via a divide-and-conquer procedure. On the other hand, in order to show the formula lower bound we formalize Subbotovskayaโs argument [25] based on the method of restrictions. To implement the proof in , we directly define an efficient refuter that given a small formula outputs an input string where it fails to compute the parity function. The correctness of the refuter is established by induction using an induction principle available in the theory . We then rely on a conservation result showing that the proof can also be done in . A detailed exposition of the argument appears in Section 4.
2 Preliminaries
2.1 Complexity Theory
We employ standard definitions from complexity theory, such as basic complexity classes, Boolean circuits, and Boolean formulas (see,ย e.g.,ย [1]).
Let represent the set of non-negative integers. For any , let denote the length of its binary representation, defined as . For a constant , a function is said to be computable in polynomial time if can be computed in time polynomial in . For convenience, we might write . The class denotes the set of polynomial-time computable functions. Although the definition of polynomial time typically refers to a machine model, can also be defined in a machine-independent manner as the closure of a set of base functions (not described here) under composition and limited recursion on notation. A function is defined from functions , , and by limited recursion on notation if
for every sequence of natural numbers. Cobham [6] established that is the smallest class of functions that contains the base functions and is closed under composition and limited recursion on notation.
2.2 Bounded Arithmetic
2.2.1 Logical Theories
We recall the definitions of some standard theories of bounded arithmetic. For more details, the reader can consult [16, 8, 20].
Cookโs Theory [7]
The theory is designed to model the set of natural numbers with the standard interpretations for constants and function symbols like , etc. The vocabulary (language) of , denoted , includes a function symbol for each polynomial-time algorithm , where is any constant. These function symbols and their defining axioms are derived using Cobhamโs characterization of polynomial-time functions discussed above. While Cookโs was an equational theory, it was later extended in [19] to a first-order theory , which includes an induction axiom scheme that simulates binary search. It can be shown that allows induction over quantifier-free formulas (i.e., polynomial-time predicates).
can be formulated with all axioms as universal formulas (i.e., , where is free of quantifiers). Thus, is a universal theory. Although the definition of is quite technical, the theory is fairly robust and the details of its definition are often unnecessary for practical purposes. In particular, has an equivalent formalizations that does not rely on Cobhamโs result, e.g. [12].
Jeลรกbekโs Theory [10, 11, 13]
extends with the dual Weak Pigeonhole Principle () for functions:
Each sentence postulates that, for every length and for every choice of , there is such that for every . It is known that is contained in [21].
Bussโs Theories and [2]
The language for these theories includes predicate symbols and , constant symbols and , and function symbols (successor), , , , (interpreted as the length of ), and (interpreted as , known as โsmashโ).
Recall that a bounded quantifier is a quantifier of the form , where and is a term not involving . Similarly, a sharply bounded quantifier is one of the form . A formula where each quantifier appears bounded (or sharply bounded) is called a bounded (or sharply bounded) formula.
We can create a hierarchy of formulas by counting alternations of bounded quantifiers. The class contains the sharply bounded formulas. Recursively, for each , the classes and are defined by the quantifier structure of the sentence, ignoring sharply bounded quantifiers. For instance, if and , then . For the general case of the definition, see [16]. It is known that for each , a predicate is in (the -th level of the polynomial hierarchy) if and only if there is a -formula that agrees with it over .
These theories share a common set of finitely many axioms, BASIC, which postulate the expected arithmetic behavior of the constants, predicates, and function symbols. The only difference among the theories is the type of induction axiom scheme each one postulates.
is a theory in the language that extends BASIC by including the induction axiom :
for all -formulas . The formula may contain other free variables in addition to .
is a theory in the language that extends BASIC by including the polynomial induction axiom :
for all -formulas . The formula may contain other free variables in addition to .
Theory
When proving some results in , it is often convenient to use a more expressive vocabulary that easily describes any polynomial-time function. This can be done in a conservative manner, meaning the power of the theory is not increased. Specifically, let be a set of -formulas. We say that a polynomial-time function is -definable in if there exists a formula such that the following conditions are met:
-
(i)
For every , if and only if .
-
(ii)
Every function is -definable in . By incorporating all functions in into the vocabulary of and extending the axioms of with their defining equations, we obtain a theory . This theory allows polynomial-time predicates to be referred to using quantifier-free formulas. remains conservative over , meaning any -sentence provable in is also provable in . Finally, it is known that proves the polynomial induction scheme for both -formulas and -formulas within the extended vocabulary.
2.2.2 The KPT Witnessing Theorem
The following witnessing theorem (a variant of Herbrandโs theorem) is proved in [19] (cf.ย also [16, Theoremย 7.4.1]) for universal theories (like the theory ).
Theorem 4 (KPT Theorem for sentences).
Let be a universal theory with vocabulary . Let be an open -formula, and suppose that
Then there is a finite sequence of -terms such that
where
We can also apply the KPT Theorem to each theory (for ) using a conservative extension of the theory that admits a universal axiomatization. The corresponding theory is called [19]. In , each term is equivalent to an function over the standard model. This leads to the following result.
Theorem 5 (Consequence of the KPT Theorem for Theory ).
Let , be a -formula, and suppose that
Then there is a finite sequence of function symbols, each corresponding to an function, such that
where
3 Circuit Size Hierarchies in Bounded Arithmetic
3.1 Explicit Circuit Lower Bounds from Provability in and
In this section, we prove Theorem 1 Items (ii) and Items (iii).
Theorem 6 (Theorem 1 Item (iii)).
If there are rationals and such that
then there is a constant and a language such that .
Proof.
Towards a contradiction, suppose that for rationals and some constant and that . The sentence has the form :
where is the existential formula:
Therefore, we can apply the KPT Theorem (Theorem 4), which provides -terms, equivalently functions, , where is a constant, such that
(1) |
In the formula above the circuits are universally quantified.
Next, we use to refute each of these disjuncts. We start by considering the following language, :
-Eval is in due to the fact that and circuit evaluation is in . By our assumption on the circuit complexity of the complexity class , for every input length and every , , so we can choose
and have . We also define the constants
for . Note that and .
We start by refuting . We consider inputs of the form to , where is the empty sequence. Then the input has length , where accounts for the overhead in the encoding of the input. We consider the circuit , which evaluates as on inputs of length , and we fix the input variables not related to to represent the empty sequence. The resulting circuit has as input an -bit string and computes according to by definition of the algorithm. For sufficiently large , we have that , therefore we have the circuit which agrees with the circuit on all -bit inputs. Since , we have that
We can apply a similar argument to the next disjunct using the aforementioned circuit . In more detail, we consider the input on , which has length for sufficiently large due to , and a corresponding circuit provided by the circuit upper bound hypothesis. Similarly, we can fix the variables not related to the input string . This provides an -bit circuit that computes according to the circuit , due to the definition of the algorithm. Since , we have that
Inductively, if we have circuits for some of sizes at most , respectively, we consider the input to , which has length for sufficiently large . Therefore, by taking a corresponding -size circuit for and fixing all the inputs except for , we get the circuit which agrees with the circuit on all -bit inputs. Consequently,
Overall, we can refute all disjuncts in Equation 1, which gives us a contradiction. This completes the proof.
Theorem 7 (Theorem 1 Item (ii)).
If there are rationals and such that
then there is a constant and a language such that .
Proof.
In this case, provability in provides by the KPT Theorem (Theorem 5) functions which are in instead of as in the previous proof. Therefore, the algorithm is in and we use the upper bound to get a contradiction in the same way as above.
Note that in the arguments above we have no control over the constant . It depends on the number of disjuncts obtained from the KPT Theorem, which depends on the supposed proof of the hierarchy sentence.
3.2 Extracting All the Hardness from Proofs of a Succinct Hierarchy Theorem
In this section, we prove Theorem 2 Item (ii).
Theorem 8 (Theorem 2 Item (ii)).
If there are rationals and a constant such that
then there is a language such that .
Proof.
The main idea here is to use the proof of in order to define a Turing machine which runs in polynomial time using an oracle and its language is hard against -size circuits.
Starting from , we see that the structure of the sentence is :
where is the formula that states that is a collection with , where and , and that if is a circuit on variables and of size , then there is some such that (we can move the existential quantifier at the front of the formula).
Thus, by the KPT Theorem (Theorem 5), there are functions , where is a fixed constant, such that
(2) |
From the relation above, we can see that one of the functions will output a collection that refutes every circuit of size . If it is not , then there is a counterexample circuit , which is used as extra input in and so on. Since are in , we can simulate this procedure in a Turing machine , described below.
ย Remark.
In contrast with Algorithm 1, the algorithm of the Turing machine does not need to have the counterexample circuits as input, since it can guess and check them during its process, using the oracle. This difference in the input size is what gives us the lower bound instead of .
It is easy to see that the language recognised by the Turing machine , is in . It suffices to show that .
Consider a circuit . We will show that it fails to recognise . Assume that the for-loop in Algorithm 2 ends in the -th iteration with . We fix the circuits found by the algorithm. Then the formula always holds. If and did not satisfy it, then the oracle would find as a counterexample and it would continue to the -th iteration. If , then by the construction of , the formulas for do not hold, which means by Equation 2 that is true.
Since , from we get that there is some , such that . However, if , then , and if , then . In both cases, the circuit fails to recognise the language , and the proof is complete.
3.3 Formalization in
In this section, we prove Theorem 1 Item (i) and Theorem 2 Item (i). To achieve this, we show that the succinct circuit size hierarchy is provable in , which is contained in . We then observe that the circuit size hierarchy is easily provable from the succinct circuit size hierarchy.
Theorem 9.
For every choice of rationals and for every large enough ,
In particular, is provable in .
Proof.
We define the polynomial-time function, , which takes as input the description of a circuit, , of size , which means that the length of the description of is , and outputs a bit string of length with the property that for all , .
The correctness of the polynomial-time algorithm is provable in . In other words,
(3) |
The quantifier is sharply bounded, so this formula is provable in .
The theory includes the axiom for all functions with input length and output length , or equivalently input length and output length with . From the first part of Equation (3.3), the input length of is , while the output length is . Furthermore, it is provable in that there is some constant , such that . Therefore, we can use the axiom:
(4) |
Every circuit of size can be described by a string of size , which means that
Also, from the second part of Equation (3.3), using the notation for the circuit , we get that
Substituting the last two relations to Equation 4, we get that
which is equivalent with , if we interpret as the collection
Corollary 10.
For every choice of rationals and for every large enough ,
Proof.
Since , there is some rational , such that . From Theorem 9, we have got a collection of size , such that for all circuits of size less than , there exists such that . So, we only need to prove that
and then we can easily deduce that . The same holds also for .
It is sufficient to argue in that there is a polynomial-time function such that given the collection from Theorem 9 outputs a circuit of the required size such that . In order to optimize the circuit size, we use that the obtained collection has a specific structure. More precisely, we have that for any , the strings is the -bit binary representation of the integer . Therefore, we can construct the circuit in the following way: For every -bit string such that , we construct the term , which is the conjunction of the first least significant bits of (we put the literal if the -th bit of is and if the -th bit of is , where ). Then we make the DNF
It is easy to see that agrees with all the pairs of the collection . For an arbitrary pair , if , then the bits of satisfy the term , hence . Otherwise, if , we know that the first least significant bits of do not satisfy any term of the disjunction (since for all , ), thus we get that .
The DNF can be viewed as a circuit and its correctness is easily provable in . This circuit has size at most (derived by -gates for each one of the at most terms and at most -gates for the final disjunction), which is at most . For large enough , we can prove that , hence we have the desired result.
4 Provability of Formula Size Bounds in
In this section, we prove Theorem 3. To achieve this, we establish that:
-
1.
The parity function on bits requires formulas of size (Section 4.1).
-
2.
The parity function on bits can be computed by formulas of size for any fixed rational and large enough (Section 4.2).
-
3.
Consequently, the formula size hierarchy holds with parameters and , provided that is large enough (Section 4.3).
4.1 Subbotovskayaโs Lower Bound
4.1.1 High-Level Details of the Formalization
In this section, we sketch a formalization in of the proof that the parity function on bits requires Boolean formulas of size [25].333For concreteness, we let the size of a Boolean formula be the number of leaves of labeled by an input literal. We allow leaves that are labeled by constants, but we do not charge for them. Consequently, a constant function has formula complexity , while a non-constant function has formula complexity at least . We adapt the argument presented in [14, Section 6.3], which proceeds as follows:
-
1.
[14, Lemma 6.8]: Given a Boolean formula on -bit inputs, it is possible to fix one of its variables so that the resulting formula satisfies
In order to pick the variable to be restricted and its value, one first โnormalizesโ the formula , as implicitly described in [14, Claim 6.9] (see more details below).
-
2.
[14, Theorem 6.10]: By applying this result times, it is possible to obtain a formula on -bit inputs such that
-
3.
[14, Example 6.11]: If the initial formula computes the parity function, by setting we obtain
and consequently .
We recommend reading this section with [14, Section 6.3] at hand. We will slightly modify the argument when formalizing the lower bound in . In more detail, given a small formula , we recursively construct (and establish correctness by induction) an -bit input witnessing that does not compute the parity function. (Actually, for technical reasons related to the induction step, we will simultaneously construct an -bit input witnessing that does not compute the parity function and an -bit input witnessing that does not compute the negation of the parity function.)
Let be a size bound and be a function that computes the parity of the binary string described by , i.e., , where denotes the -th bit of . To simplify notation, we tacitly view as a binary string. We assume that the formalization employs a well-behaved function symbol such that proves the basic properties of the parity function, e.g., and .
We consider the following -sentence stating that the parity function requires formulas of size at least for every input length :
where for convenience of notation we use the function symbol to compute the bit-length of the string represented by (under some reasonable encoding).
Theorem 11.
Let . Then .
Proof.
Given , we introduce the function . In order to prove in , we explicitly consider a polynomial-time function with the following properties:555For convenience, we often write instead of explicitly considering parameters and . We might also write just instead of .
-
1.
Let .
-
2.
If then outputs an -bit string such that .
In other words, witnesses that the formula does not compute the function over -bit strings. Note that the correctness of is captured by the bounded universal sentence:
where we employed the abbreviations and . Our plan is to define and show that . Note that this implies in . Jumping ahead, the correctness of will be established by polynomial induction on (equivalently, induction on ). Since is a universal sentence and is -conservative over , polynomial induction for and predicates (admissible in ; see, e.g.,ย [16, Section 5.2]) is available during the formalization. More details follow.
The procedure makes use of a few polynomial-time sub-routines (discussed below) and is defined in the following way:
and its properties (in )
We say that a subformula of is a neighbor of a leaf if either or is a subformula of . We say that a formula over variables is in normal form if for every and every literal , if is a leaf of and is a neighbor of in , then does not contain the variable .
Lemma 12.
There is a polynomial-time function that given a Boolean formula over input variables, outputs a formula over input variables such that the following holds:
-
(i)
.
-
(ii)
For every input , .
-
(iii)
is in normal form.
-
(iv)
is either a constant or , or contains no leaves labeled by constants and .
Moreover, the correctness of is provable in .
Proof Sketch..
It is enough to verify that the proof of [14, Claim 6.9] provides such a polynomial-time function and that its correctness can be established in . In more detail, if is not in normal form, we can efficiently compute a literal and a neighbor of that violates the corresponding property. As shown in [14, Claim 6.9], we can fix any leaf in by an appropriate constant so that the resulting formula satisfies conditions (i) and (ii) of Lemma 12. After at most iterations, we obtain a sequence of formulas such that satisfies conditions (i), (ii), and (iii) of the lemma. Moreover, condition (iv) can always be guaranteed by simplifying the final formula, i.e., by replacing subformulas by , by , by , and by . The correctness of can be established by polynomial induction for predicates (i.e., formulas), which is available in .
and its properties (in )
We argue in and follow the argument from the proof of [14, Lemma 6.8]. Let be a formula over input variables in normal form. We focus on the non-trivial case, and assume that , , and that contains no leaves labeled by constants. Let be a polynomial-time algorithm that outputs the number of leaves of that contain the variable (including its appearances as ). Let be the corresponding sequence of multiplicities, i.e., . Note that , where .
We claim that proves the existence of an index such that . First, for each , we define the cumulative sum . Let be the corresponding sequence, where we set . Notice that . Since contains elements, it can be efficiently computable from . We now argue by induction on that for some index we have . This implies that , as desired.
If , then and the result holds for . Assume the result holds for , and consider . If , we can pick and we are done. Otherwise, . By the induction hypothesis, there is an index such that . Using the lower bound on , we get that , which concludes the proof.
Consequently, proves the existence of a variable which appears times as a leaf of . Let be the leaves of labeled by either or . Recall that we assume that , , and that satisfies conditions (iii) and (iv) of Lemma 12. Therefore, each leaf has a neighbor subformula in that contains some leaf labeled by a literal not in . For this reason, if we set to an appropriate constant , will disappear from , thereby erasing at least another leaf not among . As in the proof of [14, Lemma 6.8], if we let be the constant that appears more often among and set in the restriction , all the leaves will be eliminated from together with at least additional leaves.666The existence of such a constant can be proved in in a way that is similar to the proof that some variable appears in at least leaves. Thus the total number of eliminated leaves, which we specify using a polynomial-time function , satisfies
Overall, it follows that
and its properties (in )
We only sketch the details. This is simply a polynomial-time algorithm that, given a formula on input variables and a restriction with (i.e.,ย restricts a single variable to a constant ), outputs a formula over input variables that sets every literal to the corresponding constant and simplifies the resulting formula, e.g., replaces subformulas by , by , by , and by . Additionally, for , we have
(5) |
Using the computed bound on for , we obtain that for and defined as above (with and ), and assuming that ,
(6) |
The last inequality uses that , which one can easily verify.
Note that runs in time polynomial in and that it is definable in . Next, we establish the correctness of in .
Lemma 13.
Let . Then .
Proof.
We consider the formula defined as
where as before we use and . Note that is a formula. Below, we argue that
Then, by polynomial induction for formulas (available in ) and using that trivially holds, it follows that . In turn, this yields .
Base Case: .
In this case, for a given formula and length , the hypothesis of is satisfied only if and . Let and . We need to prove that
Since and , evaluates to a constant on every input bit. The statement above is implied by Line in the definition of .
(Polynomial) Induction Step: .
Fix an arbitrary , let , and assume that holds. By the induction hypothesis, for every formula with , where , we have
(7) |
where and .
Now let , and let be a formula over -bit inputs of size . By the size bound on , ignores Line 1. If , then similarly to the base case it is trivial to check that the conclusion of holds. Therefore, we assume that and does not stop at Line 2. Let (Line 3), (Line 4), (Line 5), (Line 5), and (Line 5), where restricts the variable to the bit . Moreover, for convenience, let , , and . By Lemma 12 Item (i), Equationห6, and the bound ,
Thus is a formula on -bit inputs of size . Recall that for a given we have . Let (Line 6). By the first condition in the induction hypothesis (Equationห7) and the definition of each , we have . Below, we also rely on the last two conditions in the induction hypothesis (Equationห7), Lemma 12 Item (ii), and the last condition in Equation (5). We derive the following statements, where :
Notice that
These statements imply that, for each , . In other words, the conclusion of holds. This completes the proof of the induction step.
As explained above, the provability of in implies its provability in . Since , this completes the proof of Theorem 11.
4.1.2 On the Low-Level Details of the Formalization
In order to make our presentation accessible to a broader audience, in this section we provide more details about the formalization of algorithms and about the proofs of their basic properties. However, due to space restriction, the section is included only in the full version.
4.2 Upper Bound
In this section, we show that the parity function on bits can be computed by formulas of size , provably in . We can formalize this upper bound in the language of , defining an -sentence stating that the parity function can be computed by a formula of size for every input length :
Theorem 14.
Let . Then .
Proof.
is a sentence and our intended theory is . In order to implement some inductive proofs, it will be helpful to reduce the complexity of the formula. For this, we introduce a new polynomial-time function, , which generates the desired formula that computes the parity function on bits. Since it is a polynomial-time function, there is a symbol for it in and we can use it in the new formalization:
It is immediate that , thus we focus on proving . We continue with the following steps:
-
1.
We prove an upper bound of for the formulas calculating the parity function and its negation, when is a power of .
-
2.
We use this construction to derive the upper bound for any .
Next, we define a polynomial-time algorithm which computes a formula that calculates the parity function on bits and a formula that calculates the negation of the parity function on bits, if is a power of .
Lemma 15.
If is a power of , the algorithm correctly outputs two formulas of size which calculate the parity function and its negation, provably in .
Proof.
We split the proof of the correctness for the algorithm into properties:
-
1.
, where is the set of formulas on variables;
-
2.
;
-
3.
For now we only care about the case that is a power of , so we prove these properties conditionally (equivalently we prove ).777It is easy to check that this is true if and only if is a power of . That is why it suffices to use polynomial induction on , which is available in , since our formulas are at most .
We skip the proof of , which is proven by simple induction as below, using the fact that if are formulas then and are also formulas.
Property 2: .
For the base case, , we have , which means that the output will be two formulas with one leaf each, hence
For the induction step, we need . If is not a power of , then the statement is true by default. In the case of being a power of , we fix and we want to prove equivalently:
Assume that holds. From Line 8 we have that
(8) |
where and are copies of . From the induction hypothesis, this means that . Therefore, from (Equation 8) and the properties of the function , we get
Similarly for , which means that holds. This completes the proof of the induction for .
Property 3: .
Here the base case is trivial: for and , then . Similarly for .
For the induction step, we assume as above that and we want to prove:
We assume that holds and we write in the form
where and are copies of . Therefore, instead of , we can calculate
We need to prove that for all with . So, taking one such we can split its binary representation into two parts with lengths , such that .
The input to subformulas from the definition are the bits for , which means that their input is . Similarly, the input to subformulas is . Hence, we can define
From the properties of the evaluation function and the form of , we can prove in that , where the symbols are used as Boolean symbols here.
However, since and , from the induction hypothesis we get that
Next, it is easy to prove by checking all the 4 cases that
and as a result, we get
by the properties of the parity function. Similarly, we can prove that , which concludes the induction.
For the general case, we use a simple padding argument. For a number , we can define the number
This number is the least power of that is greater or equal to . It is easy to see that
If we replace by (the first coordinate of , we have by the above lemma that
-
1.
.
-
2.
For all with , we have , which by the lemma gives us
Since , we also have . Consequently, we have
These two together show that and the proof is complete.
4.3 Formula Size Hierarchy
In this section, we provide the proof of Theorem 3.
Theorem 16 (Theorem 3).
Consider rationals and , and let be a large enough positive integer. Then
Proof.
We combine the results of Section 4.1 and Section 4.2. We argue in . From Theorem 11, we get that
(9) |
and from Theorem 14, we have that
We can eliminate the constant from the latter using that and choosing a large enough , such that for every , (provably in ). Consequently,
(10) |
Finally, combining Equation 9 and Equation 10, we get that
which is exactly the formula size hierarchy, , for our choice of parameters and .
References
- [1] Sanjeev Arora and Boaz Barak. Computational Complexity โ A Modern Approach. Cambridge University Press, 2009. URL: http://www.cambridge.org/catalogue/catalogue.asp?isbn=9780521424264.
- [2] Samuelย R. Buss. Bounded Arithmetic. Bibliopolis, 1986.
- [3] Samuelย R. Buss. Bounded arithmetic and propositional proof complexity. In Logic of Computation, pages 67โ121. Springer Berlin Heidelberg, 1997.
- [4] Lijie Chen, Jiatu Li, and Igorย C. Oliveira. Reverse mathematics of complexity lower bounds. In Symposium on Foundations of Computer Science (FOCS), 2024.
- [5] Lijie Chen, Dylanย M. McKay, Codyย D. Murray, and R.ย Ryan Williams. Relations and equivalences between circuit lower bounds and Karp-Lipton theorems. In Computational Complexity Conference (CCC), pages 30:1โ30:21, 2019. doi:10.4230/LIPIcs.CCC.2019.30.
- [6] Alan Cobham. The intrinsic computational difficulty of functions. Proc. Logic, Methodology and Philosophy of Science, pages 24โ30, 1965.
- [7] Stephenย A. Cook. Feasibly constructive proofs and the propositional calculus (preliminary version). In Symposium on Theory of Computing (STOC), pages 83โ97, 1975. doi:10.1145/800116.803756.
- [8] Stephenย A. Cook and Phuong Nguyen. Logical Foundations of Proof Complexity. Cambridge University Press, 2010. doi:10.1017/CBO9780511676277.
- [9] Russell Impagliazzo and Avi Wigderson. Pโ=โBPP if E requires exponential circuits: Derandomizing the XOR lemma. In Symposium on the Theory of Computing (STOC), pages 220โ229, 1997. doi:10.1145/258533.258590.
- [10] Emil Jeลรกbek. Dual weak pigeonhole principle, boolean complexity, and derandomization. Annals of Pure and Applied Logic, 129(1-3):1โ37, 2004. doi:10.1016/j.apal.2003.12.003.
- [11] Emil Jeลรกbek. Weak pigeonhole principle and randomized computation. PhD thesis, Charles University in Prague, 2005.
- [12] Emil Jeลรกbek. The strength of sharply bounded induction. Mathematical Logic Quarterly, 52(6):613โ624, 2006. doi:10.1002/malq.200610019.
- [13] Emil Jeลรกbek. Approximate counting in bounded arithmetic. Journal of Symbolic Logic, 72(3):959โ993, 2007. doi:10.2178/jsl/1191333850.
- [14] Stasys Jukna. Boolean Function Complexity: Advances and Frontiers. Springer, 2012. doi:10.1007/978-3-642-24508-4.
- [15] Ravi Kannan. Circuit-size lower bounds and non-reducibility to sparse sets. Information and Control, 55(1):40โ56, 1982. doi:10.1016/S0019-9958(82)90382-5.
- [16] Jan Krajรญฤek. Bounded Arithmetic, Propositional Logic, and Complexity Theory. Encyclopedia of Mathematics and its Applications. Cambridge University Press, 1995.
- [17] Jan Krajรญฤek. Small circuits and dual weak PHP in the universal theory of p-time algorithms. ACM Transactions on Computational Logic (TOCL), 22(2):1โ4, 2021. doi:10.1145/3446207.
- [18] Jan Krajรญฤek and Igorย C. Oliveira. Unprovability of circuit upper bounds in Cookโs theory PV. Logical Methods in Computer Science, 13(1), 2017. doi:10.23638/LMCS-13(1:4)2017.
- [19] Jan Krajรญฤek, Pavel Pudlรกk, and Gaisi Takeuti. Bounded arithmetic and the polynomial hierarchy. Annals of Pure and Applied Logic, 52(1-2):143โ153, 1991. doi:10.1016/0168-0072(91)90043-L.
- [20] Jan Krajรญฤek. Proof Complexity. Encyclopedia of Mathematics and its Applications. Cambridge University Press, 2019. doi:10.1017/9781108242066.
- [21] Alexis Maciel, Toniann Pitassi, and Alanย R. Woods. A new proof of the weak pigeonhole principle. Journal of Computer and System Sciences, 64(4):843โ872, 2002. doi:10.1006/jcss.2002.1830.
- [22] Moritz Mรผller and Jรกn Pich. Feasibly constructive proofs of succinct weak circuit lower bounds. Annals of Pure and Applied Logic, 171(2), 2020. doi:10.1016/j.apal.2019.102735.
- [23] Igorย C. Oliveira. Meta-mathematics of computational complexity theory. Preprint, 2024.
- [24] Claudeย E. Shannon. The synthesis of two-terminal switching circuits. The Bell System Technical Journal, 28(1):59โ98, 1949. doi:10.1002/j.1538-7305.1949.tb03624.x.
- [25] Bellaย A. Subbotovskaya. Realization of linear functions by formulas using , , . In Soviet Math. Dokl, 1961.