The Minimum Oracle Circuit Size Problem

We consider variants of the minimum circuit size problem MCSP, where the goal is to minimize the size of oracle circuits computing a given function. When the oracle is QBF, the resulting problem MSCP QBF is known to be complete for PSPACE under ZPP reductions. We show that it is not complete under logspace reductions, and indeed it is not even hard for TC 0 under uniform AC 0 reductions. We obtain a variety of consequences that follow if oracle versions of MCSP are hard for various complexity classes under different types of reductions. We also prove analogous results for the problem of determining the resource-bounded Kolmogorov complexity of strings, for certain types of Kolmogorov complexity measures.


Introduction
The minimum circuit size problem (MCSP) asks to decide, for a given truth table f of a Boolean function and a parameter s, whether f is computable by a Boolean circuit of size at most s.MCSP is a well-known example of a problem in NP that is widely believed to be intractable, although it is not known to be NPcomplete.MCSP is known to be hard for the complexity class SZK under BPP-Turing reductions (Allender & Das 2014), which provides strong evidence for intractability.On the other hand, cc (2016) The minimum oracle circuit size problem 3 Table 1.1: Summary of main results: If MCSP A is C-hard under R, then S. The last column shows the theorem where the result is stated in the paper.If MCSP A is hard for a complexity class C under reductions of type R, then complexity statement S is true.
Table 1.1 below states our results for different instantiations of A, C, R, and S; note that S = ⊥ means that the assumption is false, i.e.MCSP A is not C-hard under R-reductions.Throughout, we assume that the reader is familiar with complexity classes such as NP, PP, PSPACE, NEXP, etc.We denote the polynomial hierarchy by PH, and its linear-time version (linear-time hierarchy) by LTH.
The Counting Hierarchy, denoted CH, is the union of the classes PP, PP PP , etc. CH was defined by Torán (1991) and arises frequently in complexity investigations.LTH was studied by Wrathall (1978), who showed that it coincides with the Rudimentary sets of Smullyan (1961).LTH has been studied, for instance, in (Allender & Gore 1991, 1993;Fortnow 2000;McKenzie et al. 2010).
For the most restricted reductions, uniform AC 0 , we get that MCSP A is not TC 0 -hard for any oracle A such that PH ⊆ SIZE A [poly] (Theorem 3.9), e.g. for A = ⊕P (Corollary 3.12).For any oracle A, we conclude new circuit lower bounds for the linear-time hierarchy and for NP A (Lemma 3.10 and Corollary 3.13). 1 1 Prior to our work, Murray & Williams (2015) have shown that if SAT≤ AC 0 m MCSP, then NP ⊆ P/poly.Their result is similar to (and is implied by) our Corollary 3.13 for the case of A = ∅.
If MCSP is P-hard under uniform TC 0 or logspace reductions, then P is different from PP or from PSPACE (Corollary 3.2 and Corollary 3.3).
One of the more interesting oracle circuit minimization problems is MCSP QBF .It was shown by Allender et al. (2006) that MCSP QBF is complete for PSPACE under ZPP-Turing reductions, but the question of whether it is complete for PSPACE under more restrictive reductions was left open.For most natural complexity classes C above PSPACE, there is a corresponding oracle circuit minimization problem (which we will sometimes denote MCSP C ) that is known to be complete under P/poly reductions, but is not known to be complete under more restrictive reductions (Allender et al. 2006).For the particular case of C = PSPACE, we denote this as MCSP QBF .We show that MCSP QBF is not PSPACE-complete under logspace reductions (Corollary 3.8).Furthermore, it is not even TC 0 -hard under uniform AC 0 reductions (Theorem 3.9).
Finally, for even more powerful oracles A, we handle even general polynomial-time reductions.We show that if SAT≤ p m MCSP EXP , then EXP = NEXP (Theorem 3.4).
We believe that MCSP is not TC 0 -hard under even nonuniform AC 0 reductions.While we are unable to prove this, we can rule out restricted AC 0 reductions for a certain gap version of MCSP.Define gap-MCSP as follows: Given a truth table f and a parameter s, output "No" if f requires circuit size s, and output "Yes" if f can be computed by a circuit of size at most s/2.Call a mapping from n-bit strings to m-bit strings α We prove that gap-MCSP is not TC 0 -hard under nonuniform AC 0 reductions that are n 1/31 -stretching (Theorem 3.17).

Related work.
The most closely related is the recent paper by Murray & Williams (2015), which also considers the question whether MCSP is NP-complete under weak reductions, and proves a number of conditional and unconditional results.The main unconditional result is that MCSP is not TC 0 -hard under uniform NC 0 reductions (or more generally, under O(n 1/2− )-time projections, for every > 0); we give an alternative proof of this result (Theorem 3.15).For conditional results, Murray & Williams (2015) show that if MCSP is NP-hard under uniform AC 0 reductions, then NP ⊂ P/poly and E ⊂ io−SIZE[2 Ω(n) ] (also implied by our Corollary 3.13 and Lemma 3.10) and that NP-hardness of MCSP under general polynomial-time reductions implies EXP = ZPP.
MCSP, MCSP QBF , and other oracle circuit minimization problems are closely related to notions of resource-bounded Kolmogorov complexity.Briefly, a small (oracle) circuit is a short description of the string that represents the truth table of the function computed by the circuit.Notions of resource-bounded Kolmogorov complexity that are roughly equivalent to (oracle) circuit size were presented and investigated by Allender et al. (2006).
In particular, there is a space-bounded notion of Kolmogorov complexity, KS, such that the set of KS-random strings (denoted R KS ) is complete for PSPACE under ZPP reductions.It is shown in Allender et al. (2006) that R KS is not even hard for TC 0 under AC 0 reductions, and R KS is not hard for PSPACE under logspace-Turing reductions.The proof of this nonhardness result also carries over to show that a set such as {f : f is the truth table of a function on n variables that has QBF circuits of size at most 2 n/2 } is also not hard for TC 0 under AC 0 reductions and is not hard for PSPACE under logspace-Turing reductions.However, it does not immediately carry over to MCSP QBF , which is defined as {(f, i): f is the truth table of a function on n variables that has QBF circuits of size at most i}; similarly it does not carry over to the set {(x, i) : KS(x) ≤ i}.Also, the techniques presented in Allender et al. (2006) have not seemed to provide any tools to derive consequences assuming completeness results for oracle circuit minimization problems for oracles less powerful than PSPACE.We should point out, however, that Allender et al. (2006) proves a result similar to (and weaker than) our Lemma 3.10 in the context of time-bounded Kolmogorov complexity: if R KT is TC 0 -hard under AC 0 many-one reductions, then PH ⊆ SIZE 2 n o(1) .

Our techniques.
To illustrate our proof techniques, let us sketch a proof of one of our results: If MCSP is P-hard under uniform logspace reductions, then P = PSPACE (Corollary 3.3).
The proof is by contradiction.Suppose that P = PSPACE.Our logspace reduction maps n-bit instances of QBF to n c -bit instances (f, s) of MCSP so that each bit of f is computable in O(log n) space.
1. Imagine that our reduction is given as input a succinct version of QBF, where some poly(log n)-size circuit D on each log n-bit input 1 ≤ i ≤ n computes the ith bit of the QBF instance.It is not hard to see that our reduction, given the circuit D, can compute each bit of f in poly(log n) space.Thus the Boolean function with the truth table f is computable by a PSPACE = P algorithm (which also has the circuit D as an input).It follows that this function f is computable by some polynomialsize Boolean circuit.
2. Next, since we know that f has at most polynomial circuit complexity, to decide the MCSP instance (f, s), we only need to consider the case where s < poly (since for big values of s, the answer is "Yes").But deciding such MCSP instances (which we call succinct MCSP) is possible in Σ p 2 : guess a circuit of size at most s, and verify that it agrees with the given polynomial-size circuit for f on all inputs.

Finally, since Σ p
2 ⊆ PSPACE = P, we get that our succinct MCSP instances can be decided in P. The reduction from succinct QBF to succinct MCSP is also in PSPACE = P. Hence, succinct QBF is in P. But, succinct QBF is EXPSPACE-complete, and so we get the collapse EXPSPACE = P, contradicting the hierarchy theorems.
In step (1) of the sketched proof, the uniformity of an assumed reduction to MCSP is used to argue that the truth table f produced by the reduction is in fact "easy" to compute uniformly.The uniform complexity of computing the function f is roughly the "exponential" analogue of the uniform complexity of the reduction.For circuit classes such as AC 0 and TC 0 , we use the well-known connection between the "exponential" analogue of uniform AC 0 and PH, and between the "exponential" analogue of uniform TC 0 and CH.
cc (2016) The minimum oracle circuit size problem 7 We use the uniform easiness of the function f to conclude that f has small circuit complexity (and hence our reduction actually outputs instances of succinct MCSP).To get that conclusion, we need to assume (or derive) the collapse to P/poly of the uniform complexity class that contains f ; in our example above, we got it from the assumption that PSPACE = P.
Step (2) exploits the fact that succinct MCSP does not become "exponentially harder" (unlike the usual succinct versions of hard problems), but is actually computable in Σ p 2 .In Step (3), we combine the algorithm for our reduction and the algorithm for succinct MCSP to get an "efficient" algorithm for the succinct version of the input problem (succinct QBF in our example).Since the succinct version of the input problem does become exponentially harder than its nonsuccinct counterpart, we get some impossible collapse (which can be disproved by diagonalization).
We use this style of proof for all our results involving reductions computable by uniform TC 0 and above.However, for the case of uniform AC 0 (and below), we get stronger results by replacing the diagonalization argument of Step (3) with the nonuniform AC 0 circuit lower bound for PARITY (Håstad 1989).
Remainder of the paper.We state the necessary definitions and auxiliary results in Section 2. Our main results are proved in Section 3, and some generalizations are given in Section 4. We give concluding remarks in Section 5.

Definitions
Definition 2.1.The minimum circuit size problem MCSP, as defined in (Kabanets & Cai 2000), is where f is a string of length 2 m encoding the entire truth table of some m-variate Boolean function.(Versions of this problem have been studied long prior to Kabanets & Cai (2000).See Allender & Das (2014); Trakhtenbrot (1984) for a discussion of this history.)We will also consider the analogous problem for circuits with oracles, the minimum A-circuit size problem MCSP A , defined analogously, where instead of ordinary circuits, we use circuits that also have oracle gates that query the oracle A. When A is a standard complete problem for some complexity class C, we may refer to this as MCSP C .Note that, for any oracle A, MCSP A ∈ NP A .
We will not need to be very specific about the precise definition of the "size" of a circuit.Our results hold if the "size" of a circuit is the number of gates (including oracle gates), or the number of "wires", or the number of bits used to describe a circuit in some standard encoding.It is perhaps worth mentioning that the different versions of MCSP that one obtains using these different notions of "size" are not known to be efficiently reducible to each other.
Circuit size relative to oracle A is polynomially related to a version of time-bounded Kolmogorov complexity, denoted KT A , which was defined and studied by Allender et al. (2006).
) runs for at most t steps and accepts iff x i = b}.Here, U is some fixed universal Turing machine, which has random access to the oracle A and to the input string (or "description") d; x i denotes the i-th symbol of x, where x |x|+1 = * .
By analogy to MCSP A , we define the "minimum KT problem": All of our results that deal with MCSP A also apply to MKTP A .We wish to warn the reader that one's intuition can be a poor guide, when judging how MCSP A and MCSP B compare to each other, for given oracles A and B. For instance, it is known that MCSP SAT ZPP-Turing reduces to MCSP QBF (Allender et al. 2006), but no deterministic reduction is known.Similarly, no efficient reduction of any sort is known between MCSP and MCSP SAT .Some of our theorems derive consequences from the assumption that MCSP SAT is hard for some complexity class under AC 0 reductions.Although one might suspect that this is a weaker hypothesis than assuming that MCSP is hard for the same complexity class under cc (2016) The minimum oracle circuit size problem 9 AC 0 reductions-certainly the best upper bound for MCSP SAT is worse than the best known upper bound for MCSP-we are not able to derive the same consequences assuming only that MCSP is hard.For essentially all time-and space-bounded complexity classes C that contain PSPACE, MCSP C is complete for C/poly under P/poly reductions (Allender et al. 2006(Allender et al. , 2010)), but uniform reductions are known only for two cases (Allender et al. 2006): when C = PSPACE (MCSP QBF is complete for PSPACE under ZPP reductions) and when C = EXP (MCSP EXP is complete for EXP under NP-Turing reductions).

Succinct problems.
The study of succinct encodings of computational problems was introduced by Galperin & Wigderson (1983); Papadimitriou & Yannakakis (1986), and has been studied since then by Balcázar et al. (1992); Wagner (1986), among others.Succinct encodings play an important role in the proofs of our main results.
Definition 2.4.Given a language L, we define the succinct version of L (denoted succ.L) to be the language {C | tt(C) ∈ L} where C is a Boolean Circuit and tt(C) is the truth table for C.
It will be necessary for us to consider "succinctly presented" problems, where the circuit that constitutes the succinct description is itself an oracle circuit: Definition 2.5.Given a language L and an oracle A, we define the A-succinct version of L (denoted A-succ.L) to be the language {C | tt(C) ∈ L} where C is a Boolean Circuit with oracle gates, and tt(C) is the truth table for C, when it is evaluated with oracle A. If A = ∅, we denote this language as succ.L.
The typical situation that arises is that the succinct version of a problem A has exponentially greater complexity than A. In particular, this happens when A is complete for a complexity class under "logtime reductions".Definition 2.6.We say that a function f can be computed in logarithmic time if there exists a random-access Turing machine that, given (x, i), computes the ith bit f (x) in time O(log |x|).(1992) presented a large list of complexity classes (C 1 , C 2 ), where C 1 is defined in terms of some resource bound B(n) and C 2 is defined in the same way, with resource bound B(2 n ), such that if a set A is complete for C 1 under logtime reductions, then succ.A is complete for C 2 under polynomial-time many-one reductions.In particular, we will make use of the fact that succ.SAT is complete for NEXP, succ.MajSAT is complete for probabilistic exponential time, succ.QBF is complete for EXPSPACE, and succ.CVP is complete for EXP.
Somewhat surprisingly, the complexity of succ.MCSP appears not to be exponentially greater than that of MCSP.(Related observations were made earlier by Williams (2012).) Theorem 2.7.succ.MCSP ∈ Σ p 2 Proof.We present an algorithm in Σ p 2 that decides succ.MCSP.Given an instance of succinct MCSP C, note that C ∈ succ.MCSP iff z is a string of the form (f, s) ∈ MCSP, where z = tt(C).By definition, |z| must be a power of 2, say |z| = 2 r , and |f | must also be a power of 2, say |f | = 2 m for some m < r.Note also that if s > |f | = 2 m , then (f, s) should obviously be accepted, since every m-variate Boolean function has a circuit of size 2 m .To be precise, we will choose one particular convention for encoding the pair (f, s); other reasonable conventions will also yield a Σ p 2 upper bound.Let us encode (f, s) as a string of length 2 m+1 , where the first 2 m bits give the truth table for f , and the second 2 m bits give s in binary.Note that this means that C has m + 1 input variables, and hardwiring the high-order input bit of C to 0 results in a circuit C for f (of size at most |C|).
Using this encoding, the "interesting" instances (f, s) are of the form where the second half of the string is all zeros, except possibly for the low-order m bits (encoding a number s ≤ 2 m = |f |).The low-order m bits can be computed deterministically in polynomial time, given C, by evaluating C on inputs 1 m+1−log m 0 log m , 1 m+1−log m 0 −1+log m 1, . . ., 1 m+1 .Let the number encoded by the low-order m bits be s .Then C (an encoding of (f, s)) is in • there is some bit position j corresponding to one of the highorder 2 m − m bits of s such that C(j) = 1, or • there exists a circuit D of size at most s such that, for all i, D(i) = C (i). (Note that s ≤ s.) It is easily seen that this can be checked in Σ p 2 .Because this proof relativizes, we obtain: Proof.We use the same encoding as in Theorem 2.7.Thus, an oracle circuit C encoding an instance (f, s) (where f is an m-ary function) has m + 1 input variables, and hardwiring the high-order input bit of C to 0 results in an oracle circuit C (with oracle B) for f (of size at most |C|).But if B≤ p T A, then this also gives us an oracle circuit C (with oracle A) for f (of size at most |C| k for some k), where we can obtain C from C in polynomial time.
Then C (an encoding of (f, s)) is in B-succ.MCSP A iff • there is some bit position j corresponding to one of the highorder 2 m − m bits of s such that C B (j) = 1, or • there exists a circuit D of size at most s such that, for all i, D A (i) = C A (i).
It is easily seen that this can be checked in (Σ p 2 ) A .An analogous result also holds for MKTP A .Theorem 2.9.Let A and B be oracles such that B≤ p T A. Then B-succ.MKTP A is in (Σ p 2 ) A .
Proof.KT A (x) could be) and thus should consist of at O(log |x|) bits.In order to mark the location of the "comma" separating x and i, we use the familiar convention of doubling each bit of i, and using the symbols 10 to mark the position of the "comma".Thus, given a circuit C with n variables, a (Σ p 2 ) B machine can compute the length of the encoded string x as follows: 1. Using nondeterminism, guess a position and verify that C B ( ) = 1 and C B ( + 1) = 0.

Using co-nondeterminism, verify that for all
> it is not the case that C B ( ) = 1 and C B ( + 1) = 0. (If this test passes, then the tt(C) is of the form (x, i) for some x and i, although it allows the possibility that absurdly large numbers i are provided.)3. Reject if the number of bits used in the encoding of i is more than 4n (which is greater than 4 log |x|).

This (Σ p
2 ) B computation can be simulated by a (Σ p 2 ) A , by our assumption that B≤ p T A. The rest of the algorithm follows closely the algorithm that we presented for MCSP.Given a circuit C, guess the number such that tt(C) = (x, i) for some string x of length .Without loss of generality, we can assume that the universal Turing machine used to define KT takes a description of a program and the input to the The (Σ p 2 ) A algorithm for B-succ.MKTP A is thus: 1. Guess and verify as above, and in parallel: 2. Evaluate C B (j) for the 4n largest positions j < 2 n (using oracle A), and thus obtain the encoding of i.
cc ( 2016) The minimum oracle circuit size problem

Constant-depth reductions.
Proposition 2.10.Suppose that f is a uniform AC 0 reduction from a problem A to a problem B. Let C be an instance of succ.A.Then, the language is in LTH (the linear-time hierarchy).
Proof.Consider the unary version of the above language: we claim that this language is in uniform AC 0 .To see this, note that after computing the length of the input (in binary), and thus obtaining a description of C (of length log n), an AC 0 algorithm can compute each bit of tt(C).For instance, the ith bit of tt(C) can be computed by guessing a bit vector of length log n recording the value of each gate of C on input i, and then verifying that all of the guessed values are consistent.Once the bits of tt(C) are available, the AC 0 algorithm computes f (tt(C)).
The result is now immediate, from (Allender & Gore 1993, Proposition 5), which shows that the rudimentary languages (that is, the languages in the linear-time version LTH of the polynomialtime hierarchy PH) are precisely the sets whose unary encodings are in Dlogtime-uniform AC 0 .By an entirely analogous argument, we obtain: Proposition 2.11.Suppose that f is a uniform TC 0 reduction from a problem A to a problem B. Let C be an instance of succ.A.Then, the language

Conditional collapses and separations of complexity classes.
Our first theorem shows that significant conclusions follow if MCSP is hard for P under AC 0 reductions.(Note that a stronger result appears later in the paper, as Corollary 3.13.) Theorem 3.1.If there is any set A in the polynomial hierarchy such that MCSP A (or MKTP A ) is hard for P under uniform AC 0 reductions, then P = NP.
Proof.We present only the proof for MCSP A ; the proof for MKTP A is identical.Suppose that P = NP and MCSP A is hard for P under AC 0 reductions.Thus, there is a family {C n } of AC 0 circuits reducing SAT to MCSP A , such that C n (φ) = f (φ), where f is the reduction function and φ is an instance of SAT.
Now we claim that succ.SAT≤ p m succ.MCSP A .To see this, consider an instance D of succ.SAT (that is, a circuit D on n variables that, when given input i, outputs the ith bit of a SAT instance of size 2 n ).This problem has been shown to be complete for NEXP (Papadimitriou 2003).By Proposition 2.10, we have that the language is in PH.By our assumption that P = NP, we have that this language is in P. Let {E m } be a family of circuits deciding this language.The function that takes input D and outputs E |(D,n)| (with D hardwired in) is a polynomial-time reduction from succ.SAT to succ.MCSP A , which is in (Σ p 2 ) A , by Corollary 2.8.Since A ∈ P (by our assumption that P = NP), we have that NEXP ⊆ P, which is a contradiction.
Corollary 3.2.If there is any set A ∈ CH such that MCSP A (or MKTP A ) is hard for P under TC 0 reductions, then P = PP.
Proof.The proof is similar to that of the preceding theorem.If P = PP, and there is a TC 0 reduction f from SAT to MCSP A , then the language is in CH (by Proposition 2.11), and hence is in P. Now, just as above, we use the circuit family recognizing this language to construct a polynomial-time reduction from succ.SAT to succ.MCSP A , leading to the contradiction that NEXP = P.
Corollary 3.3.Suppose that MCSP (or MKTP) is hard for P under logspace many-one reductions.Then P = PSPACE.
Proof.The proof proceeds along similar lines.Assume P = PSPACE.Consider an instance D of succ.SAT, where there is a reduction f computable in logspace reducing SAT to MCSP.Then the language is in PSPACE, since polynomial space suffices in order to compute f on an exponentially large input.(We do not need to store the string tt(D), and the bits of tt(D) can re-computed when they are needed.)By our assumption that P = PSPACE, this language is in P and hence is recognized by a uniform circuit family {E m }.Now, as above, the function that maps D to E |(D,n)| (with D hardwired in) is a polynomial-time reduction from succ.SAT to succ.MCSP, which yields the contradiction that NEXP = P.
Proof.Let f be the reduction taking an instance of SAT to an instance of MCSP EXP .We construct a reduction from succ.SAT to B-succ.MCSP EXP for some B ∈ EXP.
Consider the language where φ C is the formula described by the circuit C, viewed as an instance of succ.SAT with n input variables.We can decide L in cc ( 2016) exponential time because we can write down φ C in exponential time, and then we can compute f (φ C ) in exponential time because f is a polytime reduction on an exponentially large instance.
Let {D m } be a family of oracle circuits for L, using an oracle for an EXP-complete language B. Thus the mapping C → D |C|+n is a polynomial-time reduction from succ.SAT to B-succ.MCSP EXP , which is in (Σ p 2 ) EXP = EXP (see, e.g.(Allender et al. 2010, Theorem 24)), and thus EXP = NEXP.
Proof.As discussed in (Allender et al. 2006), there is essentially no difference between Kt(x) and KT EXP (x).Thus the proof is immediate, given the proof of Theorem 3.4.Theorem 3.6.If MCSP QBF or MKTP QBF is hard for NP under logspace reductions, then NEXP = PSPACE.
Proof.Let f be the reduction taking an instance of SAT to an instance of MCSP QBF .We construct a reduction from succ.SAT to QBF-succ.MCSP QBF .
Consider the language where φ C is the formula described by the circuit C, viewed as an instance of succ.SAT with n input variables.We can decide L in PSPACE, because we can compute f (φ C ) by building the bits of φ C as they are needed.Let {D m } be a family of oracle circuits for L, using an oracle for QBF.Theorem 3.9.For any language A that is hard for PH under P/poly reductions, MCSP A is not hard for TC 0 under uniform AC 0 reductions.
The theorem will follow from the next lemma.Recall that LTH (linear-time hierarchy) stands for the linear-time version of the polynomial-time hierarchy PH.
Proof.It is shown in (Agrawal 2011, Theorems 5.1 and 6.2) that if a set is hard for any class C that is closed under TC 0 reductions under uniform AC 0 reductions, then it is hard under lengthincreasing (uniform AC 0 )-uniform NC 0 reductions.(Although Theorems 5.1 and 6.2 in (Agrawal 2011) are stated only for sets that are complete for C, they do hold also assuming only hardness (Agrawal 2014), using exactly the same proofs.)Here, a (uniform AC 0 )uniform NC 0 reduction is a family {F n } n≥0 of functions such that each F n is an NC 0 circuit with the property that the direct connection language DCL = {(n, t, i, j)| gate i of F n has type t and has an edge leading from gate j} with n in unary is in Dlogtime-uniform AC 0 .
Hence, if MCSP A is hard for TC 0 under uniform AC 0 reductions, then we get that PARITY is reducible to MCSP A under a lengthincreasing (uniform AC 0 )-uniform NC 0 reduction.Such a reduction 18 Allender, Holden & Kabanets cc (2016) R maps PARITY instances x ∈ {0, 1} n to MCSP A instances (f, s), where f is the truth table of a Boolean function, f ∈ {0, 1} m , for some m such that n ≤ m ≤ n O(1) , and s is the size parameter in binary.Since every Boolean function with an m-bit truth table is computable by a Boolean circuit of size at most m, we may assume that 0 ≤ s ≤ m, and hence |s| ≤ O(log n).
Being the output of an NC 0 reduction, the binary string s depends on at most O(log n) bits in the input string x.Imagine fixing these bits in x to achieve the minimum value of the parameter s.Denote this minimum value of s by v. (We do not need v to be efficiently computable in any sense.)We get a nonuniform NC 0 reduction from PARITY on n − O(log n) ≥ n/2 bit strings to MCSP A with the size parameter fixed to the value v.
Claim 3.11.For any language A and any 0 Proof (Claim 3.11).Each A-oracle circuit of size v on log m inputs can be described by a binary string of length at most O(v 2 log v), since each of v gates has at most v inputs.Thus, there are at most 2 O(v 2 log v) Boolean functions on log m inputs that are computable by A-oracle circuits of size at most v. Checking whether any one of these truth tables equals to the input truth table f can be done by a DNF, where we take an OR over all easy functions, and for each easy function we use an AND gate to check equality to the input f .We conclude that PARITY on n/2-bit strings is solvable by AC 0 circuits of depth 3 and size m • 2 O(v 2 log v) .Indeed, each bit of the truth table f is computable by an NC 0 circuit and hence by a DNF (and a CNF) of constant size.Plugging in these DNFs (or CNFs) for the bits of f into the DNF formula from Claim 3.11 yields the required depth-3 AC 0 circuit for PARITY on inputs of length at least n/2.
Next, since PARITY on m-bit strings requires depth-3 AC 0 circuits of size at least 2 Ω( √ m) (Håstad 1989), we get that v ≥ n 1/5 .Hence, on input 0 n , our uniform NC 0 reduction produces (f, s) cc ( 2016) The minimum oracle circuit size problem 19 where f is the truth table of a Boolean function on r-bit inputs that has A-oracle circuit complexity at least v ≥ n 1/5 ≥ 2 r , for some > 0.
Finally, since the NC 0 reduction is (uniform AC 0 )-uniform, we get that the Boolean function whose truth table is f is computable in LTH.
Proof (Theorem 3.9).Towards a contradiction, suppose that MCSP A is TC 0 -hard under uniform AC 0 reductions.Then, by Lemma 3.10, there is a language L ∈ PH that requires A-oracle circuit complexity 2 Ω(n) almost everywhere.However, since A is PH-hard under P/poly reductions, we get that L ∈ SIZE A [poly].A contradiction.
Proof.By Toda's theorem (Toda 1991), PH ⊆ BPP ⊕P , which in turn is contained in the class of problems P/poly-reducible to the standard complete problem for ⊕P.The result then follows by Theorem 3.9.
Corollary 3.13.Suppose that, for some oracle A, MCSP A is TC 0 -hard under uniform AC 0 reductions.Then NP A ⊆ SIZE A [poly].Remark 3.14.Murray & Williams (2015) prove results similar to (and implied by) our Lemma 3.10 and Corollary 3.13 for the case of the empty oracle A = ∅.Namely, they show that if MCSP is NP-hard under uniform AC 0 reductions, then NP ⊆ P/poly and E ⊆ io−SIZE[2 Ω(n) ].
Finally, we note that the ideas in our proof of Lemma 3.10 yield an alternate proof of the result by Murray & Williams (2015) that Proof.Suppose that PP = C and that MCSP A is hard for C.Then, there exists a reduction from Maj.SAT (the standard complete problem for PP) to MCSP A computable in TC 0 .Similarly to Corollary 3.2, this gives us a p T reduction from succ.MajSAT to Bsucc.MCSP A for some B ∈ CH; and thus B is in C.Then, B≤ p T A, and thus succ.MajSAT is in (Σ p 2 ) A , which is in CH and hence is in PP.However, succ.MajSAT is complete for probabilistic exponential time and hence is not in PP.Fenner et al. (1994) introduced several complexity classes, including SPP and WPP that are "low for PP", in the sense that PP = PP SPP = PP WPP .Thus we obtain the following corollary: Corollary 4.5.Let A be any set in the counting hierarchy that is hard for WPP under ≤ p T reductions.If MCSP A is hard for WPP (or SPP) under uniform TC 0 reductions, then WPP = PP (respectively, SPP = PP).

Discussion
The contrast between Theorem 3.1 and Corollary 3.7 is stark.Theorem 3.1 obtains a very unsurprising consequence from the assumption that MCSP is hard for P under a very restrictive class of reductions, while Corollary 3.7 obtains a very unlikely collapse from the assumption that the apparently much harder problem MCSP QBF is hard for P under a much less restrictive class of reductions.Yet, the absence of any known efficient reduction from MCSP to MCSP QBF means that we have been unable to obtain any unlikely consequences by assuming that MCSP is hard for P. We believe that it should be possible to provide evidence that MCSP cc (2016) The minimum oracle circuit size problem 25 is not hard for P, and we pose this as an open question for further research.
program and runs the program on that input.The universal oracle machine U , given a description d of length |C| + | | + O(1), along with (i, b) can output * if i > and otherwise can use oracle A to simulate C B (i) and accept iff the answer is b.The running time will be at most (|C| + | |) k for some k, which gives us an upper bound on KT A (x).

13 4 .
Guess a description d of length at most i.Reject if U A (d, + 1, * ) does not accept.5. Using co-nondeterminism, verify that for all j ≤ and all b ∈ {0, 1}, U A (d, j, b) accepts iff C B (j) = b.
Proof.If NPA ⊆ SIZE A [poly], then PH A ⊆ SIZE A [poly].Now the result follows from Lemma 3.10.
can state the following theorem about TC 0 reductions.Theorem 4.4.Let C be any class such that if PP = C, then CH = C.If there is a set A ∈ CH that is hard for C under ≤ p T reductions such that MCSP A (or MKTP A ) is hard for C under uniform TC 0 reductions, then PP = C.

. Impossibility of uniform AC 0 reductions.
Thus the mapping C → D |C|+n is a polynomial-time reduction from succ.SAT to QBF-succ.MCSP QBF , which is in (Σ p 2 ) QBF = PSPACE, implying NEXP = PSPACE.Corollary 3.7.If MCSP QBF (or MKTP QBF ) is hard for P under logspace reductions, then EXP = PSPACE.The proof is identical to the proof of the preceding theorem, with NP replaced by P, and with NEXP replaced by EXP, resulting in a reduction from succ.CVP to QBF-succ.MCSP QBF .If we carry out a similar argument, replacing NP with PSPACE, we obtain the contradiction EXPSPACE = PSPACE, yielding the following.Corollary 3.8.None of MCSP QBF and MKTP QBF is PSPACEhard under logspace reductions.