Abstract 1 Introduction 2 Preliminaries 3 Hardness Amplification via Concatenation 4 Results for Cryptographic Hardness Amplification 5 How to Extract Many Hardcore Bits 6 A More Efficient PRG 7 Hardness Amplification via Randomized Iterates References

How to Use Nondeterminism in Cryptography

Marshall Ball ORCID New York University, NY, USA Peter Crawford-Kahrl ORCID New York University, NY, USA
Abstract

Nondeterministic reductions have yielded powerful results in the theory of computational complexity, yet are effectively useless in a cryptographic context. The reason for this is simple, a nondeterministic polynomial time adversary can trivially break almost any cryptographic primitive by simply guessing the “key.”

In order to use this powerful nondeterministic tool kit in the cryptographic context, we initiate the study of cryptography against adversaries with limited nondeterminism: polynomial time nondeterministic algorithms that are restricted to just a few bits of nondeterminism. We demonstrate that limited nondeterministic security is sufficient to prove two foundational results that have eluded our grasp for decades: dream hardness amplification, and extracting ω(logn) hardcore bits.

Keywords and phrases:
limited nondeterminism, cryptography, computational complexity, hardness amplification, pseudorandom generators, hardcore bits
Funding:
Marshall Ball: This work was supported in part by the National Science Foundation CAREER Award #2443735. Any opinion, findings, and conclusions or recommendations expressed in this material are those of the authors(s) and do not necessarily reflect the views of the National Science Foundation.
Copyright and License:
[Uncaptioned image] © Marshall Ball and Peter Crawford-Kahrl; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Computational complexity and cryptography
; Security and privacy Cryptography
Acknowledgements:
The first author would like to thank Benny Applebaum, Iftach Haitner, and Ronen Shaltiel for enlightening discussions on this topic.
Editor:
Shubhangi Saraf

1 Introduction

Nondeterministic reductions are an incredibly powerful tool in computational complexity. Nondeterministic reductions have enabled us to isolate incredibly hard problems (e.g., proving circuit lower bounds [22, 30]) and make already hard problems extremely hard (e.g., constructing problems that are incredibly hard even on a random instance [27, 11, 18]). Despite the powerful applications in computational hardness, nondeterministic reductions have had relatively little111One notable exception is the work of Barak, Ong, and Vadhan [3] which uses nondeterministic hardness assumptions to derandomize cryptographic proof systems and commitment schemes. impact on traditional cryptography.

It is not difficult to see why. Nearly any cryptographic scheme is easily broken by a nondeterministic adversary that can “guess” a secret key. For example, consider the (minimal) case of a one-way function: a function f that is easy to evaluate, yet given y=f(x) for a random x it is hard to find any preimage of y. If hard means hard for nondeterministic polynomial time, putting aside exactly what this means for now, then this notion is clearly impossible to achieve: a nondeterministic adversary can simply nondeterministically “guess” a preimage x{0,1}n and check that f(x)=y.

Consequently, if one wants to construct a cryptographic primitive B from underlying cryptographic primitive A, one cannot use a nondeterministic reduction to prove security (at least in any standard sense).

In this work, we propose a way around this quagmire, enabling the use of nondeterministic reductions in a cryptographic context: limited nondeterminism. Intuitively, in our example above if the adversary only has access to n/2 nondeterministic bits, then the adversary cannot guess a complete witness and the naive attack above will no longer succeed.

Limited nondeterministic adversaries

Before going further, it is worth discussing what limited nondeterministic means in more detail. We consider a ϕ-limited nondeterministic adversary to be a (probabilistic) polynomial time algorithm that has access to ϕ-nondeterministic bits. If we restrict ourselves to non-probabilistic adversaries this definition is straightforward for decision problems. For probabilistic adversaries, we consider a notion mirroring 𝖠𝖬: the short witness is chosen after the random coins. For search problems, as we are concerned with in this work, there are a variety of interpretations of “nondeterministic algorithm that outputs multiple bits.” For the purpose of this work, we adopt a broad and simple approach: we consider a limited nondeterministic algorithm to successfully solve a problem (after sampling the random coins) if any computational path is successful.

Limited nondeterminism has been extensively studied in the context of computational complexity. Beginning in the 1980s, Kintala and Fischer [23] initiated the study of 𝖭𝖯[logk(n)], what can be computed with logk(n) nondeterministic bits. Papadimitriou and Yannakakis [26] used this notion to analyze various optimization problems. Cai and Chen [7] (see also [8]) and later Flum et al. [13] rigorously connected the notion to parametrized complexity. We refer the reader to the brief survey by Goldsmith et al. [15], although much has happened since it was written. One notable example is Ryan Williams’s framework for proving new circuit lower bounds [29].

Despite its utility in complexity theory, the notion of limited nondeterminism has, to our knowledge, received no attention in the cryptographic context.

Feasibility of limited nondeterministic security

Armed with this strong adversarial model, the first and perhaps most important question is whether cryptographic security against such adversaries is indeed feasible. To this end, note that any ϕ(n)-nondeterministic adversary can be simulated in 2ϕ(n)poly(n) time. So, for example, subexponential security immediately implies security against nϵ-limited nondeterministic adversaries (for any constant ϵ<1).

However, we believe security ϕ-nondeterministic adversaries to be a strictly weaker notion than 2ϕpoly(n)-security. While we cannot definitively show this, there is some readily available evidence. In the nonuniform setting a counting argument demonstrates a massive gap in the size of the two classes: while there are 2O~(nc) nϵ-limited nondeterministic adversaries of size nc, there are 22nϵ adversaries of size 2nϵ. Moreover, the two notions can be readily separated in a relativized world.222Consider a random oracle and a “secret shared” inversion oracle. The secret shared inversion oracle allows one to find a preimage of the random oracle with a superpolynomial number of queries, but few queries reveal nothing.

Finally, we note that ϕ-limited nondeterministic security may be possible in regimes where 2ϕ-security is not. Namely, building on classical time/space tradeoffs [19, 12], it was recently shown that a one-way function cannot be secure against nonuniform adversaries of size 2.81n [25, 21]. However, these methods seem to critically rely on large amounts of nonuniform advice and thus it is reasonable to conjecture that one-way functions secure against nonuniform polynomial size adversaries with even 0.99n-bits of nondeterminism exist.

One might hope a closer analogue of security against limited nondeterministic adversaries can be found in leakage-resilient cryptography. One can view the nondeterministic bits as a small amount of (computationally unbounded) leakage on a cryptographic secret. While this notion of leakage-resilient cryptography has had extensive coverage in information-theoretic settings, it has received scant attention in computational regimes (given the strong leakage model). Aggarwal and Maurer [1] studied this notion leakage-resilience (providing various equivalent models) in the context of worst-case complexity of computational problems. However, to our knowledge, we are the first to study it in average-case settings, let alone in the cryptographic context.

1.1 Our Results: How to Use Limited Nondeterminism

In this section we briefly outline our contributions.

Defining limited nondeterminism

As mentioned above, we formalize a notion of limited nondeterministic adversaries that is meaningful in a cryptographic context.

For simplicity in this section, we will consider limited nondeterministic adversaries to be adversaries with nϵ-bits of nondeterminism for some constant ϵ<1 (unless otherwise stated). We refer the reader to the body for lemmas and theorems that precisely quantify the amount of nondeterminism required.

“Dream” hardness amplification

Andrew Yao [31] showed the direct product amplified the security of a weak one-way function (where an adversary can’t invert with 1-1/poly(n) probability) to a one-way function (where an adversary can’t invert with even negligible probability). While Yao’s analysis rules out negligible adversarial advantage, it fails to rule out even ϵ(n) adversarial advantage for any concrete negligible ϵ. While it was initially suggested that this failure to “dream hardness amplification” (security beyond negligible) was due limits of our techniques, subsequent work [10] has even found explicit counterexamples that resist being amplified beyond negligible via the direct product (under an assumption). We show that dream hardness amplification is possible for any weak one-way function that is secure against limited nondeterministic adversaries.

In more detail, we say a function f is ϵ-one-way against limited nondeterministic adversaries if (a) it is efficiently computable, and (b) no adversary succeeds in inverting with more than ϵ probability. We say f is subexponentially-one-way if the above holds and the success chance of all adversaries is O(2nc) for all c(0,1). Our (informal) main hardness amplification result follows. For the full version, see Theorem 14.

Theorem (“Dream” hardness amplification, informal).

Suppose f is a 1/2-one-way function against limited nondeterministic adversaries. Then the direct product f×2n of f is subexponentially-one-way for limited nondeterministic adversaries.

Extracting 𝝎(𝐥𝐨𝐠𝒏) hardcore bits

A hardcore predicate g for a one-way function f produces a bit g(x) that looks random even given the OWF evaluated on the same point f(x). Oded Goldreich and Leonid Levin [14] showed that every one-way function admits a (randomized) hardcore predicate. This result was perhaps the most important ingredient in the constructing pseudorandom generators from one-way functions and has found a myriad of other applications in learning and coding. While Goldreich and Levin showed how to extract not just one hardcore bit but even O(logn) hardcore bits from any one-way function, it has remained open how to extract more.333Bellare, Stepanovs, and Tessaro [4] showed that differing-inputs obfuscation suffices, however this a strong notion which still cannot construct from standard assumptions. We show that again, if the one-way function is secure against limited nondeterminism, then a straightforward generalization of Goldreich and Levin’s predicate suffices. As a corollary, this yields efficient constructions of PRGs from OWFs that match the state-of-the-art when assuming exponential security of the underlying OWF. Our result follows, and for more details see Theorem 18.

Theorem (Hardcore bits, informal).

Suppose that f is a one-way function against limited nondeterministic adversaries that have access to ϕ(n) nondeterministic bits. Then it is possible to extract ϕ(n) hardcore bits. In fact, if A is a random ×n matrix with ϕ(n), then (A,f(X),AX)𝑐(A,f(X),U) for all PPT distinguishers (arithmetic over 𝔽2).

The initial HILL construction of a PRG (see [17]) from one-way functions was an incredible breakthrough, but required fairly large seed and number of one-way function calls (relative to the security parameter). A long and beautiful line of work has sought to streamline such constructions, making them more efficient. Constructions due to [16], [24], and [28] provide a seed length of O~(n3). Additionally, at the cost of assuming exponential security, [24] provides a PRG construction with seed length O(n2). To highlight the power of our techniques, we show that limited nondeterministic security suffices to recover MP’s result, and additionally, the seed length given in our construction smoothly interpolates between the nonadaptive PRG construction in [24], and the state of the art constructions using exponential security. For example, if we consider adversaries with log2n nondeterministic bits, we obtain PRGs with seed length ω(n4/log4n), and if we have a linear number of nondeterministic bits (e.g., .00001n), then we recover the exponential security construction with seed length ω(n2).

Theorem (PRG Seed length, see Theorem 25).

Suppose that f is a one-way function against limited nondeterministic adversaries that have access to ϕ nondeterministic bits. Then, for any function s(n)=ω(1), there exists a construction of a (n.u.) poly-time secure PRG with seed length

O(n4ϕ2[(slognϕ)2+slognϕ]+n2).

Brief reflection

We have seen two foundational applications of limited nondeterministic reductions in cryptography, but suspect this is only the tip of the iceberg. Recent years have seen a proliferation of complexity leveraging and reliance on strong subexponential security assumptions. In this work, we have seen that two results known (folklore) to easily follow from complexity leveraging via super-polynomial time reductions can instead be deduced generically from weaker assumptions (via a weaker and only slightly more complex form of complexity leveraging). It is our hope that these notions and techniques will enable future researchers to reduce their assumption footprint in settings that seemingly necessitate complexity leveraging.

1.2 Technical Overview

Hardness amplification

We recall the standard Yao-style hardness amplification via the direct product (i.e., q-wise concatenation): if an algorithm inverts f×q with noticeable success, there is an index i at which “planting” a single instance preserves much of this success. In the PPT setting, one would simply repeat this algorithm a polynomial number of times and take the first successful output, and thus invert a single copy of f with high probability. In the limited-nondeterminism setting we follow the same high-level approach, with a specific caveat. When a reduction repeats a sub-protocol, if witness bits are not reused in subsequent repetitions, even O(n) repetitions can already consume a sublinear witness budget. We will need to ensure that we are able to reuse the same witness string in each run of a repeated sub-protocol, so we use a one-shot method: generate a list of candidate random tapes via (strongly) universal hashing, fix the witness bits, run the subroutine on each tape, and then verify which run succeeded, returning the first output that did so.

Our main technique revolves around our technical Lemma 7, which informally states the following: given a search problem, if there is a limited nondeterministic adversary 𝖠 that, for every input in some good set, succeeds with probability at least δ, then for any given ϵ we can construct a limited nondeterministic adversary 𝖠 that uses O(log(1/δ)) additional witness bits444Of note, the random-bit complexity of 𝖠 increases polynomially, but here our focus is on the number of nondeterministic-bit budget. and succeeds at the same search problem with success probability greater than 1ϵ. Then, the reduction for hardness amplification of a direct product follows; a Yao-style argument shows that there exists an index i and “good set” 𝒢, such all y𝒢 result in a success chance comparable to the overall success (up to an acceptable loss), and that 𝒢 has sufficiently large density. Lemma 7 allows us to boost the success probability for every input in that good set without overshooting our budget of nondeterministic bits. Subexponential hardness follows because if such a good set exists with a success chance at least 2nc, we only require Θ(nc) additional nondeterministic bits to boost the reduction’s success probability to greater than 12.

Extracting many hardcore bits

At first, one might consider using nondeterminism to prove that a single hardcore bit is extremely hard. There are issues with this approach; for example, suppose that there was a limited nondeterministic adversary that, given f(x) and some extremely hardcore predicate of x, is able to return a single bit of x. Any style of list decoding reduction would need to extract n-bits, and without some type of guarantee that witness bits could be reused, would result in exceeding our nondeterminism budget. In addition, Applebaum et al. [2] showed that nondeterministic black-box polynomial-time reductions cannot succeed in constructing predicates that are hard to predict with inverse superpolynomial advantage.

Instead of focusing on one bit at a time, we will show that if f is a one-way function against limited nondeterministic adversaries that have access to ϕ(n) nondeterministic bits, and A is a random ×n matrix with ϕ(n), then (A,f(X),AX)𝑐(A,f(X),U) for all PPT distinguishers (arithmetic over 𝔽2). To do so, we open Yao’s distinguisher-to-predictor hybrid argument. Then, letting A1,A2, denote the rows of the matrix A. Via a hybrid argument, there is some index i such that the bit AiX is hard to distinguish from a random bit when given (f(X),A<iX). Via a standard distinguisher-to-predictor argument, we can obtain an adversary that can predict AiX when given A, A<iX and f(X). If we can predict r,x for a random vector r, then we can use the Goldreich-Levin hardcore reduction on this bit to compute x and thus invert f(x). However, an issue that arises in the PPT setting is to somehow correctly sample the (i1)-bit prefix A<iX. If i is too large (e.g., i=ω(logn)), guessing is infeasible. In our limited-nondeterministic world however, we argue that with high enough probability it suffices to draw A<i at random, hardcode it, and then nondeterministically sample the required bits A<iX we need to run the Goldreich-Levin reduction. Since we spend i1< nondeterministic bits doing so, as long as ϕ(n) we do not exceed our nondeterministic bits budget, the reduction goes through.

Extracting more than logn hardcore bits in this way “immediately” yields efficient PRGs. The high-level idea of efficient PRGs (see [24]) from exponentially hard one-way functions is that one can extract Θ(n) hardcore bits instead of O(logn), which means that the constructions need fewer iterations (and thus a shorter seed) overall. Thus, if we assume that we started with limited nondeterministic hardness that allows one to extract just as many bits, we get an equivalently efficient construction. That said, our results also apply to the intermediate regime, where our limited nondeterministic budget is too small to extract the full Θ(n) hardcore bits, but still allows ω(logn) hardcore bits, which leads to PRGs with seed lengths in between those given by standard one-way functions and exponentially secure one-way functions. We do note that our approach only deals with the PRG construction in [24] as a proof of concept. We expect analogous limited nondeterministic techniques to apply to other PRG frameworks.

2 Preliminaries

We let log and ln denote logarithms base 2 and e, respectively. We use calligraphic letters to denote sets, capital sans-serif letters to denote algorithms, lowercase letters to denote values, vectors, and functions; and uppercase letters to denote matrices or random variables, with the exception of Vn(), which denotes a predicate. For n, let [n]:={1,,n}. Let {0,1}:=n{0,1}n. For a set 𝒮, we write xu𝒮 to denote that x was drawn uniformly at random from 𝒮, and we denote the uniform distribution over {0,1}n by Un. Let negl() and poly() denote a negligible function and polynomial, respectively. For a matrix M{0,1}m×n, we identify M with the function M:{0,1}n{0,1}m defined by M(x)=Mxmod2. We write X𝑐Y for computational indistinguishability, and X𝑐ϵY when the advantage is ϵ.

2.1 Defining Limited Nondeterministic Turing Machines

The study of problems that can be solved with limited nondeterminism was initiated by Kintala and Fischer [23]. A related definition tailored to nonuniform models of computation (and more) was introduced by Cai and Chen [7]. Flum, Grohe, and Weyer [13] demonstrated connections between limited nondeterministic complexity and notions of fixed-parameter intractability.

However, in this work, we are interested not only in decision problems, but also the nondeterministic complexity of search problems. Various notions of nondeterministic computations of functions have been introduced, for example [5, 6, 20, 11]. These definitions follow a similar template, the key difference is what it means to “compute a function nondeterministically.” The most relaxed notion, considered also in this work, means that computation does not actually compute a function but a mapping relation, the function nondeterministically chooses an output and different computation paths need not lead to the same output. More restricted notions require all accepting computation paths to output a single unique output.

Our definition of limited nondeterministic computation is a generalization of that of Cai and Chen [7] to the context of search problems (following Drucker’s adaptation [11] of nondeterministic search problems to the nonuniform context).

Definition 1.

For any function ϕ:, we say a Turing machine 𝖬 is a randomized limited nondeterministic Turing machine with ϕ(n) nondeterministic bits, if 𝖬 has three input tapes consisting of

  • x1,,xn input bits,

  • w1,,wϕ(n) nondeterministic (i.e., witness) bits,

  • r1,,rρ(n) random bits where ρ(n)=poly(n) is an arbitrary polynomial,

and one output tape. We denote the output of 𝖬 as 𝖬(x,w,r). The set of all such Turing machines we denote RLNTM(ϕ(n)). Since it is always possible to brute-force a logarithmic number of bits, throughout this paper we will always assume that ϕ(n)=ω(logn) and ϕ(n)<n.

We analyze the ability of limited nondeterministic Turing machines to perform several cryptographically interesting tasks (e.g., inversion of one-way functions, breaking collision-resistant hashes, or breaking hardcore bits).

Our results apply to collision-resistant hashes and one-way functions, but more generally, they apply to any search problem wherein the adversary can check their answer. More formally, many of our main results can be phrased in terms of a machine 𝖬RLNTM(ϕ(n)) solving an efficiently verifiable search problem, i.e. search problems where an adversary is given some efficiently computable predicate Vn:𝒳×𝒴{0,1}, and an element y𝒴, and asked to find any x𝒳 such that x satisfies Vn(x,y)=1. We formalize this in the following definition.

Definition 2.

Let {𝒳n}n and {𝒴n}n be families of sets. Let Vn:𝒳n×𝒴n{0,1} be an efficiently computable predicate (i.e., a function computable in polynomial time). The (efficiently verifiable) search problem defined by Vn is as follows: given y𝒴n, find x𝒳n such that Vn(x,y)=1.

Let 𝖬 be a randomized limited nondeterministic Turing machine that takes input y𝒴n, uses ϕ(n) nondeterministic bits and ρ(n) random bits, and outputs an element of 𝒳n. We are interested in the following probability, which we refer to as 𝖬’s success probability (for the search problem defined by Vn):

Pry,r[w{0,1}ϕ(n):Vn(𝖬(y,w,r),y)=1],

where the probability is taken over yu𝒴n and ru{0,1}ρ(n)

 Remark 3.

Our results apply to any problem that can be phrased as an efficiently verifiable search problem. We remark that any theorem or lemma that refers to search problems can be translated to relate to one-way functions and/or collision-resistant hashes, by picking a Vn so that finding (x,y) that satisfies Vn(x,y)=1 is equivalent to solving the problem of interest.

Specifically, for a one-way function f, we phrase the inversion task as follows: let 𝒳n:={0,1}n be the domain of f, let 𝒴n:=f({0,1}n) be the image of f, and let Vn:{0,1}n×f({0,1}n){0,1} be defined by Vn(x,y)=1 if f(x)=y, and 0 otherwise.

For a given family of (keyed) collision-resistant hash functions {k}k𝒦, where 𝒦 is the set of keys, we let 𝒳n:={0,1}n×{0,1}n be the set of pairs of inputs, 𝒴n:=𝒦 be the set of keys, and let Vn:{0,1}n×{0,1}n×𝒦{0,1} be defined by Vn(x1,x2,k)=1 if hk(x1)=hk(x2)x1x2, and 0 otherwise. Then, the search problem becomes: given a key k, find two elements x1x2 that map to the same image under the map hk.

For any function g:𝒳𝒴 and m, we use g×m:𝒳m𝒴m to denote the direct product map defined by g×m(x1,,xm)=(g(x1),,g(xm)).

2.2 Key Technical Lemma

Definition 4.

Let 𝒰 be a finite set and let {h:𝒰𝔽2k} be a finite family of functions from 𝒰 to 𝔽2k. We say that is a strongly universal hash family if, u,u𝒰 with uu, z,z𝔽2k, we have

Prhu[h(u)=zh(u)=z]=22k
Proposition 5 (folklore).

Let k,>0. Then

,k:={hA,v:F2𝔽2kA𝔽2k×,v𝔽2k}

is a strongly universal hash family, where hA,v(x):=Ax+v with addition over 𝔽2k.

Lemma 6.

Let {h:𝒲𝒱} be a strongly universal hash family. Let 𝒰𝒱 be a finite set, and let p=|𝒰||𝒱|. Then

Prhu[w𝒲:h(w)𝒰]11|𝒲|p
Proof.

Let 𝒲={w1,,w|𝒲|} and let Xi:=[h(wi)𝒰] be the indicator random variable for the event that h(wi) is in 𝒰. Notice that X1,,X|𝒲| are pairwise independent, 𝖤[Xi]=PrvuV[v𝒰]=p, and 𝗏𝖺𝗋[Xi]=p(1p). Define S:=i=1|𝒲|Xi. Note 𝖤[S]=p|𝒲| and 𝗏𝖺𝗋[S]=|𝒲|𝗏𝖺𝗋[X1]=|𝒲|p(1p). We seek to estimate Pr[S=0]. If S=0, then |S𝖤[S]|=|𝒲|p, so applying Chebyshev’s inequality we obtain

Pr[S=0]Pr[|S𝖤[S]||𝒲|p]𝗏𝖺𝗋[S](|𝒲|p)2=|𝒲|p(1p)(|𝒲|p)2=1p|𝒲|p1|𝒲|p.

Thus, Prhu[w𝒲:h(w)𝒰]=Pr[S1]11|𝒲|p.

Lemma 7 (probability boosting for efficiently verifiable search problems).

Let ϵ,δ(0,1). Let {𝒳n}n and {𝒴n}n be families of sets. Let Vn:𝒳n×𝒴n{0,1} be an efficiently computable function. Let {𝒢n𝒴n}n be a family of sets. Suppose that 𝖬 is a randomized limited nondeterministic Turing machine that uses ϕ(n) nondeterministic bits and ρ(n) random bits, and suppose that for all y𝒢n, 𝖬 satisfies

Prru{0,1}ρ(n)[w{0,1}ϕ(n):V(𝖬(y,w,r),y)=1]>δ

then there exists a randomized limited nondeterministic Turing machine 𝖬 that uses ϕ(n)+log2δ nondeterministic bits and (ρ(n)+1)log2δlog1ϵ random bits, and for all y𝒢n, 𝖬 satisfies

Prr{0,1}ρ(n)[w{0,1}ϕ(n)+log2δ:V(𝖬(y,w,r),y)=1]>1ϵ.

The subtlety lies in the fact that we cannot boost the probability through simple repetition. In a standard PPT setting, we could always boost the success probability by using multiple runs of an algorithm, but we need to be very careful in the limited nondeterministic setting. It is only possible to rerun sub-protocols if we can reuse the same nondeterministic bits for each run. To get around this fact, we use the same nondeterministic bits for each run, and then, at the very end, verify which run was actually successful. This subtlety, while at first seemingly unimportant, can cause some serious issues when importing many black box reductions from other settings to the limited nondeterministic setting. If the success of a particular sub-protocol is required for a later step to be run successfully, or alternatively, if there is no way to guarantee that the exact same witness string can be reused for each sub-protocol, then many reductions are not importable.

Proof.

Let denote the set of random strings for which 𝖬 succeeds, i.e.

:={r{0,1}ρ(n)|w{0,1}ϕ(n):V(𝖬(y,w,r),y)=1}.

The main idea of the proof is to use some nondeterministic bits, along with a hash function, to generate a string, call it r1, that is contained in with probability at least 12. We then repeat this times, generating a list of candidate strings r1,,r, so that for properly chosen , the probability that at least one such string is in is greater than 1ϵ. We then verify that one of these is (with high probability) the correct answer by computing V(𝖬(y,w,ri),y) for i=1,,. Details follow.

Let :=log2δ and m:=log1ϵ. We define 𝖬 as follows:

  • Parse the nondeterministic bits into (w,w){0,1}ϕ(n)×{0,1}

  • Parse the random bits into (A1,v1),,(Am,vm)𝔽2ρ(n)××𝔽2ρ(n).

  • For i[m], compute r~iAiw+vi, with arithmetic over 𝔽2.

  • For i[m], compute x~i𝖬(y,w,r~i).

  • Return the first x~i such that V(x~i,y)=1 if one exists; otherwise return .

To analyze the probability that 𝖬 does not output , we first analyze the chance that at least one r~i is in . We know that Prr{0,1}ρ(n)[w{0,1}ϕ(n):V(𝖬(y,w,r),y)=1]>δ, hence ||>δ2ρ(n).

We can use Lemma 6 to compute the chance that a single r~i works, as follows: let i[m], and note

Pr(A,v)u𝔽2n××𝔽2n[w{0,1}:Aw+v] 11|{0,1}|δ
=112δ
112
=12

since =log2δ, and so 12δ12. We have drawn m independent hashes, so

Pr[w{0,1},i[m]:r~i]
=1Pr[w{0,1},i[m]:r~i]
=1i[m]Pr[w{0,1},r~i]
>112m12log1ϵ=1ϵ

As long as there is some index i so that r~i, we can nondeterministically pick w so that V(𝖬(y,w,r~i),y)=1. Thus,

Prr[w:V(𝖬(y,w,r),y)=1]Pr[w{0,1},i[m]:r~i]>1ϵ,

which completes the proof.

3 Hardness Amplification via Concatenation

The core idea of the next lemma and proof comes from the proof of Proposition 1 in [9], but is included here for completeness and adapted into our framework.

Definition 8.

Given an efficiently verifiable search problem defined by Vn:𝒳n×𝒴n{0,1}, for any integer q>0 we define the q-concatenation of Vn, denoted Vnq:𝒳n×q×𝒴n×q{0,1} by

Vnq(x1,,xq,y1,,yq):=Vn(x1,y1)Vn(x2,y2)Vn(xq,yq)

Note that the next result makes no specific reference to limited nondeterminism in its proof, and holds when ϕ(n):=0.

Lemma 9 (concatenations of search problems have good sets).

Let ϵ=ϵ(n),δ=δ(n)(0,1) be functions. Let Vn:𝒳n×𝒴n{0,1} be efficiently verifiable search problem. Let q be any integer satisfying q>2δlog2ϵ. Suppose that some Turing machine 𝖬RLNTM(ϕ(n)) has success probability at least ϵ(n) for the q-concatenation Vnq. Let 𝖬 be the Turing machine defined as follows: on input y𝒴n,

  1. 1.

    choose y1,,yqu𝒴n and iu[q] uniformly at random, and set yiy

  2. 2.

    run 𝖬 on input (y1,,yq) to obtain x1,,xq, and output xi.

Then 𝖬RLNTM(ϕ(n)), and 𝖬 satisfies

Pry[Prr[w{0,1}ϕ(n):Vn(𝖬(y,w,r),y)=1]ϵδq]1δ2.
Proof.

Suppose that some Turing machine 𝖬RLNTM(ϕ(n)) has success probability at least ϵ(n) for the q-concatenation Vnq.

Let 𝖬 be the Turing machine as defined in the statement of the lemma. Following the proof of Proposition 1 in [9], we analyze the success probability of 𝖬.

Denote the events

𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y) [w{0,1}ϕ(n):Vn(𝖬(y,w,r),y)=1],
𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y1,,yq) [w{0,1}ϕ(n):Vnq(𝖬(y1,,yq,w,r),y)=1].

Let 𝒮𝒴n be any set of density δ2. Then, since q>2δlog2ϵ>2δln2ϵ, using a union bound we see that

Pry1,,yq[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y1,,yq)j[q]:yj𝒮]ϵ(1δ/2)qϵ/2.

Thus, as we are randomly guessing the index i, if j[q]:yj𝒮, the chance that we guess such an index correctly is at least 1/q, and so

Pry1,,yq,i[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y1,,yq)yi𝒮]ϵ2q.

Estimating the success chance from above, by our construction of 𝖬, we can also obtain

Pry1,,yq,i[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y1,,yq)yi𝒮]
=Pry1,,yq,i[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y1,,yq)yi𝒮]Pry1,,yq,i[yi𝒮]
=δ2Pry1,,yq,i[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y1,,yq)yi𝒮]
δ2maxy𝒮Pr[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y)]

Putting these estimates together, we see that for any set 𝒮𝒴n of density δ/2,

maxy𝒮[Pr[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y)]]ϵδq. (1)

By way of contradiction, suppose that

Pry[Pr[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y)ϵδq]]1δ/2

Then there would exist some set 𝒴n of density at least δ/2 so that for every y, Pr[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y)]<ϵδq, contradicting (1). Therefore,

Pry[Pr[𝖲𝗎𝖼𝖼𝖾𝗌𝗌𝖬(y)ϵδq]]1δ2,

completing the proof.

Theorem 10 (inverter for concatenations of search problems).

Let ϵ,δ(0,1) be arbitrary. Let Vn:𝒳n×𝒴n{0,1} be efficiently verifiable search problem. Let q>2δlog2ϵ be any integer. Suppose there exists some Turing machine 𝖬RLNTM(ϕ(n)) that uses ϕ(n) nondeterministic bits and ρ(n) random bits, and has success probability at least ϵ(n) for the q-concatenation Vnq.

Then there exists a limited nondeterministic Turing machine 𝖬 that uses

ϕ(n)+log2δqϵ

nondeterministic bits, and

(ρ(n)+1)log2δqϵlog2δ

random bits, and such that the success probability of 𝖬 for Vn is at least 1δ.

Proof.

At a high level, this result follows directly from Lemma 9, which yields a Turing machine that has a large set of inputs such that for each one of those inputs, the success probability is bounded below by a certain amount. Once such a set exists, we can instantiate Lemma 7 to significantly boost the success probability, and obtain the desired machine. Details follow.

From Lemma 9, we obtain a Turing machine 𝖬 such that

Pry[Prr[w{0,1}ϕ(n):Vn(𝖬(y,w,r),y)=1]ϵδq]1δ2,

or in other words, there exists a set 𝒢n𝒴n of density at least 1δ2 such that, for all y𝒢n, Prr[w{0,1}ϕ(n):V(𝖬(y,w,r),y)=1]ϵδq. We are thus set up to apply Lemma 7 This gives us a Turing machine 𝖬′′ such that for 𝖬′′ uses ϕ(n)+log2δqϵ nondeterministic bits, and (ρ(n)+1)log2δqϵlog2δ random bits, and for every y𝒢, 𝖬′′ will succeed on that y with probability greater than 1δ/2, hence the overall success chance of 𝖬′′ is greater than (1δ/2)Pry[y𝒢n]=(1δ/2)2>1δ, completing the proof.

4 Results for Cryptographic Hardness Amplification

4.1 One-Way Functions

Definition 11.

We say a polynomial-time Turing machine is a sublinearly-limited nondeterministic Turing machine, if there exists c>0 and ϵ(0,1) such that 𝖬RLNTM(cnϵ). We denote the class of such Turing machines as sublinNTM. In other words,

sublinNTM:=ϵ(0,1)c>0RLNTM(cnϵ).
Definition 12.

Given a function f:{0,1}{0,1} and 𝖬RLNTM(ϕ(n)), we refer to the probability

Prx,r[𝖬 inverts f]:=Prx,r[w{0,1}ϕ(n):𝖬(f(x),w,r)f1(f(x))]. (2)
Definition 13 (one-way for limited nondeterminism).

Given an efficiently computable function f:{0,1}{0,1}, and a collection 𝖢 of randomized limited nondeterministic Turing machines, and a function α:[0,1], we say that f is α(n)-one-way for 𝖢 if for all 𝖬𝖢, for all sufficiently large n,

Prx,r[𝖬 inverts f]α(n).

We say that f is subexponentially-one-way for 𝖢 if for all ϵ(0,1) and for all 𝖬𝖢, for all sufficiently large n,

Prx,r[𝖬 inverts f]12nϵ.
Theorem 14.

Let p(n)=poly(n), and let f:{0,1}{0,1} be (11p(n))-one-way for sublinNTM. Then f×(2np(n)) is subexponentially-one-way for sublinNTM.

Proof.

Suppose not. Then there exists ϵ(0,1) and there exists a randomized limited nondeterministic Turing machine 𝖬sublinNTM, such that for infinitely many n,

Prx,r[𝖬 inverts f×(2np(n))]>2nϵ.

Thus, there exists c>0 and ϵ′′(0,1) such that 𝖬RLNTM(cnϵ′′)

We recall how to phrase the inversion task of a one-way function in terms of our definition of a search problem. Let 𝒳n:={0,1}n be the domain of f, let 𝒴n:=f({0,1}n) be the image of f, and let Vn:{0,1}n×f({0,1}n){0,1} be defined by Vn(x,y)=1 if f(x)=y, and 0 otherwise.

Then we can simply instantiate Theorem 10. Set δ=1/p(n), ϵ=2nϵ, and q=2np(n). We note that 2δlog2ϵ=2p(n)(1+nϵ)<2np(n)=q. Thus, applying Theorem 10, we obtain a randomized limited nondeterministic Turing machine 𝖬 that has success probability at least 1δ=11/p(n), and that uses

cnϵ′′+log2δqϵ<cnϵ′′+log(4n)+1+nϵ=O(nmax{ϵ,ϵ′′})

nondeterministic bits. Hence, 𝖬sublinNTM, and succeeds at inverting f with probability greater than 11p(n), contradicting the fact that f is (11p(n))-one-way for sublinNTM.

Corollary 15.

Let f:{0,1}{0,1} be 12-one-way for sublinNTM. Then f×(2n) is subexponentially-one-way for sublinNTM.

4.2 Collision-Resistant Hash Functions

Definition 16.

A family of hash functions is a collection of polynomial-time computable functions :={n:{0,1}𝗄𝖾𝗒(n)×{0,1}𝗂𝗇(n){0,1}𝗈𝗎𝗍(n)}, where n is the security parameter, satisfying 𝗈𝗎𝗍(n)<𝗂𝗇(n). We refer to 𝗂𝗇(n), 𝗈𝗎𝗍(n), 𝗄𝖾𝗒(n) as the input length, output length and key size of the hash function, respectively. We use hκ:{0,1}𝗂𝗇(n){0,1}𝗈𝗎𝗍(n) to denote the function n(κ,) associated with the key κ{0,1}𝗄𝖾𝗒(n). We call a pair (x0,x1) satisfying x0x1 and hκ(x0)=hκ(x1) a collision for hκ.

Given a collection 𝖢 of randomized limited nondeterministic Turing machines, we say n is an ϵ-CRHF (collision-resistant hash function) for 𝖢 if for every 𝖬𝖢,

Pr[κ{0,1}𝗄𝖾𝗒(n):M(κ) outputs a collision for hκ]<ϵ

We say that n is a subexponentially-secure CRHF for 𝖢 if for all ϵ(0,1) and for all 𝖬𝖢, for all sufficiently large n,

Pr[κ{0,1}𝗄𝖾𝗒(n):M(κ) outputs a collision for hκ]<12nϵ.
Theorem 17.

Let p(n)=poly(n), and let n be a (11p(n))-CRHF for sublinNTM. Then n×(2np(n)) is subexponentially-secure CRHF for sublinNTM.

Proof.

Identical to the proof of Theorem 14, using the following search problem. Let 𝒳n:={0,1}n×{0,1}n be the set of pairs of inputs, 𝒴n:=𝒦 be the set of keys, and let Vn:{0,1}n×{0,1}n×𝒦{0,1} be defined by Vn(x1,x2,k)=1 if hk(x1)=hk(x2)x1x2, and 0 otherwise.

5 How to Extract Many Hardcore Bits

In this section, we show how OWF with ϕ-limited nondeterministic hardness yields ϕ hardcore bits (against PPT algorithms). In subsequent sections, we show that this result further implies that OWF against Ω(n)-limited nondeterministic hardness yield PRG constructions matching the state-of-the-art efficiency. Prior constructions [16, 24] with matching efficiency required the one-way function to be secure against exponential time adversaries (a strictly stronger assumption). In both prior work and ours, the resulting PRG is only achieves negligible distinguishing advantage against polynomial time adversaries.

Theorem 18.

Suppose that f:{0,1}{0,1} is α(n)-one-way for RLNTM(ϕ(n)), for some α(n)=negl(n). Let (n) be any function such that (n)ϕ(n). Let Au{0,1}(n)×n be a random matrix. Let Xu{0,1}n. Then (A,f(X),AX)𝑐(A,f(X),U), where AX is computed with arithmetic over 𝔽2. That is to say, for all PPT distinguishers 𝖣,

|Pr[𝖣(A,f(X),AX)=1]Pr[𝖣(A,f(X),U)=1]|=negl(n)
Proof.

Let A1,,A denote the rows of A, and for any jk let Aj:k denote the matrix with rows Aj,Aj+1,,Ak. Then we can write (A,f(X),AX)=(A1:,f(X),A1:X).

We will use a hybrid argument. For all i=0,,, let Hi:=(A1:,f(X),A1:iX,Ui), where by convention we take U0:=.

H0 :=(A,f(X),U)
H1 :=(A,f(X),A1X,U1)
H2 :=(A,f(X),A1X,A2X,U2)
H1 :=(A,f(X),A1X,A2X,,A1X,U1)
H :=(A,f(X),A1X,A2X,,AX)

We will prove that if there exists an i[1] so that HiHi+1, then f is not α(n)-one-way for RLNTM(ϕ(n)).

Suppose that there exists some i[1] so that HiHi+1, and for the time being, suppose that we know which index this is (we will modify the argument to guess the index at the end of the proof).

Then, there exists some PPT distinguisher 𝖣, and there exists ϵ(n)>1/poly(n), such that for infinitely many n,

|Pr[𝖣(A1:,f(X),A1:iX,Ui)=1]Pr[𝖣(A1:,f(X),A1:iX,Ai+1X,Ui1)=1]|>ϵ(n)

If we think of Ai+2: and Ui1 as internal coins that 𝖣 can throw, then we can write this as

|Pr[𝖣(A1:i+1,f(X),A1:iX,U1)=1]Pr[𝖣(A1:i+1,f(X),A1:iX,Ai+1X)=1]|>ϵ(n)

Using a standard “distinguisher-to-predictor” style argument, we can obtain an adversary 𝖠 that satisfies

PrA1:i+1,X[𝖠(A1:i+1,f(X),A1:iX)=Ai+1X]12+ϵ(n)2

Then, an application of Corollary 20 ensures that there is a set, call it 𝒢x{0,1}n, such that PrX[X𝒢x]>ϵ(n)/2, and for all fixed x𝒢x,

PrA1:i+1[𝖠(A1:i+1,f(x),A1:ix)=Ai+1x]12+ϵ(n)4.

For any fixed x𝒢x, we can apply Corollary 20 again to find a set 𝒢A(x){0,1}i×n so that PrA1:i[A1:i𝒢A(x)]>ϵ(n)8, and for all fixed A^1:i𝒢A(x),

PrAi+1[𝖠(A^1:i,Ai+1,f(x),A^1:ix)=Ai+1x]12+ϵ(n)8.

The idea is to then simply hard-code A^1:i and A^1:ix into our adversary, and run the standard Goldreich-Levin hardcore bit reduction to invert f. The trick is that while we can easily hard-code A^1:i, we need a few nondeterministic bits to guess the i-bit string A^1:ix. If is too large, we would not be able to correctly guess this string with non-negligible chance. However, with i bits of nondeterminism, we can safely guess this string, as long as x𝒢x and A^1:i𝒢A(x). Since i, as long as ϕ, we will have enough budget of nondeterministic bits. We observe that independence yields Pr[X𝒢xA^1:i𝒢A(x)]ϵ(n)216, which is still greater than 1/poly(n). Conditioned on this event, the GL reduction [14, 31] gives a decoder for finding x with a success chance that is also >1/poly(n). Finally, we need to guess the correct index to actually apply the reduction, which we can do with probability 1/, and <n, so overall, we obtain an inverting algorithm that uses exactly bits of nondeterminism and, with probability >1/poly(n), finds an element of f1(f(x)).

We do need the following lemma and corollary, which is likely folklore, but included here with proof for completeness.

Lemma 19.

Let 𝒳 and 𝒴 be finite sets. Let D:𝒳×𝒴{0,1} be a predicate, and let α>0. Suppose that Prx,y[D(x,y)=1]>α. Then for all 0β<α, there exists a set 𝒢𝒳 such that Prx[x𝒢]αβ1β and for all x𝒢, Pry[D(x,y)=1]>β.

Proof.

We apply an averaging argument. Let 𝒢:={x𝒳:Pry[D(x,y)=1]>β}. By way of contradiction, suppose that Prx,y[D(x,y)=1]>α and Prx[x𝒢]<αβ1β. Then

Prx,y[D(x,y)=1]=Prx,y[D(x,y)=1|x𝒢]Prx[x𝒢]+Prx,y[D(x,y)=1|x𝒢]Prx[x𝒢]
Prx,y[D(x,y)=1|x𝒢]αβ1β+Prx,y[D(x,y)=1|x𝒢]Prx[x𝒢]
Prx,y[D(x,y)=1|x𝒢]αβ1β+βPrx[x𝒢]
αβ1β+βPrx[x𝒢]αβ1β+β(1αβ1β)=α

and thus α<Prx,y[D(x,y)=1]α, a contradiction.

Corollary 20.

Let 𝒳 and 𝒴 be finite sets. Let D:𝒳×𝒴{0,1} be a predicate, and let μ>0. Suppose that Prx,y[D(x,y)=1]>1/2+μ. Then there exists a set 𝒢𝒳 such that Prx[x𝒢]μ/2 and for all x𝒢, Pry[D(x,y)=1]>1/2+μ/2.

Proof.

Apply Lemma 19, with α=1/2+μ, and β=μ/2, and note αβ1βαβ.

6 A More Efficient PRG

In this subsection, we show how to use the result from Section 5 to adapt PRG constructions (from OWF) that previously required exponential hardness assumptions to instead use linear limited nondeterministic hardness assumptions.

The state-of-the-art in efficient PRG constructions can be summarized as follows:

  • [16]: Assuming exponentially-secure one-way functions, there exists a PRG construction that (adaptively) invokes the OWF ω(logn) times with seed length ω(nlogn).

  • [24]: Assuming exponentially-secure one-way functions, there exists a PRG construction that nonadaptively invokes the OWF ω(logn) times with seed length ω(n2).

In both cases, this efficiency (over constructions from poly-secure OWF) is achieved by exploiting the fact that exponentially-secure OWF yield a linear number of hardcore bits. While many other beautiful ideas are involved in these constructions (and we encourage the reader to delve deeper into the details of these amazing papers!), exponential-security is only used to get a linear number of hardcore bits from linear hashes (i.e. extended Goldreich-Levin).

6.1 Bits-Unpredictability Definitions

For the remainder of this section, we switch to a nonuniform adversary model. Specifically, we adjust our definition of randomized limited nondeterministic Turing machines with ϕ(n) nondeterministic bits to include an additional read-only advice tape a1,,ap(n) for some p(n)=poly(n). None of our proofs make use of the advice tape, so to reduce notation we will not explicitly write the dependence on the advice tape. However, it is required by the black box machinery in [24], which deals with nonuniform computation.

We use the same definitions as given in [24], repeated here for clarity.

Definition 21 (Unpredictable bits).

Let m=m(n), =(n), λ=λ(n), and k=k(n) be integer functions, and let ϵ=ϵ(n)[0,1]. We say that a function family

g={ga:{0,1}m(n){0,1}(n)}a{0,1}λ(n)

has (k,ϵ)-bits-unpredictability if for every n and x{0,1}m(n), there exists a set 𝒮(x)[(n)], such that, for Xnu{0,1}m(n) and Au{0,1}λ(n):

  1. 1.

    for every n, 𝖤[|𝒮(Xn)|]k(n), and,

  2. 2.

    for every sequence {in}n such that inx{0,1}m(n)𝒮(x),

    {A,gA(Xn)<in,gA(Xn)inin𝒮(Xn)}n𝑐ϵ{A,gA(Xn)<in,Uin𝒮(Xn)}n

We say that g has k-bits-unpredictability if it has (k,nc)-bits-unpredictability for all c.

Definition 22 (Random bits unpredictability).

Let m=m(n), =(n), λ=λ(n), and k=k(n) be integer functions, and let ϵ=ϵ(n)[0,1]. We say that a function family

g={ga:{0,1}m(n){0,1}(n)}a{0,1}λ(n)

has (k,ϵ)-random-bits-unpredictability if for every n and x{0,1}m(n), there exists a set 𝒮(x)[(n)], such that, for Xnu{0,1}m(n) and Au{0,1}λ(n):

  1. 1.

    for every i[(n)], Pr[i𝒮(Xn)]k(n)/(n), and,

  2. 2.

    for every sequence {in}n such that inx{0,1}m(n)𝒮(x),

    {A,gA(Xn)<in,gA(Xn)inin𝒮(Xn)}n𝑐ϵ{A,gA(Xn)<in,Uin𝒮(Xn)}n

We say that the function family g has k-random-bits-unpredictability if it has (k,nc)-random-bits-unpredictability for all c.

6.2 Results for Efficient PRGs

Theorem 23 (Bits-unpredictability from RLNTM).

Let f:{0,1}n{0,1}n be a one-way function for RLNTM(ϕ(n)) and let n={0,1}n×n be the family of all n×n matrices. Let

g={gM:{0,1}n{0,1}2n}Mn

be defined by gM(x):=M(f(x)),M(x). Then g has (n+ϕ(n))-bits-unpredictability.

Proof.

This effectively follows immediately from Theorem 18. For an extended discussion, see the full version of this paper.

We note that the above construction, when applied to standard OWF that is just secure against PPT adversaries, yields a function family with (n+logn)-bits-unpredictability. In the case of an OWF for RLNTM(ϕ(n)), we have a dramatic increase of bits-unpredictability, which will allow us to follow the constructions in [24] to construct a PRG with more efficient seed lengths. The key technical piece is what we have just shown, so it simply remains to follow the parameters through the constructions in [24].

Corollary 24.

Let f:{0,1}n{0,1}n be a one-way function for RLNTM(ϕ(n)). Then there exists an efficiently computable function family

g={ga:{0,1}m(n){0,1}(n)}a{0,1}λ(n)

with k-random-bits-unpredictability, for m(n)=O(n2/ϕ(n)), (n)=O(n2/ϕ(n)), λ(n)=n2, and k(n)m(n)+n. Moreover, the construction uses 2n/ϕ(n)+3 nonadaptive calls to f.

Proof.

Assume ϕ(n)>log(n)+1. We instantiate Theorem 6.1 from [24] with r(n):=2n/ϕ(n)+3, and the fact that the function family g given in Theorem 23 has (n+ϕ(n))-bits-unpredictability.

Theorem 25.

Let f:{0,1}n{0,1}n be a one-way function for RLNTM(ϕ(n)). Then, for any function s(n)=ω(1), there exists a construction of a (n.u.) poly-time secure PRG with seed length

O(n4s2log2nϕ4(n)+n4slognϕ3(n)+n2).
Proof.

The proof is nearly identical to the proof of Theorem 7.2 from [24], but uses Corollary 24. Once that piece is in place, it is just a matter of checking that parameters propagate correctly. For more details, see the full version of this paper

7 Hardness Amplification via Randomized Iterates

Finally, we will illustrate how one can use limited nondeterministic tools for other types of hardness amplification. One of the main issues with hardness amplification via the direct product is that the input length blows up by a multiplicative factor, and so the construction is not “security-preserving”. If one allows additional constraints on f, such as regularity, then better constructions exist, such as the randomized iterate (as given in [16]).

We will show how limited nondeterminism can also be applied to the randomized iterate. Very roughly, one of the key technical pieces is that our technique hinges on the existence of some large set of “good” inputs so that for every element in that set, the success probability is lower bounded by some function. Then we can use the probability boosting Lemma 7 to make the overall success chance approximately the same as the density of our good set. In the context of the direct product, we showed that such a good set must exist for at least one of the indices of the direct product.

In the context of the randomized iterate, as [16] argue, there is some index of the iterate where one can plant the input to achieve a similar effect. The main difference is that the proof proceeds via contradiction, arguing that if we have a one-way function, then there must be sufficiently large “failing sets”, or else using Lemma 7 we could boost the success probability too high.

Definition 26.

Let f:{0,1}{0,1} be a function. We say that f is regular if for all n, for all x,x{0,1}n, |f1(f(x))|=|f1(f(x))|.

Definition 27 (Definition 3.1 from [16]).

Let n, f:{0,1}n{0,1}n, and let be a family of pairwise-independent length-preserving hash functions over strings of length n. For k, x{0,1}n, and h¯=(h1,,hk1)k1, define the kth randomized iterate fk:{0,1}n×k1{0,1}n recursively as

fk(x,h¯):=f(hk1(fk1(x,(h1,,hk1))))

where f1(x):=f(x). To make notation easier, for m>k1, we let fk(x,h1,,hm)=fk(x,h1,,hk1), which is to say we ignore unneeded extra hash functions as input to the randomized iterate.

Definition 28.

Let f:{0,1}n{0,1}(n) and let 𝖠 be an algorithm trying to invert f. We say that f has a (δ(n),ϵ(n))-failing-set for 𝖠 if for large enough n, there exists a set 𝒮(n){0,1}(n) such that

  1. 1.

    Pr[f(Un)𝒮(n)]δ(n)

  2. 2.

    y𝒮(n),Pr[w:𝖠(y,w)f1(y)]<ϵ(n)

The following lemma and proof are inspired by Claim 6.2 in [16], but are adapted to our setting of limited nondeterminism.

Lemma 29.

Let f:{0,1}n{0,1}(n) be a (1ϵ)-one-way function for RLNTM(ϕ(n)), and let γ(n) be any polytime computable function such that log(1/γ)=O(nc) for some c>0. Any algorithm using ϕ(n)log(2/γ) nondeterministic bits has an (ϵ2n,γ)-failing set.

Proof.

Suppose, by way of contradiction, that f:{0,1}n{0,1}(n) is (1ϵ)-one-way, that γ be polytime computable, and there exists an algorithm 𝖠 that uses ϕ(n)log(2/γ) nondeterministic bits and ρ(n) random bits, such that it does not have a (ϵ2n,γ)-failing-set, i.e. for infinitely many n’s, there exists (n){0,1}(n) such that

  1. 1.

    Pr[f(Un)(n)]1ϵ+2n

  2. 2.

    y(n),Prr[w:𝖠(y,w,r)f1(y)]γ

Intuitively, we construct an algorithm 𝖬𝖠 that runs 𝖠 as a subprotocol and uses the probability boosting Lemma 7, assuming that y. This would imply that for all y, 𝖬𝖠 would invert successfully with probability extremely close to 1, while using ϕ(n)+log(2/γ) nondeterministic bits. In fact, by using (ρ(n)+1)log2γlog12n=poly(n) random bits, we can ensure that for all y, the probability of inverting y is greater than 12n. Thus, the probability of inverting f is greater than Pr[f(Un)(n)](12n)(1ϵ+2n)(12n)>1ϵ, contradicting the fact that f was (1ϵ)-one-way.

Theorem 30.

Let ϵ>1/poly(n) be some polynomial-time computable function, and let f:{0,1}n{0,1}n be a regular (1ϵ)-one-way function for RLNTM(ϕ(n)). Let k=k(n)=4n/ϵ(n), let be a family of pairwise-independent length-preserving hash functions, and let fk+1 be the kth randomized iterate. Let

g:{0,1}n×kf({0,1}n)×k

be defined as

g(x,h¯):=(fk+1(x,h¯),h¯).

Let ϵ be a polytime computable function. Then for any function γ that satisfies γ<ϵ4ϵ5945n5, g is ϵ-one-way for RLNTM(ϕ(n)log(2/γ)).

Proof.

By way of contradiction, suppose that f is a regular (1ϵ)-one-way function for RLNTM(ϕ(n)), and suppose that γ is some polytime computable function satisfying γ<ϵ4ϵ5945n5 and there exists an algorithm 𝖠RLNTM(ϕ(n)log(2/γ)), such that for infinitely many n’s, 𝖠 inverts g with probability greater than ϵ. Let

ϵ𝖠:=Pr[w:𝖠(f(Un),w)f1(f(Un))],

so that for infinitely many n’s, ϵ𝖠>ϵ.

Then, recalling that k(n)=4n/ϵ(n) applying Lemma 32, we obtain an algorithm 𝖡𝖠 such that for all 𝒮(n)f({0,1}n) with Pr[f(Un)𝒮(n)]ϵ/2, we have

Pr[𝖡𝖠(f(Un))f1(f(Un))f(Un)𝒮(n)]ϵ𝖠49k5=ϵ𝖠4ϵ5945n5>ϵ4ϵ5945n5.

Thus, 𝖡𝖠 has no (ϵ/2,ϵ4ϵ5945n5) fooling sets. However, applying Lemma 29, we know that 𝖡𝖠 must have an (ϵ/2,γ) failing set, and by assumption γ<ϵ4ϵ5945n5, which is a contradiction.

Corollary 31.

Let ϵ>1/poly(n) be some polynomial-time computable function, and let f:{0,1}n{0,1}n be a regular (1ϵ)-one-way function for RLNTM(ϕ(n)). Let k=k(n)=4n/ϵ(n), let be a family of pairwise-independent length-preserving hash functions, and let fk+1 be the kth randomized iterate. Let

g:{0,1}n×kf({0,1}n)×k

be defined as

g(x,h¯):=(fk+1(x,h¯),h¯).

Let ϵ be a polytime computable function. Then g is ϵ-one-way for

RLNTM(ϕ(n)O(logn)4log(1/ϵ)).
Lemma 32.

Suppose that there exists a randomized limited nondeterministic algorithm 𝖠 that uses nondeterministic bits and a polynomial time computable function ϵ𝖠 such that for infinitely many n’s, 𝖠 inverts g with probability greater than ϵ𝖠. There exists an algorithm 𝖡𝖠 which runs 𝖠 as a subroutine exactly once and uses no additional nondeterministic bits, such that for any set 𝒮(n)f({0,1}n) with Pr[f(Un)𝒮(n)]ϵ/2, it holds that

Pr[𝖡𝖠(f(Un))f1(f(Un))f(Un)𝒮(n)]ϵ𝖠49k5Ω(ϵ𝖠4/k5)
Proof.

We directly import results from Section 6.3 in [16]. The algorithm in question is built using 𝖬𝖠, which is defined as follows:

𝖬𝖠:

On input (y,h1,,hi)f({0,1}n)×i, where i[k]

  • If i=k, let w=y.

    Otherwise, choose hi+1,,hk uniformly at random and let

    w=fk1(hi+1(y),hi+2,,hk)
  • Apply 𝖠(w,h1,,hk) to get (x,h1,,hk).

  • Return fi(x,h1,,hi1)

Then define 𝖡𝖠 as follows: on input y{0,1}n, choose a random i[k] and h¯i, and return h¯i(𝖬𝖠(y,h¯)). The analysis in Section 6.3 of [16] proved that

Pr[𝖡𝖠(f(Un))f1(f(Un))f(Un)𝒮(n)]ϵ𝖠4/9k5

which completes our proof.

References

  • [1] Divesh Aggarwal and Ueli Maurer. The leakage-resilience limit of a computational problem is equal to its unpredictability entropy. In International Conference on the Theory and Application of Cryptology and Information Security, pages 686–701. Springer, 2011. doi:10.1007/978-3-642-25385-0_37.
  • [2] Benny Applebaum, Sergei Artemenko, Ronen Shaltiel, and Guang Yang. Incompressible functions, relative-error extractors, and the power of nondeterministic reductions (extended abstract). In David Zuckerman, editor, 30th Conference on Computational Complexity, CCC 2015, June 17-19, 2015, Portland, Oregon, USA, volume 33 of LIPIcs, pages 582–600. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2015. doi:10.4230/LIPIcs.CCC.2015.582.
  • [3] Boaz Barak, Shien Jin Ong, and Salil P. Vadhan. Derandomization in cryptography. In Dan Boneh, editor, Advances in Cryptology - CRYPTO 2003, 23rd Annual International Cryptology Conference, Santa Barbara, California, USA, August 17-21, 2003, Proceedings, volume 2729 of Lecture Notes in Computer Science, pages 299–315. Springer, 2003. doi:10.1007/978-3-540-45146-4_18.
  • [4] Mihir Bellare, Igors Stepanovs, and Stefano Tessaro. Poly-many hardcore bits for any one-way function and a framework for differing-inputs obfuscation. In International Conference on the Theory and Application of Cryptology and Information Security, pages 102–121. Springer, 2014. doi:10.1007/978-3-662-45608-8_6.
  • [5] Ronald V. Book, Timothy J. Long, and Alan L. Selman. Quantitative relativizations of complexity classes. SIAM J. Comput., 13(3):461–487, 1984. doi:10.1137/0213030.
  • [6] Ronald V. Book, Timothy J. Long, and Alan L. Selman. Qualitative relativizations of complexity classes. J. Comput. Syst. Sci., 30(3):395–413, 1985. doi:10.1016/0022-0000(85)90053-4.
  • [7] Liming Cai and Jianer Chen. On the amount of nondeterminism and the power of verifying (extended abstract). In Andrzej M. Borzyszkowski and Stefan Sokolowski, editors, Mathematical Foundations of Computer Science 1993, 18th International Symposium, MFCS’93, Gdansk, Poland, August 30 - September 3, 1993, Proceedings, volume 711 of Lecture Notes in Computer Science, pages 311–320. Springer, 1993. doi:10.1007/3-540-57182-5_23.
  • [8] Liming Cai, Jianer Chen, Rodney G. Downey, and Michael R. Fellows. On the structure of parameterized problems in NP. Inf. Comput., 123(1):38–49, 1995. doi:10.1006/INCO.1995.1156.
  • [9] Ran Canetti, Ron Rivest, Madhu Sudan, Luca Trevisan, Salil Vadhan, and Hoeteck Wee. Amplifying collision resistance: A complexity-theoretic treatment. In Annual International Cryptology Conference, pages 264–283. Springer, 2007.
  • [10] Yevgeniy Dodis, Abhishek Jain, Tal Moran, and Daniel Wichs. Counterexamples to hardness amplification beyond negligible. In Theory of Cryptography Conference, pages 476–493. Springer, 2012. doi:10.1007/978-3-642-28914-9_27.
  • [11] Andrew Drucker. Nondeterministic direct product reductions and the success probability of SAT solvers. In 54th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2013, 26-29 October, 2013, Berkeley, CA, USA, pages 736–745. IEEE Computer Society, 2013. doi:10.1109/FOCS.2013.84.
  • [12] Amos Fiat and Moni Naor. Rigorous time/space tradeoffs for inverting functions. In Cris Koutsougeras and Jeffrey Scott Vitter, editors, Proceedings of the 23rd Annual ACM Symposium on Theory of Computing, May 5-8, 1991, New Orleans, Louisiana, USA, pages 534–541. ACM, 1991. doi:10.1145/103418.103473.
  • [13] Jörg Flum, Martin Grohe, and Mark Weyer. Bounded fixed-parameter tractability and log2n nondeterministic bits. In Josep Díaz, Juhani Karhumäki, Arto Lepistö, and Donald Sannella, editors, Automata, Languages and Programming: 31st International Colloquium, ICALP 2004, Turku, Finland, July 12-16, 2004. Proceedings, volume 3142 of Lecture Notes in Computer Science, pages 555–567. Springer, 2004. doi:10.1007/978-3-540-27836-8_48.
  • [14] Oded Goldreich and Leonid A Levin. A hard-core predicate for all one-way functions. In Proceedings of the twenty-first annual ACM symposium on Theory of computing, pages 25–32, 1989. doi:10.1145/73007.73010.
  • [15] Judy Goldsmith, Matthew A. Levy, and Martin Mundhenk. Limited nondeterminism. SIGACT News, 27(2):20–29, 1996. doi:10.1145/235767.235769.
  • [16] Iftach Haitner, Danny Harnik, and Omer Reingold. On the power of the randomized iterate. In Annual International Cryptology Conference, pages 22–40. Springer, 2006. doi:10.1007/11818175_2.
  • [17] Johan Håstad, Russell Impagliazzo, Leonid A Levin, and Michael Luby. A pseudorandom generator from any one-way function. SIAM Journal on Computing, 28(4):1364–1396, 1999. doi:10.1137/S0097539793244708.
  • [18] Alexander Healy, Salil P. Vadhan, and Emanuele Viola. Using nondeterminism to amplify hardness. In László Babai, editor, Proceedings of the 36th Annual ACM Symposium on Theory of Computing, Chicago, IL, USA, June 13-16, 2004, pages 192–201. ACM, 2004. doi:10.1145/1007352.1007389.
  • [19] Martin E. Hellman. A cryptanalytic time-memory trade-off. IEEE Trans. Inf. Theory, 26(4):401–406, 1980. doi:10.1109/TIT.1980.1056220.
  • [20] Lane A. Hemaspaandra and Mitsunori Ogihara. The Complexity Theory Companion. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2002. doi:10.1007/978-3-662-04880-1.
  • [21] Shuichi Hirahara, Rahul Ilango, and R. Ryan Williams. Beating brute force for compression problems. In Bojan Mohar, Igor Shinkar, and Ryan O’Donnell, editors, Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 659–670. ACM, 2024. doi:10.1145/3618260.3649778.
  • [22] Richard M. Karp and Richard J. Lipton. Some connections between nonuniform and uniform complexity classes. In Raymond E. Miller, Seymour Ginsburg, Walter A. Burkhard, and Richard J. Lipton, editors, Proceedings of the 12th Annual ACM Symposium on Theory of Computing, April 28-30, 1980, Los Angeles, California, USA, pages 302–309. ACM, 1980. doi:10.1145/800141.804678.
  • [23] Chandra M. R. Kintala and Patrick C. Fischer. Computations with a restricted number of nondeterministic steps (extended abstract). In John E. Hopcroft, Emily P. Friedman, and Michael A. Harrison, editors, Proceedings of the 9th Annual ACM Symposium on Theory of Computing, May 4-6, 1977, Boulder, Colorado, USA, pages 178–185. ACM, 1977. doi:10.1145/800105.803407.
  • [24] Noam Mazor and Rafael Pass. Counting unpredictable bits: a simple prg from one-way functions. In Theory of Cryptography Conference, pages 191–218. Springer, 2023. doi:10.1007/978-3-031-48615-9_7.
  • [25] Noam Mazor and Rafael Pass. The non-uniform perebor conjecture for time-bounded kolmogorov complexity is false. In Venkatesan Guruswami, editor, 15th Innovations in Theoretical Computer Science Conference, ITCS 2024, January 30 to February 2, 2024, Berkeley, CA, USA, volume 287 of LIPIcs, pages 80:1–80:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.ITCS.2024.80.
  • [26] Christos H. Papadimitriou and Mihalis Yannakakis. The complexity of facets (and some facets of complexity). In Harry R. Lewis, Barbara B. Simons, Walter A. Burkhard, and Lawrence H. Landweber, editors, Proceedings of the 14th Annual ACM Symposium on Theory of Computing, May 5-7, 1982, San Francisco, California, USA, pages 255–260. ACM, 1982. doi:10.1145/800070.802199.
  • [27] Luca Trevisan and Salil P. Vadhan. Extracting randomness from samplable distributions. In 41st Annual Symposium on Foundations of Computer Science, FOCS 2000, Redondo Beach, California, USA, November 12-14, 2000, pages 32–42. IEEE Computer Society, 2000. doi:10.1109/SFCS.2000.892063.
  • [28] Salil Vadhan and Colin Jia Zheng. Characterizing pseudoentropy and simplifying pseudorandom generator constructions. In Proceedings of the forty-fourth annual ACM symposium on Theory of computing, pages 817–836, 2012. doi:10.1145/2213977.2214051.
  • [29] Ryan Williams. Improving exhaustive search implies superpolynomial lower bounds. In Leonard J. Schulman, editor, Proceedings of the 42nd ACM Symposium on Theory of Computing, STOC 2010, Cambridge, Massachusetts, USA, 5-8 June 2010, pages 231–240. ACM, 2010. doi:10.1145/1806689.1806723.
  • [30] Ryan Williams. Non-uniform ACC circuit lower bounds. In Proceedings of the 26th Annual IEEE Conference on Computational Complexity, CCC 2011, San Jose, California, USA, June 8-10, 2011, pages 115–125. IEEE Computer Society, 2011. doi:10.1109/CCC.2011.36.
  • [31] Andrew C Yao. Theory and application of trapdoor functions. In 23rd Annual Symposium on Foundations of Computer Science (SFCS 1982), pages 80–91. IEEE, 1982.