Y. Yu et al. / Theoretical Computer Science 569 (2015) 58–69 59
plifying and improving the constructions, and the current state-of-the-art construction [5] requires seed length O (n
3
). Let
us mention that all aforementioned approaches are characterized by a parallel construction, namely, they run sufficiently
many independent copies of the underlying OWFs (rather than running a single trail and feeding its output back to the
input iteratively) and there seems an inherent lower bound on the number of copies needed. This is recently formalized
by Holenstein and Sinha [6], in particular, they showed that any black-box construction of a PRG from an arbitrary OWF f
requires
Ω(n/ log n) calls to f in general.
2
PRGs from special OWFs. Another line of research focuses on OWFs with special structures that give rise to more effi-
cient PRGs.
Blum, Micali [7] and Yao [8] independently introduced the notion of PRGs, and observed that PRGs can be
efficiently constructed from one-way permutations (OWPs). That is, given an OWP f on input x and its hardcore function h
c
(e.g. by Goldreich and Levin [9]), a single invocation of f already implies a PRG g(x) = ( f (x), h
c
(x)) with a stretch
3
of
Ω(log n) bits and it extends to arbitrary stretch by repeated iterations (seen by a hybrid argument):
g
(x) =
h
c
(x), h
c
f
1
(x)
,...,h
c
f
(x)
,...
where f
i
(x)
def
= f ( f
i−1
(x)) and f
1
(x)
def
= f (x). The above PRG, often referred to as the BMY generator, enjoys many advantages
such as simplicity, optimal seed length, and minimal number of calls. Levin [10] observed that f is not necessarily an OWP,
but it suffices to be one-way on its own iterate. Unfortunately, an arbitrary OWF doesn’t have this property. Goldreich,
Krawczyk, and Luby [11] assumed known-regular
4
OWFs and gave a construction of seed length O (n
3
) by iterating the
underlying OWFs and applying k-wise independent hashing in between every two iterations. Later Goldreich showed a
more efficient (and nearly optimal) construction from known-regular OWFs in his textbook [12], where in the concrete
security setting the construction does only a single call to the underlying OWF (or ω(1) calls in general). The construction
was also implicit in many HILL-style constructions (e.g. [3,4]). Haitner, Harnik and Reingold [13] refined the technique used
in [11] (which they called the randomized iterate) and adapted the construction to unknown regular OWFs with reduced seed
length O (n ·logn). Informally, the randomized iterate follows the route of [11] and applies a random pairwise independent
hash function h
i
in between every two applications of f , i.e.
f
1
(x)
def
= f (x); for i ≥ 2let f
i
(x;h
1
,...,h
i−1
)
def
= f
h
i−1
f
i−1
(x;h
1
,...,h
i−2
)
.
The key observation is “the last iterate is hard-to-invert” [14], more precisely, function f , when applied to h
i−1
( f
i−1
;
h
1
,..., h
i−2
), is hard-to-invert even if h
1
, ..., h
i−1
are made public. The generator follows by running the iterate O (n/ log n)
times, and outputting Ω(log n) hardcore bits per iteration, which requires seed length O (n
2
/ log n) and can be further
pushed to O (n · log n) using derandomization techniques (e.g., Nisan’s bounded-space generator [15]). The randomized iter-
ate
matches the lower bound on the number of OWF calls,
5
but it remains open if any efficient construction can achieve
linear seed length and O(n/ log n) OWF calls simultaneously.
Summary
of contributions. We contribute an alternative proof for the folklore construction of PRGs from known-regular
OWFs via the notion of unpredictability pseudo-entropy, which significantly simplifies and tightens the proofs in [12]. We
also give a new construction from any unknown-regular one-way function using seed length
˜
O (n) and making
˜
O (n/ log n)
calls, where both parameters are optimal in the concrete security setting and nearly optimal in general (up to an arbitrarily
close to constant factor), and this improves the randomized iterate [14]. We sketch both constructions as follows.
Entropy
observation. We start by assuming a (t, ε)-OWF f (see Definition 2.2) with known regularity 2
k
(i.e., every image
has 2
k
preimages under f ). The key observation is that for uniform X (over {0, 1}
n
) we have X given f (X) has k +log(1/ε)
bits of pseudo-entropy (defined by the game below and formally in Definition 2.5). That is, no adversary A of running time t
can
win the following game against the challenger C with probability greater than (2
−k
·ε). The rationale is that conditioned
on any f (X) = y random variable X is uniformly distributed on the set f
−1
(y)
def
={x : f (x) = y} of size 2
k
, and thus even if
any deterministic (or probabilistic) A recovers an x
∈ f
−1
(y), the probability that X = x
is only 2
−k
.
PRGs
from known-regular OWFs. Given the above observation, we immediately obtain the following folklore construction
using three extractions along with a three-line proof.
• Randomness extraction from f (X). f (X) has min-entropy n − k, and thus we can extract nearly n − k statistically
random bits.
• Randomness extraction from X. X has min-entropy k given any y = f (X), so we can extract another k statistically
random bits.
2
The lower bound of [6] also holds in the concrete security setting, namely, Ω(n/ log(1/ε)) calls from any ε-hard OWF.
3
The stretch of a PRG refers to the difference between output and input lengths (see Definition 3.2).
4
A function f (x) is regular if the every image has the same number (say α) of preimages, and it is known- (resp., unknown-) regular if α is efficiently
computable (resp., inefficient to approximate) from the security parameter.
5
As explicitly stated in [6], the lower bound of Ω(n/ logn) calls also applies to unknown regular OWFs.