Abstract 1 Introduction 2 Preliminaries 3 Hardness of Range Avoidance 4 Lower Bounds for Student-Teacher Games

Hardness of Range Avoidance and Proof Complexity Generators from Demi-Bits

Hanlin Ren ORCID Institute for Advanced Study, Princeton, NJ, USA Yichuan Wang ORCID Department of EECS, University of California, Berkeley, CA, USA Yan Zhong ORCID Department of Computer Science, Johns Hopkins University, Baltimore, MD, USA
Abstract

Given a circuit G:{0,1}n{0,1}m with m>n, the range avoidance problem (Avoid) asks to output a string y{0,1}m that is not in the range of G. Besides its profound connection to circuit complexity and explicit construction problems, this problem is also related to the existence of proof complexity generators – circuits G:{0,1}n{0,1}m where m>n but for every y{0,1}m, it is infeasible to prove the statement “yRange(G)” in a given propositional proof system.

This paper connects these two problems with the existence of demi-bits generators, a fundamental cryptographic primitive against nondeterministic adversaries introduced by Rudich (RANDOM ’97).

  • We show that the existence of demi-bits generators implies Avoid is hard for nondeterministic algorithms. This resolves an open problem raised by Chen and Li (STOC ’24). Furthermore, assuming the demi-hardness of certain LPN-style generators or Goldreich’s PRG, we prove the hardness of Avoid even when the instances are constant-degree polynomials over 𝔽2.

  • We show that the dual weak pigeonhole principle is unprovable in Cook’s theory 𝖯𝖵1 under the existence of demi-bits generators secure against 𝐀𝐌/O(1), thereby separating Jeřábek’s theory 𝖠𝖯𝖢1 from 𝖯𝖵1. Previously, Ilango, Li, and Williams (STOC ’23) obtained the same separation under different (and arguably stronger) cryptographic assumptions.

  • We transform demi-bits generators to proof complexity generators that are pseudo-surjective in certain parameter regime. Pseudo-surjectivity is the strongest form of hardness considered in the literature for proof complexity generators.

Our constructions are inspired by the recent breakthroughs on the hardness of Avoid by Ilango, Li, and Williams (STOC ’23) and Chen and Li (STOC ’24). We use randomness extractors to significantly simplify the construction and the proof.

Keywords and phrases:
Range Avoidance, Proof Complexity Generators
Copyright and License:
[Uncaptioned image] © Hanlin Ren, Yichuan Wang, and Yan Zhong; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Complexity classes
; Theory of computation Circuit complexity ; Theory of computation Proof complexity ; Theory of computation Cryptographic primitives ; Theory of computation Pseudorandomness and derandomization ; Theory of computation Expander graphs and randomness extractors
Related Version:
Full Version: https://arxiv.org/abs/2511.14061
Acknowledgements:
We thank Yilei Chen for helpful discussions regarding the LPN assumption, Xin Li for helpful discussions about extractors, and Rahul Ilango for sending us a draft version of [32]. We are also grateful to Erfan Khaniki and Iddo Tzameret for helpful suggestions that improved the presentation of this paper.
Editor:
Shubhangi Saraf

1 Introduction

This paper makes progress on the hardness of the range avoidance problem and the existence of proof complexity generators. We begin with a brief overview of these two lines of research.

1.1 Range Avoidance

The range avoidance problem (Avoid) is a total search problem introduced by [43, 45, 72]. Given a Boolean circuit G:{0,1}n{0,1}m with m>n (usually we also require mpoly(n)), the goal is to find a string y{0,1}m such that yRange(G). This problem has attracted considerable interest due to its connection to central problems in complexity theory such as explicit constructions [45, 72, 16, 30, 26] and circuit lower bounds [45, 13, 61, 47]. We refer the reader to [46] for a comprehensive survey on the range avoidance problem.

The range avoidance problem admits a trivial randomized algorithm: simply output a uniformly random m-bit string, which will lie outside the range of G with high probability. On the other hand, deterministic algorithms for Avoid would imply breakthroughs in explicit constructions and circuit lower bounds [45, 72, 30, 26]. Since such breakthroughs are widely believed to be true (albeit difficult to prove), the aforementioned results only suggest that deterministic algorithms for Avoid would be difficult to obtain unconditionally, rather than that such algorithms are unlikely to exist. This raises a natural question: Is there a deterministic algorithm for Avoid?

Perhaps surprisingly, recent results suggested that the answer is likely no under plausible cryptographic assumptions. Ilango, Li, and Williams [33] showed that Avoid is hard for deterministic algorithms assuming the existence of subexponentially secure indistinguishability obfuscation (i𝒪) and that 𝐍𝐏𝐜𝐨𝐍𝐏. Chen and Li [17] extended this result and showed that Avoid is hard even for nondeterministic algorithms, under certain assumptions regarding the nondeterministic hardness of LWE (Learning with Errors) or LPN (Learning Parity with Noise). In addition to providing compelling evidence for the hardness of Avoid, these results establish a strong separation between deterministic and randomized algorithms (recall that there exists a trivial randomized algorithm for Avoid).

The hardness results in [33, 17] open up several exciting research directions:

  1. 1.

    Can the hardness of Avoid be based on weaker (or alternative) assumptions?

    The assumptions used in prior work, i.e., i𝒪 [33] and public-key encryption [17], belong to Cryptomania in the terminology of Impagliazzo’s worlds [34]. Can we base the hardness of range avoidance on assumptions of a “Minicrypt” flavor, such as one-way functions or pseudorandom generators? Additionally, both [33] and [17] rely on subexponential indistinguishability assumptions111More precisely, the assumptions in [33, 17] assert subexponential indistinguishability against polynomial-time adversaries. This level of security is referred to as “JLS-security” in [33], where “JLS” comes from the strengths of the “well-founded” assumptions used to construct i𝒪 in [37].. Are such subexponential assumptions necessary?

  2. 2.

    Can we obtain hardness of Avoid for instances computed by restricted circuits?

    Previously, under assumptions related to LWE, Chen and Li [17] showed that Avoid remains hard even when each output bit of G is computed by a so-called “𝖣𝖮𝖱𝖬𝖠𝖩 and O(logn) circuit”. No such results were known for other restricted circuit classes. The related remote point problem has been shown to be hard under LPN-style assumptions for 𝖷𝖮𝖱 and O(logn) circuits (i.e., O(logn)-degree polynomials over 𝔽2) [17].

This paper makes progress on both fronts. We show that Avoid is hard for nondeterministic algorithms under the existence of demi-bits generators with sufficient stretch222The stretchability of generic demi-bits generators is only partially understood. Recent work of Tzameret and Zhang [77] shows that demi-bits generator with 1-bit stretch G:{0,1}n{0,1}n+1 implies those with a sublinear bits of stretch G:{0,1}n{0,1}n+nc for any constant 0<c<1. This is the first proof that generic demi-bits generators are stretchable at all, but it still falls short of the linear or polynomial stretch assumed in our hypothesis. [73]. A formal definition of demi-bits generators is deferred to Subsection 2.1; in Appendix B of the full version of this paper, we also provide some candidate constructions supporting their existence. For the purpose of this introduction, it suffices to keep in mind that demi-bits generators are a version of cryptographic pseudorandom generators secure against nondeterministic adversaries.

We highlight three key features of our results here:

  1. 1.

    Minicrypt-style assumptions against nondeterministic adversaries.

    Roughly speaking, demi-bits generators are (cryptographic) pseudorandom generators secure against nondeterministic adversaries333In fact, Rudich [73] introduced two ways to define pseudorandomness against nondeterministic adversaries: super-bits and demi-bits. Demi-bits are weaker than super-bits.. They are arguably a natural “Minicrypt” analog of pseudorandom generators in the context of cryptography against nondeterministic adversaries. Moreover, our results only rely on the super-polynomial hardness of these demi-bits generators, thereby completely getting rid of the subexponential (or “JLS”-style) assumptions used in prior work.

  2. 2.

    Hardness for restricted circuit classes.

    Under the assumption that certain concrete demi-bits generators are secure (e.g., those based on LPN or Goldreich’s PRG), we show that the range avoidance problem remains hard for nondeterministic algorithms even when the underlying circuits belong to 𝖷𝖮𝖱 and O(1), i.e., constant-degree polynomials over 𝔽2.

  3. 3.

    Simplicity of the proof for hardness of range avoidance.

    In contrast to [33, 17], which rely on sophisticated and delicate adaptations of high-end cryptographic assumptions, our proof of the hardness of range avoidance (Theorem 27) is based solely on the most elementary pseudorandom constructions together with the existence of demi-bits. This approach distills the arguments of [33, 17] to their essence, yielding a proof that is both conceptually cleaner and technically simpler. In fact, the proof of Theorem 27 fits in just half a page. Moreover, by isolating the core ingredients, this simplified framework opens the door to potential extensions and generalizations that may be harder to see in the more cryptographically heavy approaches.

1.2 Proof Complexity Generators

Let G:{0,1}n{0,1}m be a Boolean circuit where m>n, and 𝒫 be a propositional proof system. We say that G is a (secure) proof complexity generator [3, 49] against 𝒫 if, for every string y{0,1}m, the (properly encoded) statement “yRange(G)” does not admit short proofs in 𝒫.444If y is in fact in the range of G, then “yRange(G)” is a false statement and hence has no proof in any sound proof system. Therefore, this requirement is equivalent to that, for every yRange(G), the tautology “yRange(G)” is hard to prove in 𝒫. A comprehensive survey about proof complexity generators can be found in [57].

The study of proof complexity generators is motivated by at least the following themes:

  1. 1.

    Pseudorandomness in proof complexity [3].

    A standard pseudorandom generator (PRG) G:{0,1}n{0,1}m [78] fools a (polynomial-time) algorithm 𝒟 if 𝒟 cannot distinguish the outputs of G from truly random m-bit strings; that is, 𝒟(𝒰m)𝒟(G(𝒰n)), where 𝒰 denotes the uniform distribution over -bit strings. Analogously, one can say that G fools a propositional proof system 𝒫 if 𝒫 cannot distinguish between the outputs of G and truly random m-bit strings, and a natural way of formalizing this is to say that 𝒫 cannot efficiently prove any string outside the range of G.

    Following the idea of pseudorandomness in proof complexity, subsequent works [53, 65, 54, 71, 42] studied the hardness of the Nisan–Wigderson generator ([63]) as a proof complexity generator in various settings. An influential conjecture of Razborov asserts that the Nisan–Wigderson generator based on any “sufficiently hard” function in 𝐍𝐏𝐜𝐨𝐍𝐏 is a proof complexity generator against Extended Frege [71, Conjecture 2]; that is, computational hardness can be transformed into proof complexity pseudorandomness.

  2. 2.

    Candidate hard tautologies for strong proof systems.

    There are two difficulties in proving lower bounds for strong proof systems such as Frege and Extended Frege: the lack of techniques and the lack of candidate hard tautologies. The latter problem was highlighted by Bonet, Buss, and Pitassi [9], who demonstrated that many combinatorial tautologies can be proved efficiently in Frege, hence disqualifying them as hard candidates. This issue has been further discussed in [50, 53, 74, 42].

    Tautologies from proof complexity generators are among the few natural candidates that appear hard for strong proof systems. It seems plausible that for some mapping G:{0,1}n{0,1}n+1 and some (or even every) y{0,1}n+1Range(G), the natural CNF encoding of the tautology “yRange(G)” requires super-polynomially long Extended Frege proofs.

  3. 3.

    Unprovability of circuit lower bounds.

    Given our very limited progress in circuit complexity, it is tempting to conjecture that circuit lower bounds are hard to prove in formal proof systems. For a Boolean function f:{0,1}n{0,1} and a size parameter s, one can write down a propositional formula 𝗅𝖻(f,s) (of size 2O(n)) asserting that no circuit of size at most s computes f. The proof complexity of such formulas have been studied extensively [69, 70, 53, 71, 66, 67, 74, 68], due to its implications for the metamathematics of complexity theory.

    Consider the truth table generator 𝖳𝖳:{0,1}poly(s){0,1}2n, which maps a size-s circuit C to its 2n-bit truth table. By definition, 𝖳𝖳 is a proof complexity generator against a proof system 𝒫 if and only if 𝒫 cannot efficiently prove any circuit lower bound 𝗅𝖻(f,s). Krajíček [53] introduced the notion of pseudo-surjectivity and showed that 𝖳𝖳 is the hardest pseudo-surjective generator: The existence of any generator pseudo-surjective against 𝒫 implies that 𝖳𝖳 is pseudo-surjective against 𝒫 (and thus that 𝒫 cannot prove circuit lower bounds). Razborov [71] further showed unprovability of circuit lower bounds in the proof system Res(εloglogN) by exhibiting a proof complexity generator that is iterable for this system.555Iterability is a weaker notion than pseudo-surjectivity. Krajíček [53] also showed that 𝖳𝖳 is the “hardest” iterable generator.

Krajíček [53, 56, 51] conjectured that there exists a proof complexity generator that is secure against every propositional proof system. One could also consider a slightly weaker conjecture that for every propositional proof system 𝒫, there is a proof complexity generator C𝒫 (possibly depending on 𝒫) that is hard against 𝒫. At first glance, these conjectures may appear unrelated to standard hardness assumptions in complexity theory or cryptography, as proof complexity generators require “yRange(G)” to be hard to prove for every y (i.e., the best-case y), while complexity-theoretic or cryptographic hardness assumptions tend to be either worst-case or average-case. We elaborate on the notion of “best-case” proof complexity in Subsection 1.4.

In this paper, we give strong evidence for the weaker conjecture by showing that it follows from the existence of demi-bits generators (with sufficiently large stretch) [73]. The latter is a natural and fundamental conjecture in the study of cryptography against nondeterministic adversaries. Furthermore, we show that our generators are even pseudo-surjective under certain regimes.666The parameters of our pseudo-surjectivity results fall just short of those required to apply Krajíček’s result [53], hence they do not imply the hardness of the truth table generator. This limitation is inherent; we discuss this issue in more details after presenting Theorem 7.

1.3 Our Results

Hardness of range avoidance.

Our main result is that the existence of demi-bits generators implies that Avoid𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏, i.e., Avoid is hard for nondeterministic search algorithms.

Theorem 1 (Main).

If there exists a demi-bits generator G:{0,1}n{0,1}10n, then Avoid𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏.

In fact, we show that composing the demi-bits generator with a hash function in some pairwise independent hash family would yield a hard instance for Avoid. In its full generality, our arguments hold for arbitrary strong seeded extractors, and the theorem below follows from the leftover hash lemma [35], which guarantees that pairwise independent hash families are such extractors; see Theorem 27 for details.

We present the version using pairwise independent hash families here due to its elegance:

Theorem 2.

Let G:{0,1}n{0,1}N be a demi-bits generator, ={h:{0,1}N{0,1}m} be a family of pairwise independent hash functions, and 𝒜 be a nondeterministic polynomial-time algorithm. If N>10m and m>n, then there exists h such that 𝒜 fails to solve the range avoidance problem on the input hG.

As discussed before, this result improves upon [33, 17] in several key aspects. First, we only require super-polynomial hardness of the demi-bits generators, thereby completely eliminating the subexponential- or JLS-hardness assumptions. Second, our assumptions are solely based on the existence of demi-bits generators, a primitive arguably situated within “nondeterministic Minicrypt.” Finally, by instantiating the extractors with pairwise independent hash functions computable by linear transformations over 𝔽2 and using demi-bits generators computable by constant-degree 𝔽2-polynomials, we establish the hardness of Avoid even for circuits where each output bit is computable in constant 𝔽2-degree (i.e., 𝖷𝖮𝖱 and O(1) circuits):

Corollary 3 (Informal).

Assuming the existence of demi-bits generators computable in 𝖷𝖮𝖱 and O(1) (Assumption 10), the range avoidance problem for 𝖷𝖮𝖱 and O(1) circuits is not in 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏.

Proof complexity generators.

Building on this result, we show that for any fixed propositional proof system 𝒫 closed under certain reductions, demi-bits generators for 𝒫 imply proof complexity generators for 𝒫. In particular, the existence of demi-bits generators secure against 𝐍𝐏/poly implies the weaker version of Krajíček’s conjecture, providing strong evidence that the latter conjecture is true.

Moreover, this result suggests a new approach for constructing proof complexity generators for concrete proof systems closed under certain reductions, such as 𝖱𝖾𝗌[]: it suffices to construct demi-bits generators secure against the same proof system.

Theorem 4.

Let 𝒫 be a proof system closed under “simple parity reductions” (Definition 29). If there exists a demi-bits generator G:{0,1}n{0,1}10n secure against 𝒫, then there is a (non-uniform) proof complexity generator secure against 𝒫.

Unprovability of 𝐝𝐰𝐏𝐇𝐏(𝗣𝗩) in 𝗣𝗩 from demi-bits.

A central goal in bounded arithmetic is to delineate the logical power required to formalize reasoning about computational complexity. Two well-studied theories in this context are Cook’s theory 𝖯𝖵1 [20], which corresponds to reasoning in deterministic polynomial time, and Jeřábek’s theory 𝖠𝖯𝖢1 [38, 41]777Note that the terminology 𝖠𝖯𝖢1 was first used in [11]., which extends 𝖯𝖵1 by adding the Dual Weak Pigeonhole Principle for polynomial-time functions (dwPHP(𝖯𝖵)), and captures aspects of randomized polynomial-time reasoning.

Despite decades of interest, it has remained open whether 𝖠𝖯𝖢1 and 𝖯𝖵1 are actually distinct theories, i.e., whether dwPHP(𝖯𝖵) is unprovable in 𝖯𝖵1. Recently, Ilango, Li, and Williams [33] provided the first evidence separating the two: they showed that dwPHP(𝖯𝖵) is unprovable in 𝖯𝖵1 under the assumptions that indistinguishability obfuscation (i𝒪) with JLS-security exists and that 𝐜𝐨𝐍𝐏 is not infinitely often in 𝐀𝐌. We remark that the same separation was also shown by Krajíček [55], albeit under an assumption that is regarded as “unlikely” (𝐏 admits fixed-polynomial size circuits). In this work, we establish the same separation assuming the existence of demi-bits generators against 𝐀𝐌/O(1).

Theorem 5.

Assuming there exists a demi-bits generator G:{0,1}n{0,1}ω(n) secure against 𝐀𝐌/O(1), the Dual Weak Pigeonhole Principle for polynomial-time functions (dwPHP(𝖯𝖵)) is not provable in 𝖯𝖵. (In particular, 𝖠𝖯𝖢1 is a strict extension of 𝖯𝖵1.)

The only property of 𝖯𝖵1 used in our argument is the KPT witnessing theorem [59], which states that if 𝖯𝖵1 proves the dual weak pigeonhole principle for polynomial-time functions, then there exists a deterministic polynomial-time Student that wins the Student-Teacher game for solving Avoid in O(1) rounds (see Subsection 2.5). Our separation result in Theorem 5 follows by showing that no such Student algorithm exists. Moreover, for any parameter k=k(n), assuming the existence of demi-bits generators secure against 𝐀𝐌/O(logk), we further rule out deterministic polynomial-time Students that wins the Student-Teacher game within k rounds.

Theorem 6.

Let m=m(n)>n and k=k(n) be parameters. If there exists a demi-bits generator G:{0,1}n{0,1}100km secure against 𝐀𝐌/O(logk), then there is no polynomial-time deterministic algorithm for Avoid on circuits with n inputs and m outputs using k circuit-inversion oracle queries.

Pseudo-surjective generators.

Assuming demi-bits generators against 𝐍𝐏/poly, we show that our proof complexity generators are even pseudo-surjective against every proof system. (The precise definition of k-round pseudo-surjectivity is presented in Definition 21.)

Theorem 7.

Let m=m(n)>n and k=k(n) be parameters. If there exists a demi-bits generator G:{0,1}n{0,1}100km secure against 𝐍𝐏/poly, then for every non-uniform propositional proof system 𝒫, there is a non-uniform proof complexity generator G𝒫,k:{0,1}n{0,1}m that is k-round pseudo-surjective against 𝒫.

Krajíček [53] proved that, under appropriate parameter settings, the existence of pseudo-surjective proof complexity generators is equivalent to the pseudo-surjectivity of the truth table generator. As a corollary, the existence of pseudo-surjective generators against a proof system 𝒫 implies that every circuit lower bound is hard to prove in 𝒫.

However, the parameters in our Theorem 7 fall short of applying Krajíček’s result and therefore do not imply the pseudo-surjectivity of the truth table generator. Specifically, to apply Krajíček’s results, we need a proof complexity generator that is computable by circuits of size s and is k-round pseudo-surjective for some ks; see the proof of [53, Theorem 4.2] for detailed discussions. In contrast, Theorem 7 guarantees a generator computable by circuits of size poly(n,k) that is k-round pseudo-surjective, which is in the regime where k<s and thus outside the reach of Krajíček’s equivalence.

This limitation is inherent to the generality of our result: we construct generators secure against all proof systems, whereas under the assumption 𝐄𝐒𝐈𝐙𝐄[2o(n)], there exists a proof system that can prove circuit lower bounds (e.g., by simply hardwiring an axiom that certain 𝐄-complete language has exponential circuit complexity). Thus, under this standard hardness assumption, it is provably impossible to extend our results to the regime where ks and thereby obtain pseudo-surjectivity of the truth table generator. It remains an intriguing open question whether our approach can be refined to construct proof complexity generators of size s that are k-round pseudo-surjective against specific systems such as Extended Frege, for some ks. Such a result would imply that Extended Frege cannot prove any circuit lower bounds.

Finally, we comment on the strength of the adversaries required in our assumptions on demi-bits generators. In the main theorem (Theorem 1), a 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏 algorithm for Avoid is transformed into a nondeterministic adversary that breaks the demi-bits generator. Since 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏 is a uniform class, it suffices to assume that the generator is secure against uniform nondeterministic adversaries. In contrast, Theorem 6 requires the generator to be secure against 𝐀𝐌/O(logk(n)) adversaries. This is because the adversary invokes the Goldwasser–Sipser protocol [29] which is in 𝐀𝐌, and needs to hardwire the index of the circuit-inversion query that succeeds with good probability. In Theorem 7, we require security against 𝐍𝐏/poly adversaries, as our adversary needs to hardwire a “good” sequence of teacher responses in the student-teacher game, thus is highly non-uniform.

1.4 Perspective: Average-Case to Best-Case Reductions in Proof Complexity

Theoretical computer science has traditionally focused on the worst-case complexity of problems: An algorithm 𝒜 solves a problem if 𝒜(x) succeeds on every input x. Motivated by practical heuristics (where worst-case analysis tends to be overly pessimistic) and cryptography (where worst-case hardness is not sufficient for security), average-case complexity has emerged as an important research direction [34, 7]. In this setting, fixing a distribution 𝒟 over inputs, an algorithm 𝒜 solves a problem if 𝒜(x) succeeds with good probability over x𝒟. Recently, average-case complexity has received attention in proof complexity as well: For example, [64, 24, 19] proved proof complexity lower bounds for Clique and Coloring for random graphs.

An important topic in average-case complexity is worst-case to average-case reductions: reductions showing that if a problem L is hard in the worst-case then a related problem L is hard on average. Worst-case to average-case reductions are known for the Permanent [12], Discrete Logarithm [6], Quadratic Residuosity [28], certain lattice problems [2], and more recently for problems in meta-complexity [31]. On the other hand, “black-box” worst-case to average-case reductions are unlikely to exist for 𝐍𝐏-complete problems [25, 8].

In contrast, the notion of best-case complexity has received far less attention. Perhaps one reason is that this notion is often trivial in standard computational complexity: for every language L, either the all-zero function or the all-one function can decide L on the “best” input.888One notable exception appears in recent derandomization results [15] based on almost-all-input hardness assumptions. In particular, it was shown that pr𝐏=pr𝐁𝐏𝐏 follows from the existence of depth-efficient multi-output functions with high best-case complexity against randomized algorithms. However, in proof complexity, best-case hardness is a meaningful and natural notion, as illustrated by proof complexity generators, which are stretching functions G such that the statement “yRange(G)” is hard to prove even for the best choice of y.

In this context, our results can be interpreted as an average-case to best-case reduction in proof complexity. Indeed, Theorem 4 transforms demi-bits generators, where statements of the form “yRange(G)” is hard to prove for an average-case y, to proof complexity generators, where such statements are hard for a best-case y.

We find the existence of such average-case to best-case reductions quite surprising. Our arguments crucially exploit the power of nondeterministic computation, and the phenomenon of average-case to best-case reductions seems unique to the setting of proof complexity and hardness against nondeterministic algorithms. We believe that further exploring the scope and limitations of average-case to best-case reductions is a promising direction for future research.

We remark that there are also worst-case to best-case reductions in proof complexity. Krajíček [52] constructed a proof complexity generator whose hardness can be based on the hardness of the pigeonhole principle, thereby reducing the best-case hardness of an entire family of tautologies to that of a single tautology. Inspired by this example, Garlik, Gryaznov, Ren, and Tzameret [27] recently showed a worst-case to best-case reduction for the rank principles. Let “rank(A)>r” denote the collection of polynomial equations expressing that the rank of an n×n matrix A is greater than r. If a proof system (closed under certain algebraic reductions) cannot prove “rank(In)>r” where In is the n×n identity matrix, then it also cannot prove “rank(A)>r” for every n×n matrix A.

1.5 Concurrent Works

In an independent and concurrent work, Ilango [32] presented a different proof of Theorem 1 and Theorem 4. Ilango’s proof implies the average-case hardness of Avoid under a natural distribution (namely, it is hard for errorless nondeterministic heuristic algorithms to output a truth table with high O-oracle circuit complexity given the truth table of a random oracle O). Based on this result, Ilango constructed a (non-uniform) non-interactive proof system that “looks” zero knowledge to every proof system. However, Ilango did not show the pseudo-surjectivity of his generators.

2 Preliminaries

2.1 Demi-Bits Generators

Definition 8 (Demi-Bits Generators).

Let n,m be length parameters such that n<m. A function G:{0,1}n{0,1}m is an (s,ε)-secure demi-bits generator if there is no 𝐍𝐏/poly adversary 𝖠𝖽𝗏 of size s such that

Pry{0,1}m[𝖠𝖽𝗏(y)=1]εandPrx{0,1}n[𝖠𝖽𝗏(G(x))=1]=0.

This paper requires demi-bits generators with large stretch and computable with small circuit complexity. In particular, we need the following assumptions:

Assumption 9 (Demi-Bits Generators with Polynomial Stretch).

For every constant c1, there exists a family of demi-bits generators {gn:{0,1}n{0,1}nc} secure against 𝐍𝐏/poly.

Assumption 10 (Demi-Bits Generators with n1+ε Stretch in Constant Degree).

There exist constants ε>0, d2, and a (non-uniformly computable) family of demi-bits generators {gn:{0,1}n{0,1}n1+ε} secure against 𝐍𝐏/poly, such that each output bit of gn is computable by a degree-d polynomial over 𝔽2 (i.e., an 𝖷𝖮𝖱 and d circuit).

Our main hardness results for Avoid will be based on Assumption 9; we also need Assumption 10 to obtain hardness results for constant-degree Avoid. In Appendix B of the full version, we justify these assumptions and provide some candidate constructions.

2.2 Arthur–Merlin Protocols

An Arthur–Merlin protocol [5] for a language L is a constant-round public-coin interactive protocol between a computationally unbounded 𝖯𝗋𝗈𝗏𝖾𝗋 (Merlin) and a randomized polynomial-time 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 (Arthur) that satisfies the following properties for every input x:

  • Completeness: If xL, then there is a 𝖯𝗋𝗈𝗏𝖾𝗋 that makes the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accept w.p. 2/3.

  • Soundness: If xL, then no 𝖯𝗋𝗈𝗏𝖾𝗋 can make the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accept w.p. >1/3.

Let 𝐀𝐌 denote the set of languages with an Arthur–Merlin protocol. The round-collapse theorem of Babai [5] implies that every language in 𝐀𝐌 actually has an Arthur–Merlin protocol with two rounds: 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 sends the first message, 𝖯𝗋𝗈𝗏𝖾𝗋 sends a proof, and 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 decides whether xL. Hence, 𝐀𝐌 can be seen as a randomized version of 𝐍𝐏; indeed, one can prove that 𝐀𝐌=𝐍𝐏 under circuit lower bound assumptions [44, 62, 75, 76].

Goldwasser–Sipser set lower bound protocol.

We need the following well-known 𝐀𝐌 protocol for proving lower bounds on the size of efficiently recognizable sets.

Lemma 11 ([29], also see [4, section 8.4]).

There is an Arthur–Merlin protocol such that the following holds. Suppose that both 𝖯𝗋𝗈𝗏𝖾𝗋 and 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 receive a nondeterministic circuit C:{0,1}n{0,1} and a number s2n. Let S={x{0,1}n:C(x)=1}.

  • Specification: The protocol is a two-round public-coin protocol, in which the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 first sends a random string r and receives a message m, then deterministically decides whether to accept based on r and m.

  • Completeness: If |S|s, then w.p. 2/3 over r, there exists a proof m that makes the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accept.

  • Soundness: If |S|s/2, then w.p. 2/3 over r, the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 rejects regardless of m.

Arthur–Merlin protocols as adversaries.

Definition 12 (Breaking demi-bits generators by 𝐀𝐌 adversaries).

Let m>n. An 𝐀𝐌 adversary breaks a demi-bits generator G:{0,1}n{0,1}m if both 𝖯𝗋𝗈𝗏𝖾𝗋 and 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 receives a common input y{0,1}m, and:

  • for 1/3 fraction of y{0,1}m, there exists a 𝖯𝗋𝗈𝗏𝖾𝗋 that makes the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accept with probability 2/3;

  • for all yRange(G), for every 𝖯𝗋𝗈𝗏𝖾𝗋, the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accepts with probability 1/3.

We also consider 𝐀𝐌 adversaries with advice:

Definition 13 (𝐀𝐌/k(n) adversaries).

An 𝐀𝐌/k(n) adversary is an Arthur–Merlin protocol where the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 is a probabilistic polynomial-time machine that additionally receives a k(n)-bit advice string an (which may depend on the input length n but not on the specific input y). The interaction on input y proceeds as follows:

  1. 1.

    The 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 uses an and randomness r to generate a message to the 𝖯𝗋𝗈𝗏𝖾𝗋;

  2. 2.

    The 𝖯𝗋𝗈𝗏𝖾𝗋 replies with a message;

  3. 3.

    The 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accepts or rejects based on y, an, r, and the 𝖯𝗋𝗈𝗏𝖾𝗋’s response.

The acceptance probabilities are still defined over 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋’s internal randomness, with the advice string fixed to an.

Proposition 14.

Let G be a demi-bits generator.

  • If there exists an 𝐀𝐌 adversary breaking G, then there exists an 𝐍𝐏/poly adversary breaking G ([1]).

  • For every constant k2, if there exists a k-round 𝐀𝐌 adversary breaking G, then there exists a (standard) two-round 𝐀𝐌 adversary breaking G ([5]).

2.3 𝐅𝐍𝐏 v.s. 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏

In this paper, we will distinguish between the two notions 𝐅𝐍𝐏 and 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏.

Definition 15 (𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏 [17]).

Let P be a search problem and R be the binary relation defining P. We say P can be solved by a nondeterministic polynomial-time algorithm if there is a nondeterministic Turing machine M such that for every input x,

  • If x has a solution, then M(x) has an accepting computation path, and every accepting path will output a valid solution y, i.e., R(x,y) is true.

  • If x has no solution, then M(x) has no accepting computation path.

The class of search problems solvable by nondeterministic polynomial-time algorithm is defined as 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏.

Definition 16 (𝐅𝐍𝐏 [17]).

The class of search problems defined by a polynomial-time relation, i.e., R𝐏 is defined as 𝐅𝐍𝐏.

While it is clear that 𝐅𝐍𝐏𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏, the following example suggests that this inclusion is strict.

Proposition 17 ([17]).

If 𝐏𝐍𝐏, then there is a total search problem in 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏𝐅𝐍𝐏.

For more knowledge about nondeterministic algorithms, readers are referred to [17, Section 2.4].

2.4 Proof Complexity

Recall that TAUT, the set of DNF tautologies, is the canonical 𝐜𝐨𝐍𝐏-complete problem. A propositional proof system is simply a nondeterministic algorithm for TAUT. More formally:

Definition 18 ([22]).

An algorithm 𝒫(φ,π) is called a propositional proof system if it satisfies the following conditions:

  • (Completeness) For every φTAUT, there exists a string π{0,1} such that 𝒫(φ,π) accepts.

  • (Soundness) For every φ,π{0,1}, if 𝒫(φ,π) accepts, then φTAUT.

  • (Efficiency) 𝒫(φ,π) runs in deterministic poly(|φ|+|π|) time.

We say that 𝒫 is a non-uniform propositional proof system if 𝒫 is a polynomial-size circuit instead of a uniform algorithm (that is, 𝒫 is equipped with non-uniform advice).

Definition 19 (Proof Complexity Generators [3, 53]).

Let s(n)<n be a function for seed length. A proof complexity generator is a map Cn:{0,1}s{0,1}n computed by a family of polynomial-size circuits {Cn}n. A generator is secure against a propositional proof system P if for every large enough n and every y{0,1}n, P does not have a polynomial-size proof of the (properly encoded) statement

x{0,1}s,Cn(x)y.

It is easy to see that the existence of proof complexity generators is closely related to the hardness of range avoidance. In fact we have:

Theorem 20 (Informal version of [72, Theorem 6.6]).

The range avoidance problem with suitable stretch is in 𝐅𝐍𝐏 if and only if there exists a propositional proof system that breaks every proof complexity generator.

Pseudo-surjectivity.

In addition to the basic notion of hardness for proof complexity generators, several stronger notions have been proposed in the literature, including freeness [50], iterability and pseudo-surjectivity [53], and -hardness [51]. Pseudo-surjectivity is the strongest hardness notion among them. In this paper, we show that our proof complexity generators are pseudo-surjective in certain parameter regimes.

To motivate the definition of pseudo-surjectivity [53, Definition 3.1], it is helpful to consider Student-Teacher games for solving Avoid. Let G:{0,1}n{0,1}m be a mapping where m>n. A polynomial-time Student attempts to find a string y{0,1}mRange(G) with the help of a Teacher who has unbounded computational power. The game proceeds in rounds. In each round i, the Student proposes a candidate string yi{0,1}m, and if yiRange(G), the Teacher returns a preimage qi{0,1}n such that G(qi)=yi. If the Student ever proposes a string outside the range of G, they win the game.

A Student who attempts to solve Avoid in k rounds can be represented as k circuits B1,B2,,Bk, where each Bi uses the Teacher’s responses from previous rounds to generate the next query. Specifically, B1 outputs a fixed string y1{0,1}m, and each subsequent circuit Bi (i>1) takes the previous responses q1,q2,,qi1{0,1}n as inputs and outputs yi{0,1}m. The game proceeds as follows:

  • The Student proposes y1:=B1{0,1}m. If y1Range(G), then the Student wins the game; otherwise, the Teacher returns some q1{0,1}n such that G(q1)=y1.

  • The Student then proposes y2:=B2(q1){0,1}m. If y2Range(G) then the Student wins the game; otherwise, the Teacher returns q2{0,1}n such that G(q2)=y2.

  • This continues until round k, where the Student proposes yk:=Bk(q1,,qk1){0,1}m. If ykRange(G) then the Student wins the game; otherwise the Student loses the game.

To formally express whether the Student succeeds in the game, we define a formula stating that at least one of the Student’s queries is outside the range of G. Let B:{0,1}n{0,1}m be a circuit, z{0,1}n and x{0,1}n be disjoint variables, we define τ(G)B(z)(x) to be the (properly encoded) statement that B(z)G(x). Then, using q1,,qk1{0,1}n to represent the Teacher’s responses, the Student wins if and only if

i=1kτ(G)Bi(q1,,qi1)(qi). (1)

Roughly speaking, a generator G is pseudo-surjective for a proof system 𝒫 if 𝒫 cannot prove any Student wins the game, no matter how the Student is constructed. In other words, a generator G is pseudo-surjective for 𝒫 if, for every sequence of Student circuits (B1,,Bk), the formula (1) is hard to prove in 𝒫.

Note that pseudo-surjectivity is indeed a stronger notion than ordinary hardness for proof complexity generators. Indeed, for every y{0,1}mRange(G), the trivial one-round Student with B1=y clearly wins the game – yet pseudo-surjectivity implies that this fact is hard to prove in 𝒫.

We proceed to the formal definition. We also introduce the notion of k-round pseudo-surjectivity, where the unprovability of (1) only holds for k-round Students for some fixed k=k(n).

Definition 21 (k-round pseudo-surjectivity [53]).

Let 𝒫 be any proof system, G:{0,1}n{0,1}m be a circuit where m>n, and s be a size parameter.

  • We say that G is s-pseudo-surjective for 𝒫 if for every k and every sequence of Student circuits (B1,B2,,Bk), (1) requires 𝒫-proof of size at least s.

  • Fixing a parameter k=k(n), we say that G is k-round s-pseudo-surjective for 𝒫 if for every sequence of Student circuits (B1,B2,,Bk), (1) requires 𝒫-proof of size s.

When s=nω(1), we omit the parameter s and simply say that G is (k-round) pseudo-surjective for 𝒫.

2.5 Bounded Arithmetic

Roughly speaking, 𝖯𝖵1 is a theory of bounded arithmetic capturing “polynomial-time” reasoning. The language of 𝖯𝖵1, (𝖯𝖵), contains a function symbol for every polynomial-time algorithm f:k, defined using Cobham’s characterization of polynomial-time functions [18]. Although Cook’s 𝖯𝖵 [20] was originally defined as an equational theory (i.e., the only relation in 𝖯𝖵 is equality and there are no quantifiers), one can define a first-order theory 𝖯𝖵1 by adding suitable induction schemes [20, 59]. In the literature, the notation 𝖯𝖵 is often used to refer to the set of polynomial-time computable functions as well. The precise definition of 𝖯𝖵1 is somewhat involved, and we refer the reader to the textbooks [48, 21, 58] and references [20, 40, 14, 60].

To capture reasoning in randomized polynomial time, Jeřábek [38, 39, 41] defined a theory 𝖠𝖯𝖢1 by extending 𝖯𝖵1 with the dual weak Pigeonhole Principle for 𝖯𝖵 functions (i.e., polynomial-time functions). Let 𝖤𝗏𝖺𝗅(G,x):=G(x) be the circuit evaluation function. For a function (n)>n, define dwPHP(𝖤𝗏𝖺𝗅) to be the following sentence
dwPHP(𝖤𝗏𝖺𝗅):= n𝖫𝗈𝗀circuit G:{0,1}n{0,1}(n)y{0,1}(n)x{0,1}n[𝖤𝗏𝖺𝗅(G,x)y].

Here, “n𝖫𝗈𝗀” is the standard notation in bounded arithmetic, which means that n is the bit-length of some object; this notation allows us to reason about objects of size poly(n) instead of merely size polylog(n). The above sentence can be interpreted as the totality of Avoid: every input G:{0,1}n{0,1}(n) has at least one solution y.

For this paper, it suffices to think of (n) as a large polynomial in n; in fact, under suitable hardness assumptions, we will be able to show that 𝖯𝖵1 cannot prove dwPHP for every polynomial (n). This suffices to separate 𝖠𝖯𝖢1 from 𝖯𝖵1.

KPT witnessing and Student-Teacher games.

The only property of bounded arithmetic theories that we need in this paper is the KPT witnessing theorem:

Theorem 22 (KPT Witnessing Theorem for 𝖯𝖵1 [59]).

For every quantifier-free formula φ(x,y,z) in the language (𝖯𝖵), if 𝖯𝖵1xyzφ(x,y,z), then there is a k and (𝖯𝖵)-terms t1,t2,,tk such that

𝖯𝖵1xz1z2zki=1kφ(x,ti(x,z1,,zi1),zi). (2)

In particular, Theorem 22 implies that if 𝖯𝖵1dwPHP(𝖤𝗏𝖺𝗅), then there exists a constant k and a polynomial-time Student that wins the Student-Teacher game for the range avoidance problem. (Note that here the Student is computed by a uniform algorithm that gets (1n,G) as inputs, as opposed to a family of non-uniform circuits in Subsection 2.4). To see this, let φ((1n,G),y,x)=1 iff 𝖤𝗏𝖺𝗅(G,x)y and apply Theorem 22. We obtain a constant k and (𝖯𝖵)-terms t1,t2,,tk such that:

𝖯𝖵1n𝖫𝗈𝗀Gz1z2zki=1k𝖤𝗏𝖺𝗅(G,zi)ti(G,z1,,zi1). (3)

This implies that the following Student wins the Student-Teacher game in k rounds:

  1. 1.

    The Student and the Teacher are given a circuit G:{0,1}n{0,1}(n) as input.

  2. 2.

    In the first round, the Student proposes y1:=t1(G) as a candidate non-output. If y1 is correct (i.e., z1φ(G,y1,z1) is true), then the Student wins the game. Otherwise, the Teacher provides a counterexample z1 such that 𝖤𝗏𝖺𝗅(G,z1)=y1, i.e., a preimage z1G1(y1).

  3. 3.

    Then, the Student proposes a new candidate y2:=t2(G,z1) based on the counterexample given in the first round. If y2 is a correct non-output, then the Student wins the game. Otherwise, the Teacher again provides a counterexample z2 such that 𝖤𝗏𝖺𝗅(G,z2)=y2, i.e., a preimage z2G1(y2).

  4. 4.

    The game proceeds until the Student provides a correct witness y.

2.6 Extractors

Definition 23 (k-Source).

A random variable X is a k-source if for every xSupp(X), Pr[X=x]2k.

Definition 24 (Strong Seeded Extractors).

A polynomial-time computable function 𝖤𝗑𝗍:{0,1}n×{0,1}d{0,1}m is a (k,ε)-strong seeded extractor if for every k-source 𝒳 over {0,1}n, the statistical distance of (𝒰d,𝖤𝗑𝗍(X,𝒰d)) and (𝒰d,𝒰m) is at most ε.

Below is the only property of strong seeded extractors that we will use:

Fact 25.

Suppose 𝖤𝗑𝗍:{0,1}n×{0,1}d{0,1}m is a (k,ε)-strong seeded extractor. Then for every (possibly unbounded) adversary 𝒜:{0,1}d+m{0,1}, the number of strings x{0,1}n such that

Prr{0,1}d[𝒜(r,𝖤𝗑𝗍(x,r))=1]<Prr{0,1}d,z{0,1}m[𝒜(r,z)=1]ε (4)

is at most 2k.

Proof Sketch.

Fix an adversary 𝒜, let 𝒳 be the set of strings x{0,1}n such that (4) holds. (We abuse notation and also use 𝒳 to denote the uniform distribution over itself.) Note that 𝒜 distinguishes 𝖤𝗑𝗍(𝒳,r) from the uniform distribution with advantage ε. If |𝒳|2k, then the min-entropy of 𝒳 is at least k, contradicting the extractor properties of 𝖤𝗑𝗍. Hence |𝒳|<2k.

This work requires extractors with exponentially small ε, which can be constructed from any family of pairwise independent hash functions.

Theorem 26 (Leftover Hash Lemma [35]).

Let h:{0,1}n×{0,1}d{0,1}m be a family of pairwise independent hash functions, where the first component (length n) is its input and the second component (length d) is its key. Then for every k,ε such that m=k2log(1/ε), h is a (k,ε)-strong seeded extractor.

In particular, if nm and d2n, there exists a family of pairwise independent hash functions h that is 𝔽2-linear.999That is, for each fixed r{0,1}d, the function h(,r) is an 𝔽2-linear function over its inputs. If we set n3m+3, d2n, k:=n1, ε:=2m1, then h is an (n1,ε)-strong seeded extractor.

3 Hardness of Range Avoidance

Theorem 27.

Assume that for some m>n, there exists a demi-bits generator G:{0,1}n{0,1}N and 𝖤𝗑𝗍:{0,1}N×{0,1}d{0,1}m is an (N1,2m1)-strong seeded extractor. (N,dpoly(m).) Then Avoid for polynomial-size circuits of stretch nm is not in 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏.

Proof.

Let r{0,1}d, define the circuit Cr:{0,1}n{0,1}m with r hardwired:

Cr(s)=𝖤𝗑𝗍(G(s),r).

Assume towards contradiction that there is a nondeterministic polynomial-time algorithm 𝒜 solving Avoid. We construct the following nondeterministic adversary (y) that breaks the demi-bits generator G. Given an input y{0,1}N, the adversary accepts y if and only if there exists r{0,1}d such that some nondeterministic branch of 𝒜(Cr) outputs 𝖤𝗑𝗍(y,r).

It is easy to see that rejects every string yRange(G). To see this, suppose that y=G(s) for some s{0,1}n. Then

Cr(s)=𝖤𝗑𝗍(G(s),r)=𝖤𝗑𝗍(y,r),

hence 𝒜(Cr) will never output 𝖤𝗑𝗍(y,r).

It remains to show that accepts at least 1/2 fraction of strings y{0,1}N. For r{0,1}d,z{0,1}m, let 𝒜(r,z) be the adversary that outputs 1 if there is a nondeterministic branch of 𝒜(Cr) that outputs z, and outputs 0 otherwise. Since 𝖤𝗑𝗍 is a (N1,2m1)-strong seeded extractor, the following is true for at least 1/2 fraction of y{0,1}N:

Prr{0,1}d[𝒜(r,𝖤𝗑𝗍(y,r))=1]Prr{0,1}dz{0,1}m[𝒜(r,z)=1]2m12m1.

For such y, there exists r{0,1}d and a nondeterministic branch of 𝒜(Cr) that outputs 𝖤𝗑𝗍(y,r).

It follows that rejects every string in Range(G) but accepts at least 1/2 fraction of strings y{0,1}N. This contradicts the security of G.

Theorem 2. [Restated, see original statement.]

Let G:{0,1}n{0,1}N be a demi-bits generator, ={h:{0,1}N{0,1}m} be a family of pairwise independent hash functions, and 𝒜 be a nondeterministic polynomial-time algorithm. If N>10m and m>n, then there exists h such that 𝒜 fails to solve the range avoidance problem on the input hG.

Proof.

We construct an extractor 𝖤𝗑𝗍(y,h):=h(y)(y{0,1}N,h). According to Theorem 26, 𝖤𝗑𝗍:{0,1}N×{0,1}m is an (N1,2m1)-strong seeded extractor. Therefore, by Theorem 27, there exists h such that 𝒜 fails to solve Avoid on 𝖤𝗑𝗍(G(),h), i.e., hG.

Corollary 28.

Under Assumption 10, there are constants ε>0 and d2 such that Avoid for 𝖷𝖮𝖱 and d circuits (i.e., degree-d polynomials over 𝔽2) of stretch nn1+ε is not in 𝐒𝐞𝐚𝐫𝐜𝐡𝐍𝐏.

Proof.

Assumption 10 implies a demi-bits generator G:{0,1}n{0,1}n1+δ and each output bit of G can be computed by a degree-d polynomial over 𝔽2, where δ>0 and d2 are constants. Let ε:=δ/2, 𝖤𝗑𝗍:{0,1}n1+δ×{0,1}2n1+δ{0,1}n1+ε be a (n1+δ1,2n1+ε1)-strong linear seeded extractor guaranteed by Theorem 26. Then, for every nondeterministic adversary 𝒜, there exists r{0,1}2n1+δ such that 𝒜 fails to solve Avoid on the instance

Cr(s):=𝖤𝗑𝗍(G(s),r).

Since 𝖤𝗑𝗍 is multi-linear and G is a degree-d polynomial over 𝔽2, Cr is an 𝖷𝖮𝖱 and d circuit.

3.1 From Demi-Bits Generators to Proof Complexity Generators

Let 𝒫 be a proof system and G:{0,1}n{0,1} be a function computable in polynomial size where >n. (We allow G to take non-uniform advice.) Let b{0,1}, denote as τb(G) the propositional formula encoding that b is not in the range of G. We say G is a:

  • demi-bits generator against 𝒫, if for at least a 1/3 fraction of b{0,1}, 𝒫 does not have polynomial-size proof of τb(G); and G is a

  • proof complexity generator against 𝒫, if for every b{0,1}, 𝒫 does not have polynomial-size proof of τb(G).

The precise definition of τb(G) as a 3-CNF is as follows. The variables of τb(G) consist of x{0,1}n and 𝗁𝗂𝗌𝗍{0,1}s, where s is the number of internal gates in G (including the output gates but not including the input gates). The intended meaning is that G(x)=b and 𝗁𝗂𝗌𝗍 represents the values of internal gates of G during the computation of G(x). Each gate in G corresponds to a bit vg; if g is an input (internal) gate then vg refers to some xi (𝗁𝗂𝗌𝗍i). For each internal gate gG labeled by an operation g (such as , , or ) and two children gates gl,gr, we have a constraint

vg=vglgvgr

in τb(G). Similarly, for each i[] representing an output gate gi, we have a constraint

vgi=bi

in τb(G). Note that since every constraint only depends on at most 3 variables, it can be written as a 3-CNF of size at most 23=8, and we can add every clause in this 3-CNF into τb(G). We assume that the gate of fan-in 2 is included in our basis (looking ahead, it will be used to implement the extractor). The 3-CNF τb(G) is simply the union of (3-CNFs generated from) these constraints over every internal and output gate gG.

Now we define the notion of simple parity reductions between two CNFs. This is a technical notion that we need in Claim 30.

Definition 29.

Let F(x) and G(y) be CNF formulas over variables x=(x1,,xn) and y=(y1,,ym). We say that there is a simple parity reduction from F to G, denoted as FG, if:

  • Variables. The reduction is computed by a GF(2)-linear mapping 𝗋𝖾𝖽𝗎:{0,1}n{0,1}m (that is, every output bit of 𝗋𝖾𝖽𝗎 is the 𝖷𝖮𝖱 of a subset of its input bits).

  • Axioms. For any clause gG, one of the following happens:

    • g𝗋𝖾𝖽𝗎𝖳𝗋𝗎𝖾;

    • g𝗋𝖾𝖽𝗎 is equal to some axiom in F; or

    • g is a width-1 clause (i.e., one that consists of a single literal) and g𝗋𝖾𝖽𝗎 is the 𝖷𝖮𝖱 of a subset of axioms in F (in which case these axioms in F are also width-1 clauses).

We say a proof system 𝒫 is closed under simple parity reductions if there is a polynomial p such that the following holds. For every CNF F and G, if there is a simple parity reduction from F to G and there is a length- 𝒫-proof of G, then there is a length-p() 𝒫-proof of F.

We note that this notion is weaker than that of (degree-1) algebraic reductions in [10, 23]. It follows from [23, Lemma 8.3] that many algebraic proof systems (such as Nullstellensatz and Polynomial Calculus) over GF(2) are closed under simple parity reductions when the complexity measure is degree. While we do not know if 𝖱𝖾𝗌[] (resolution over linear equations modulo 2 [36]) is closed under low-degree algebraic reductions, it is straightforward to prove that 𝖱𝖾𝗌[] is closed under simple parity reductions (see Appendix C of the full version).

Recall that G:{0,1}n{0,1}N is a purported demi-bits generator, 𝖤𝗑𝗍:{0,1}N×{0,1}d{0,1}m is an extractor, and for a fixed r{0,1}d we define the circuit Cr:{0,1}n{0,1}m as

Cr(s):=𝖤𝗑𝗍(G(s),r).

We say that 𝖤𝗑𝗍 is linear if for every fixed randomness r, the function 𝖤𝗑𝗍(,r):GF(2)NGF(2)m is GF(2)-linear. For every r we fix a circuit 𝖤𝗑𝗍r for computing 𝖤𝗑𝗍(,r) using gates of fan-in 2 only.

Claim 30.

Suppose that 𝖤𝗑𝗍 is a linear extractor. For every y{0,1}N and r{0,1}d, there is a simple parity reduction from τy(G) to τz(Cr), where z:=𝖤𝗑𝗍(y,r).

First, as a sanity check, we show that τy(G) follows from τz(Cr) logically: Suppose that τy(G) is false and that y=G(s) for some s{0,1}n, then

Cr(s)=𝖤𝗑𝗍(G(s),r)=𝖤𝗑𝗍(y,r)=z,

meaning that τz(Cr) is also false. Now we show that if 𝖤𝗑𝗍 is a linear extractor, then the above deduction is actually a simple parity reduction under our formalization of τb(G):

Proof of Claim 30.

Recall that the variables of τy(G) consist of s{0,1}n and 𝗁𝗂𝗌𝗍G{0,1}|G|, where |G| denotes the number of internal gates in G. Also, recall the variables of τz(Cr) consist of s{0,1}n and 𝗁𝗂𝗌𝗍Cr{0,1}|Cr|. Since Cr(s)=𝖤𝗑𝗍(G(s),r), 𝗁𝗂𝗌𝗍Cr consists of 𝗁𝗂𝗌𝗍G as well as the internal gates of 𝖤𝗑𝗍(,r). Since 𝖤𝗑𝗍 is linear, each internal gate in 𝖤𝗑𝗍(,r) is an XOR of variables in 𝗁𝗂𝗌𝗍G. Therefore, one can compute a GF(2)-linear map 𝗋𝖾𝖽𝗎:{0,1}n+|G|{0,1}n+|Cr| that maps (s,𝗁𝗂𝗌𝗍G) to (s,𝗁𝗂𝗌𝗍Cr).

Now we show that for every clause cτz(Cr), one of the three cases in Definition 29 happens. Note that c comes from an internal gate or an output gate of Cr.

  • If c comes from an internal gate of G, then c𝗋𝖾𝖽𝗎 (which is equal to c itself) is an axiom in τy(G).

  • If c comes from an internal gate in 𝖤𝗑𝗍(,r), then c𝗋𝖾𝖽𝗎𝖳𝗋𝗎𝖾 by the definition of 𝗋𝖾𝖽𝗎.

  • The only remaining case is that c comes from an output gate. Suppose this is the i-th output gate of Cr (where i[m]), and let vi denote the variable (of τz(Cr)) representing the i-th output of Cr. Note that c is a width-1 axiom stating that vi=zi.

    Let Si[N] be such that 𝖤𝗑𝗍(y,r)i=jSiyj. Then 𝗋𝖾𝖽𝗎 maps vi to jSivjG, where vjG is the variable in τy(G) that represents the j-th output gate of G. We also have that zi=jSiyj. Hence c𝗋𝖾𝖽𝗎 is the 𝖷𝖮𝖱 of the axioms vjG=yj over all jSi. Since each vjG=yj is an axiom in τy(G), this concludes the proof.

Theorem 31.

Let 𝒫 be a proof system closed under parity reductions. Let G:{0,1}n{0,1}N be a demi-bits generator secure against 𝒫, and 𝖤𝗑𝗍:{0,1}N×{0,1}d{0,1}m be an (N2,2m1)-strong linear seeded extractor. Then there is a non-uniform proof complexity generator secure against 𝒫.

Proof.

Suppose for contradiction that for every r{0,1}d, there exists a string z(r){0,1}m such that 𝒫 admits a length- proof of τz(r)(Cr), where poly(|G|). For r{0,1}d and z{0,1}m, let 𝒜(r,z) be the adversary that outputs 1 if 𝒫 admits a length- proof of τz(Cr) and outputs 0 otherwise. Since for every r, 𝒜(r,z(r))=1, we have

Prr{0,1}dz{0,1}m[𝒜(r,z)=1]2m.

Since 𝖤𝗑𝗍 is a (n2,2m1)-strong extractor, for at least a 3/4 fraction of y{0,1}N, we have

Prr{0,1}d[𝒜(r,𝖤𝗑𝗍(y,r))=1]Prr{0,1}dz{0,1}m[𝒜(r,z)=1]2m1>0.

Hence, for such y{0,1}N, there exists some r:=r(y) such that 𝒫 admits a length- proof of τz(Cr) where z:=𝖤𝗑𝗍(y,r). Since there is a parity reduction from τy(G) to τz(Cr) and 𝒫 is closed under parity reductions, it follows that 𝒫 admits a length-poly() proof of τy(G) as well, contradicting the security of G as a demi-bits generator against 𝒫.

Although super-polynomial lower bounds for 𝖱𝖾𝗌[] remain open, it seems conceivable that we will eventually prove such lower bounds sooner or later. Our results suggest a potential approach for designing proof complexity generators against 𝖱𝖾𝗌[]: it suffices to design a demi-bits generator against 𝖱𝖾𝗌[] (which might be an easier task) and then apply Theorem 31.

4 Lower Bounds for Student-Teacher Games

In this section, we show that Avoid is hard for Student-Teacher games. In Subsection 4.1 we prove lower bounds against uniform, polynomial-time Students, which implies a conditional separation between bounded arithmetic theories 𝖯𝖵1 and 𝖠𝖯𝖢1. In Subsection 4.2, we show that demi-bits generators can be transformed into proof complexity generators that are pseudo-surjective.

4.1 Separating 𝗣𝗩𝟏 from 𝗔𝗣𝗖𝟏

As discussed in Subsection 2.5, to separate 𝖯𝖵1 from 𝖠𝖯𝖢1, it suffices to show that there is no polynomial-time Student that wins the Student-Teacher game for Avoid in O(1) rounds. In fact, we will show something stronger: Let k=k(n) be a parameter, assuming the existence of demi-bits generators secure against 𝐀𝐌/O(logk), there is no polynomial-time Student that wins the Student-Teacher game for Avoid in k(n) rounds.

Theorem 32.

Let m,n,k be parameters such that m>n. Assume there exists a demi-bits generator G:{0,1}n{0,1}N secure against 𝐀𝐌/O(logk). Let 𝖤𝗑𝗍:{0,1}N×{0,1}d{0,1}m be an (N1,210km)-strong extractor. Then for every deterministic polynomial-time Student A, there is a string r{0,1}d and a Teacher such that A fails to solve Avoid on Cr in k rounds, where Cr:{0,1}n{0,1}m is the circuit

Cr(s):=𝖤𝗑𝗍(G(s),r).

Proof.

Let A denote the Student algorithm where A(i,C,z1,,zi1) outputs the i-th candidate solution. For strings s1,,sj{0,1}n (where jk), we say that (s1,,sj) is a valid trace for A on the input Cr if all of the following are true:

  • Cr(s1)=A(1,Cr) (that is, s1 is a valid counterexample for A(1,));

  • Cr(s2)=A(2,Cr,s1) (that is, s2 is a valid counterexample for A(2,));

  • and Cr(sj)=A(j,Cr,s1,s2,,sj1) (that is, sj is a valid counterexample for A(j,)).

We prove the following stronger claim that implies Theorem 32:

Claim 33.

For every jk, there exist s1,s2,,sj{0,1}n such that

Prr{0,1}d[(s1,,sj) is a valid trace for A on the input Cr]22jm.

Clearly, Claim 33 implies Theorem 32 by setting j:=k and noticing that 22jm>0.

We prove Claim 33 by induction on j. The base case j=0 is trivially true. Now we assume the claim is true for j1, which gives strings s1,,sj1 such that

Prr{0,1}d[(s1,,sj1) is a valid trace for A on the input Cr]22(j1)m.

Consider the following 𝐀𝐌/O(logk) protocol that attempts to break the demi-bits generator G. This protocol has the index j hardwired as advice but is otherwise uniform.

Algorithm 4.1 The 𝐀𝐌/O(logk) protocol 𝒫 breaking demi-bits generator G.

Completeness of 𝓟.

We show that for at least a 1/2 fraction of y, there is a 𝖯𝗋𝗈𝗏𝖾𝗋 such that the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accepts w.p. 2/3 in 𝒫. In the first round, the honest 𝖯𝗋𝗈𝗏𝖾𝗋 sends (s1,,sj1) as guaranteed by the induction hypothesis. Recall that this means

Prr{0,1}d[(s1,,sj1) is a valid trace for A on the input Cr]22(j1)m.

Let 𝖳𝖾𝗌𝗍(r,z)=1 if (s1,,sj1) is a valid trace for A on the input Cr and z=A(j,Cr,s1,,sj1), and 𝖳𝖾𝗌𝗍(r,z)=0 otherwise. Clearly, we have

Prr{0,1}d,z{0,1}m[𝖳𝖾𝗌𝗍(r,z)=1]22(j1)m/2m=2(2j1)m.

Since 𝖤𝗑𝗍 is an (N1,210km)-strong extractor, for 1/2 fraction of y’s, it holds that

Prr{0,1}d[𝖳𝖾𝗌𝗍(r,𝖤𝗑𝗍(y,r))=1]Prr{0,1}d,z{0,1}m[𝖳𝖾𝗌𝗍(r,z)=1]210km2(2j1)m1.

It follows that there is a 𝖯𝗋𝗈𝗏𝖾𝗋 for the Goldwasser–Sipser protocol in Line 2 of Algorithm 4.1 such that the verifier accepts with probability at least 2/3.

Employing the lack of soundness.

Since G is a demi-bits generator secure against 𝐀𝐌/O(logk) adversaries, 𝒫 does not have the soundness for all sufficiently large n. In other words, there is a 𝖯𝗋𝗈𝗏𝖾𝗋 that makes the 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accepts some yRange(G) with probability >1/3. Fix such a string y, let sj be any n-bit string such that G(sj)=y, and let s1,,sj1{0,1}n be the message sent in Line 1 (of Algorithm 4.1) by 𝖯𝗋𝗈𝗏𝖾𝗋 on the input y.

Since 𝖵𝖾𝗋𝗂𝖿𝗂𝖾𝗋 accepts with probability >1/3, by the soundness of the Goldwasser–Sipser Protocol (Lemma 11), we have that

Prr{0,1}d[(s1,,sj1) is a valid trace for A on the input Crand 𝖤𝗑𝗍(y,r)=A(j,Cr,s1,,sj1).]2j(2m+1)2.

Recall that 𝖤𝗑𝗍(y,r)=Cr(sj), hence the above condition inside Prr{0,1}d[] means exactly that (s1,,sj) is a valid trace for A(Cr). This implies Claim 33 for j.

We remark that the parameters we obtained in Theorem 32 are (almost) tight in the following sense. Theorem 32 showed that (under plausible assumptions) for every parameter kpoly(n), there is no deterministic polynomial-time Student that wins the Student-Teacher game for Avoid in k rounds, when given an Avoid instance of size s=poly(k,n)>k. On the other hand, under plausible derandomization assumptions, for every size parameter s, there exists a deterministic polynomial-time Student that wins the game on size-s circuits within k=poly(s,n)>s rounds [33, Appendix A].

Finally, setting k=O(1) in Theorem 32, we obtain the following separation:

Theorem 5. [Restated, see original statement.]

Assuming there exists a demi-bits generator G:{0,1}n{0,1}ω(n) secure against 𝐀𝐌/O(1), the Dual Weak Pigeonhole Principle for polynomial-time functions (dwPHP(𝖯𝖵)) is not provable in 𝖯𝖵. (In particular, 𝖠𝖯𝖢1 is a strict extension of 𝖯𝖵1.)

4.2 From Demi-Bits to Pseudo-Surjectivity

Theorem 34.

Let G:{0,1}n{0,1}N be a demi-bits generator secure against 𝐍𝐏/poly, k, and 𝖤𝗑𝗍:{0,1}N×{0,1}d{0,1}m be an (N1,ε)-strong linear extractor for ε:=210km. (k,d,Npoly(m).) Then for every non-uniform propositional proof system 𝒫, there is a string r{0,1}d such that the circuit Cr:{0,1}n{0,1}m defined as

Cr(s):=𝖤𝗑𝗍(G(s),r)

is a non-uniform k-round pseudo-surjective proof complexity generator secure against 𝒫.

Proof.

Suppose, for contradiction, that such an r{0,1}d does not exist. Then, for any r{0,1}d, there exist Student circuits

B(r)={Bi(r):{0,1}n(i1){0,1}m}i[k+1]

such that 𝒫 admits a proof of

i=1kτ(Cr)Bi(q1,q2,,qi1)(qi).

(i.e., 𝒫 can prove that B(r) wins the Student-Teacher game on Cr.)

Now we attempt to break the demi-bits generator G. For j=0,1,,k, define
Φj:=max(s1,s2,,sj){0,1}njPrr{0,1}m[ Student B such that:(1) 𝒫 can prove that B wins the Student-Teacher game on Cr;(2) Bi(s1,,si1)=Cr(si) for all i[j].].

(Item (2) says that the history of the Student-Teacher game in the first i rounds is exactly s1,,sj.) We make the following claims on the values of Φ0 and Φk:

  • Φ0=1: When j=0, item (2) obviously holds, and item (1) holds by our assumption that Cr is not a pseudo-surjective proof complexity generator;

  • Φk=0: When j=k, for any r,B items (1) and (2) cannot hold simultaneously. This is because (2) implies that B loses the Student-Teacher game, which contradicts (1).

Simple calculations show that there exists j{0,1,,k1} such that

Φj2mε>2Φj+1.

We use such j to break the demi-bits generator G. Let (s1,,sj) be the tuple such that the maximum is achieved in the definition of Φj, i.e.,

Φj=Prr{0,1}m[ Student B such that:(1) 𝒫 can prove that B wins the Student-Teacher game on Cr;(2) Bi(s1,,si1)=Cr(si) for all i[j].].

Consider the following algorithm: on an input y{0,1}n, let

p(y):=Prr{0,1}m[ Student B such that:(1) 𝒫 can prove that B wins the Student-Teacher game on Cr;(2) Bi(s1,,si1)=Cr(si)=𝖤𝗑𝗍(G(si),r) for all i[j], and Bj+1(s1,,sj)=𝖤𝗑𝗍(y,r).].

Our algorithm accepts y if p(y)Φj2mε, and rejects if p(y)Φj+1. This can be implemented by the Goldwasser–Sipser set lower bound protocol since Φj2mε>2Φj+1, and the condition inside Prr{0,1}m[] is certifiable in polynomial time with the help of a prover. Finally, we prove that this algorithm breaks demi-bits generator G:

  • For any yRange(G), we have p(y)Φj+1:
    Suppose y=G(s). Then
    p(y) =Prr{0,1}m[ student B such that:(1) 𝒫 can prove that B wins the Student-Teacher game on 𝖤𝗑𝗍(G(),r);(2) Bi(s1,,si1)=𝖤𝗑𝗍(G(si),r) for all i[j], and Bj+1(s1,,sj)=𝖤𝗑𝗍(G(s),r).] Φj+1.

    Where the in the second line follows from the definition of Φj+1.

  • For half of y{0,1}n, we have p(y)Φj2mε:

    For simplicity, we use “𝖳𝖾𝗌𝗍(r,𝖤𝗑𝗍(y,r))” to denote the condition inside Prr{0,1}m[] in the definition of p(y). We have:

    Prr{0,1}mz{0,1}m[𝖳𝖾𝗌𝗍(r,z)]=Φj2m.

    By the definition of strong extractors, for half of y{0,1}n, we have

    Prr{0,1}m[𝖳𝖾𝗌𝗍(r,𝖤𝗑𝗍(y,r))]Prr{0,1}mz{0,1}m[𝖳𝖾𝗌𝗍(r,z)]ε=Φj2mε.

Corollary 35.

Suppose for any parameter Npoly(n), there exists a demi-bits generator G:{0,1}n{0,1}N secure against 𝐍𝐏/poly. Then for every non-uniform propositional proof system 𝒫 and any parameters kpoly(n) and n<m<poly(n), there is a circuit C:{0,1}n{0,1}m of size poly(n) such that C is a k-round pseudo-surjective proof complexity generator secure against 𝒫.

Proof.

In Theorem 34, let N:=100km and 𝖤𝗑𝗍:{0,1}N×{0,1}O(km){0,1}m be an (N1,210km)-strong seeded extractor guaranteed by Theorem 26. Then there exists r{0,1}O(km) such that Cr:=𝖤𝗑𝗍(G(),r) is a k-round pseudo-surjective proof complexity generator secure against 𝒫.

References

  • [1] Leonard M. Adleman. Two theorems on random polynomial time. In FOCS, pages 75–83. IEEE Computer Society, 1978. doi:10.1109/SFCS.1978.37.
  • [2] Miklós Ajtai. Generating hard instances of lattice problems (extended abstract). In STOC, pages 99–108. ACM, 1996. doi:10.1145/237814.237838.
  • [3] Michael Alekhnovich, Eli Ben-Sasson, Alexander A. Razborov, and Avi Wigderson. Pseudorandom generators in propositional proof complexity. SIAM Journal on Computing, 34(1):67–88, 2004. doi:10.1137/S0097539701389944.
  • [4] Sanjeev Arora and Boaz Barak. Computational Complexity: A Modern Approach. Cambridge University Press, USA, 1st edition, 2009. doi:10.1017/CBO9780511804090.
  • [5] László Babai. Trading group theory for randomness. In STOC, pages 421–429. ACM, 1985. doi:10.1145/22145.22192.
  • [6] Manuel Blum and Silvio Micali. How to generate cryptographically strong sequences of pseudo-random bits. SIAM J. Comput., 13(4):850–864, 1984. doi:10.1137/0213053.
  • [7] Andrej Bogdanov and Luca Trevisan. Average-case complexity. Found. Trends Theor. Comput. Sci., 2(1), 2006. doi:10.1561/0400000004.
  • [8] Andrej Bogdanov and Luca Trevisan. On worst-case to average-case reductions for 𝐍𝐏 problems. SIAM J. Comput., 36(4):1119–1159, 2006. doi:10.1137/S0097539705446974.
  • [9] Maria Luisa Bonet, Samuel R. Buss, and Toniann Pitassi. Are there hard examples for Frege systems? In Feasible Mathematics II, pages 30–56, Boston, MA, 1995. Birkhäuser Boston. doi:10.1007/978-1-4612-2566-9_3.
  • [10] Samuel R. Buss, Dima Grigoriev, Russell Impagliazzo, and Toniann Pitassi. Linear gaps between degrees for the polynomial calculus modulo distinct primes. J. Comput. Syst. Sci., 62(2):267–289, 2001. doi:10.1006/JCSS.2000.1726.
  • [11] Samuel R. Buss, Leszek Aleksander Kolodziejczyk, and Neil Thapen. Fragments of approximate counting. J. Symb. Log., 79(2):496–525, 2014. doi:10.1017/JSL.2013.37.
  • [12] Jin-yi Cai, Aduri Pavan, and D. Sivakumar. On the hardness of permanent. In STACS, volume 1563 of Lecture Notes in Computer Science, pages 90–99. Springer, 1999. doi:10.1007/3-540-49116-3_8.
  • [13] 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.
  • [14] Lijie Chen, Jiatu Li, and Igor C. Oliveira. Reverse mathematics of complexity lower bounds. In FOCS, pages 505–527. IEEE, 2024. doi:10.1109/FOCS61266.2024.00040.
  • [15] Lijie Chen and Roei Tell. Hardness vs randomness, revised: Uniform, non-black-box, and instance-wise. In FOCS, pages 125–136. IEEE, 2021. doi:10.1109/FOCS52979.2021.00021.
  • [16] Yeyuan Chen, Yizhi Huang, Jiatu Li, and Hanlin Ren. Range avoidance, remote point, and hard partial truth table via satisfying-pairs algorithms. In STOC, pages 1058–1066. ACM, 2023. doi:10.1145/3564246.3585147.
  • [17] Yilei Chen and Jiatu Li. Hardness of range avoidance and remote point for restricted circuits via cryptography. In STOC, pages 620–629. ACM, 2024. doi:10.1145/3618260.3649602.
  • [18] Alan Cobham. The intrinsic computational difficulty of functions. In Proc. Logic, Methodology, and the Philosophy of Science, pages 24–30, 1964.
  • [19] Jonas Conneryd, Susanna F. de Rezende, Jakob Nordström, Shuo Pang, and Kilian Risse. Graph colouring is hard on average for Polynomial Calculus and Nullstellensatz. In FOCS, pages 1–11. IEEE Computer Society, 2023. doi:10.1109/FOCS57990.2023.00007.
  • [20] Stephen A. Cook. Feasibly constructive proofs and the propositional calculus (preliminary version). In STOC, pages 83–97. ACM, 1975. doi:10.1145/800116.803756.
  • [21] Stephen A. Cook and Phuong Nguyen. Logical Foundations of Proof Complexity, volume 11. Cambridge University Press, 2010. doi:10.1017/CBO9780511676277.
  • [22] Stephen A. Cook and Robert A. Reckhow. The relative efficiency of propositional proof systems. J. Symb. Log., 44(1):36–50, 1979. doi:10.2307/2273702.
  • [23] Susanna F. de Rezende, Mika Göös, Jakob Nordström, Toniann Pitassi, Robert Robere, and Dmitry Sokolov. Automating algebraic proof systems is 𝐍𝐏-hard. In STOC, pages 209–222. ACM, 2021. doi:10.1145/3406325.3451080.
  • [24] Susanna F. de Rezende, Aaron Potechin, and Kilian Risse. Clique is hard on average for unary Sherali-Adams. In FOCS, pages 12–25. IEEE, November 2023. doi:10.1109/FOCS57990.2023.00008.
  • [25] Joan Feigenbaum and Lance Fortnow. Random-self-reducibility of complete sets. SIAM J. Comput., 22(5):994–1005, 1993. doi:10.1137/0222061.
  • [26] Karthik Gajulapalli, Alexander Golovnev, Satyajeet Nagargoje, and Sidhant Saraogi. Range avoidance for constant depth circuits: Hardness and algorithms. In APPROX/RANDOM, volume 275 of LIPIcs, pages 65:1–65:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.APPROX/RANDOM.2023.65.
  • [27] Michal Garlik, Svyatoslav Gryaznov, Hanlin Ren, and Iddo Tzameret. The weak rank principle: Lower bounds and applications, 2025. Manuscript.
  • [28] Shafi Goldwasser and Silvio Micali. Probabilistic encryption. J. Comput. Syst. Sci., 28(2):270–299, 1984. doi:10.1016/0022-0000(84)90070-9.
  • [29] Shafi Goldwasser and Michael Sipser. Private coins versus public coins in interactive proof systems. In STOC, pages 59–68. ACM, 1986. doi:10.1145/12130.12137.
  • [30] Venkatesan Guruswami, Xin Lyu, and Xiuhan Wang. Range avoidance for low-depth circuits and connections to pseudorandomness. In APPROX/RANDOM, volume 245 of LIPIcs, pages 20:1–20:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.APPROX/RANDOM.2022.20.
  • [31] Shuichi Hirahara. Non-black-box worst-case to average-case reductions within 𝐍𝐏. In FOCS, pages 247–258. IEEE Computer Society, 2018. doi:10.1109/FOCS.2018.00032.
  • [32] Rahul Ilango. The oracle derandomization hypothesis is false (and more) assuming no natural proofs, 2025. Manuscript.
  • [33] Rahul Ilango, Jiatu Li, and R. Ryan Williams. Indistinguishability obfuscation, range avoidance, and bounded arithmetic. In STOC, pages 1076–1089. ACM, 2023. doi:10.1145/3564246.3585187.
  • [34] Russell Impagliazzo. A personal view of average-case complexity. In SCT, pages 134–147. IEEE Computer Society, 1995. doi:10.1109/SCT.1995.514853.
  • [35] Russell Impagliazzo, Leonid A. Levin, and Michael Luby. Pseudo-random generation from one-way functions. In STOC, pages 12–24. ACM, 1989. doi:10.1145/73007.73009.
  • [36] Dmitry Itsykson and Dmitry Sokolov. Resolution over linear equations modulo two. Ann. Pure Appl. Log., 171(1), 2020. doi:10.1016/J.APAL.2019.102722.
  • [37] Aayush Jain, Huijia Lin, and Amit Sahai. Indistinguishability obfuscation from well-founded assumptions. In STOC, pages 60–73. ACM, 2021. doi:10.1145/3406325.3451093.
  • [38] Emil Jeřábek. Dual weak pigeonhole principle, Boolean complexity, and derandomization. Ann. Pure Appl. Log., 129(1-3):1–37, 2004. doi:10.1016/J.APAL.2003.12.003.
  • [39] Emil Jeřábek. Weak pigeonhole principle and randomized computation. PhD thesis, Charles University in Prague, 2005.
  • [40] Emil Jeřábek. The strength of sharply bounded induction. Math. Log. Q., 52(6):613–624, 2006. doi:10.1002/MALQ.200610019.
  • [41] Emil Jeřábek. Approximate counting in bounded arithmetic. J. Symb. Log., 72(3):959–993, 2007. doi:10.2178/JSL/1191333850.
  • [42] Erfan Khaniki. Nisan–Wigderson generators in proof complexity: New lower bounds. In CCC, volume 234 of LIPIcs, pages 17:1–17:15. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.CCC.2022.17.
  • [43] Robert Kleinberg, Oliver Korten, Daniel Mitropolsky, and Christos Papadimitriou. Total Functions in the Polynomial Hierarchy. In ITCS, volume 185 of Leibniz International Proceedings in Informatics (LIPIcs), pages 44:1–44:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.ITCS.2021.44.
  • [44] Adam R. Klivans and Dieter van Melkebeek. Graph nonisomorphism has subexponential size proofs unless the polynomial-time hierarchy collapses. SIAM J. Comput., 31(5):1501–1526, 2002. doi:10.1137/S0097539700389652.
  • [45] Oliver Korten. The hardest explicit construction. In 2021 IEEE 62nd Annual Symposium on Foundations of Computer Science (FOCS), pages 433–444. IEEE, 2021. doi:10.1109/FOCS52979.2021.00051.
  • [46] Oliver Korten. Range avoidance and the complexity of explicit constructions. Bull. EATCS, 145, 2025. URL: http://bulletin.eatcs.org/index.php/beatcs/article/view/825.
  • [47] Oliver Korten and Toniann Pitassi. Strong vs. weak range avoidance and the linear ordering principle. In FOCS, pages 1388–1407. IEEE, 2024. doi:10.1109/FOCS61266.2024.00089.
  • [48] Jan Krajíček. Bounded Arithmetic, Propositional Logic, and Complexity Theory. Encyclopedia of Mathematics and its Applications. Cambridge University Press, 1995. doi:10.1017/CBO9780511529948.
  • [49] Jan Krajíček. On the weak pigeonhole principle. Fundamenta Mathematicae, 170:123–140, 2001. doi:10.4064/fm170-1-8.
  • [50] Jan Krajíček. Tautologies from pseudo-random generators. Bulletin of Symbolic Logic, 7(2):197–212, 2001. doi:10.2307/2687774.
  • [51] Jan Krajíček. On the existence of strong proof complexity generators. Bulletin of Symbolic Logic, 30(1):20–40, 2024. doi:10.1017/bsl.2023.40.
  • [52] Jan Krajíček. A proof complexity generator. In Proc. from the 13th International Congress of Logic, Methodology and Philosophy of Science (Beijing, August 2007), Studies in Logic and the Foundations of Mathematics. King’s College Publications, London, 2009.
  • [53] Jan Krajíček. Dual weak pigeonhole principle, pseudo-surjective functions, and provability of circuit lower bounds. Journal of Symbolic Logic, 69(1):265–286, 2004. doi:10.2178/jsl/1080938841.
  • [54] Jan Krajíček. On the proof complexity of the Nisan–Wigderson generator based on a hard 𝐍𝐏𝐜𝐨𝐍𝐏 function. J. Math. Log., 11(1), 2011. doi:10.1142/S0219061311000979.
  • [55] Jan Krajíček. Small circuits and dual weak PHP in the universal theory of p-time algorithms. ACM Trans. Comput. Log., 22(2):11:1–11:4, 2021. doi:10.1145/3446207.
  • [56] Jan Krajíček. A proof complexity conjecture and the Incompleteness theorem. The Journal of Symbolic Logic, pages 1–5, 2023. doi:10.1017/jsl.2023.69.
  • [57] Jan Krajíček. Proof complexity generators. Cambridge University Press, 2025. doi:10.1017/9781009611664.
  • [58] Jan Krajíček. Proof Complexity. Encyclopedia of Mathematics and its Applications. Cambridge University Press, 2019. doi:10.1017/9781108242066.
  • [59] Jan Krajíček, Pavel Pudlák, and Gaisi Takeuti. Bounded arithmetic and the polynomial hierarchy. Annals of Pure and Applied Logic, 52(1):143–153, 1991. doi:10.1016/0168-0072(91)90043-L.
  • [60] Jiatu Li. An introduction to feasible mathematics and bounded arithmetic for computer scientists. Electron. Colloquium Comput. Complex., TR25-086, 2025. URL: https://eccc.weizmann.ac.il/report/2025/086.
  • [61] Zeyong Li. Symmetric exponential time requires near-maximum circuit size: Simplified, truly uniform. In STOC, STOC 2024, pages 2000–2007. ACM, 2024. doi:10.1145/3618260.3649615.
  • [62] Peter Bro Miltersen and N. V. Vinodchandran. Derandomizing Arthur-Merlin games using hitting sets. Comput. Complex., 14(3):256–279, 2005. doi:10.1007/S00037-005-0197-7.
  • [63] Noam Nisan and Avi Wigderson. Hardness vs randomness. J. Comput. Syst. Sci., 49(2):149–167, 1994. doi:10.1016/S0022-0000(05)80043-1.
  • [64] Shuo Pang. Large clique is hard on average for resolution. In CSR, volume 12730 of Lecture Notes in Computer Science, pages 361–380. Springer, 2021. doi:10.1007/978-3-030-79416-3_22.
  • [65] Ján Pich. Nisan-Wigderson generators in proof systems with forms of interpolation. Math. Log. Q., 57(4):379–383, 2011. doi:10.1002/MALQ.201010012.
  • [66] Ján Pich. Circuit lower bounds in bounded arithmetics. Ann. Pure Appl. Log., 166(1):29–45, 2015. doi:10.1016/J.APAL.2014.08.004.
  • [67] Ján Pich and Rahul Santhanam. Why are proof complexity lower bounds hard? In FOCS, pages 1305–1324. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.00080.
  • [68] Ján Pich and Rahul Santhanam. Learning algorithms versus automatability of Frege systems. In ICALP, volume 229 of LIPIcs, pages 101:1–101:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ICALP.2022.101.
  • [69] Alexander A. Razborov. Lower bounds for the polynomial calculus. Comput. Complex., 7(4):291–324, 1998. doi:10.1007/s000370050013.
  • [70] Alexander A. Razborov. Resolution lower bounds for perfect matching principles. J. Comput. Syst. Sci., 69(1):3–27, 2004. doi:10.1016/J.JCSS.2004.01.004.
  • [71] Alexander A. Razborov. Pseudorandom generators hard for k-DNF resolution and polynomial calculus resolution. Annals of Mathematics, pages 415–472, 2015. doi:10.4007/annals.2015.181.2.1.
  • [72] Hanlin Ren, Rahul Santhanam, and Zhikun Wang. On the range avoidance problem for circuits. In FOCS, pages 640–650, 2022. doi:10.1109/FOCS54457.2022.00067.
  • [73] Steven Rudich. Super-bits, demi-bits, and 𝐍𝐏/qpoly-natural proofs. In RANDOM, volume 1269 of Lecture Notes in Computer Science, pages 85–93. Springer, 1997. doi:10.1007/3-540-63248-4_8.
  • [74] Rahul Santhanam and Iddo Tzameret. Iterated lower bound formulas: a diagonalization-based approach to proof complexity. In STOC, pages 234–247. ACM, 2021. doi:10.1145/3406325.3451010.
  • [75] Ronen Shaltiel and Christopher Umans. Simple extractors for all min-entropies and a new pseudorandom generator. J. ACM, 52(2):172–216, 2005. doi:10.1145/1059513.1059516.
  • [76] Ronen Shaltiel and Christopher Umans. Pseudorandomness for approximate counting and sampling. Comput. Complex., 15(4):298–341, 2006. doi:10.1007/S00037-007-0218-9.
  • [77] Iddo Tzameret and Lu-Ming Zhang. Stretching Demi-Bits and Nondeterministic-Secure Pseudorandomness. In ITCS, volume 287 of Leibniz International Proceedings in Informatics (LIPIcs), pages 95:1–95:22, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ITCS.2024.95.
  • [78] Andrew Chi-Chih Yao. Theory and applications of trapdoor functions (extended abstract). In FOCS, pages 80–91. IEEE Computer Society, 1982. doi:10.1109/SFCS.1982.45.