List approximation for increasing Kolmogorov complexity

It is impossible to effectively modify a string in order to increase its Kolmogorov complexity. But is it possible to construct a few strings, not longer than the input string, so that most of them have larger complexity? We show that the answer is yes. We present an algorithm that on input a string $x$ of length $n$ returns a list with $O(n^2)$ many strings, all of length $n$, such that 99\% of them are more complex than $x$, provided the complexity of $x$ is less than $n - \log \log n - O(1)$. We obtain similar results for other parameters, including a polynomial-time construction.


Introduction
The Kolmogorov complexity of a binary string x, denoted C(x), is the minimal description length of x, i.e., it is the length of a shortest program (in a fixed universal programming system) that prints x. We analyze the possibility of modifying a string in an effective way in order to obtain a string with higher complexity, without increasing its length. Strings with high complexity exhibit good randomness properties and are potentially useful because they can be employed in lieu of random bits in probabilistic algorithms. It is common to define the randomness deficiency of x as the difference |x|− C(x) (where |x| is the length of x), and to say that the smaller the randomness deficiency is, the more random is the string. In this sense, we want to modify a string so that it becomes "more" random. As stated, the above task is impossible because clearly any effective modification cannot increase Kolmogorov complexity (at least not by more than a constant): If f is a computable function, C(f (x)) ≤ C(x) + O(1), for every x. Consequently we have to settle for a weaker solution, and the one we consider is that of list-approximation. List approximation consists in the construction of a list of objects guaranteed to contain at least one element having the desired property. Actually, we try to obtain a stronger type of list approximation, in which, not just one, but most of the elements in the list have the desired property. More precisely, we study the following question: Question. Is there a computable function which takes as input a string x and outputs a short list of strings, which are not longer than x, such that most of the list's elements have complexity greater than C(x)?
Without the restriction that the length is not increased, the problem is easy to solve by appending a random string (see the discussion in Section 2). The restriction not only makes the problem interesting, but also amenable to applications in which the input string and the modified strings need to be in a given finite set. The solution that we give can be readily adjusted to handle this case.
The problem of increasing Kolmogorov complexity has been studied before by Buhrman, Fortnow, Newman, and Vereshchagin [3]. They show that there exists a polynomial-time computable f that on input x of length n returns a list of strings, all having length n, such that if C(x) < n, then there exists y in the list with C(y) > C(x) (this is Theorem 14 in [3]). In the case of complexity conditioned by the string length, they show that it is even possible to compute in polynomial time a list of constant size. That is f (x) is a list with O(1)-many strings of length n and if C(x | n) < n, then it contains a string y with C(y | n) > C(x | n) (this is Theorem 11 in [3]).
As indicated above we are after a stronger type of list approximation: We want on input x and δ > 0 to construct a short list of strings not longer than x with the property that a fraction of (1 − δ) of its elements have complexity larger than that of x. There are several parameters to consider. The first one is the size of the list. The shorter is the list, the better is the approximation. Next, the increasing-complexity procedure that we seek will not work for all strings x. Recall that C(x) ≤ |x| + O (1) and if x is a string of maximal complexity at its length, then there simply is no string of larger complexity at its length. In general, for strings x that have complexity close to |x|, it is difficult to increase their complexity. Thus, a second parameter is the bound on the complexity of x for which the increasing-complexity procedure succeeds. The closer this bound is to |x|, the better is the procedure. The third parameter is the complexity of the procedure. The procedure is required to be computable, but it is preferable if it is computable in polynomial time.
We show the following three results, each one beating the other two with respect to one of these three parameters. The first result exhibits a computable list-approximation for increasing Kolmogorov complexity that works for any x with complexity C(x) < |x| − log log |x| − O(1). Theorem 1.1 (Computable list of polynomial size for increasing Kolmogorov complexity). There exists a computable function f that on input x ∈ {0, 1} * and a rational number δ > 0, returns a list of strings of length |x| with the following properties: in the list f (x) have Kolmogorov complexity larger than C(x) (where the constant hidden in O(1) depends on δ).
Note. In a previous version of this work (Proceedings STACS 2017) it is claimed that the above theorem holds for all strings x with C(x) < x. The proof had a bug, and we can only prove the version above which holds for all x with C(x) < |x| − log log |x| − O(1).
Whether the bound C(x) < |x| − log log |x| − O(1) can be improved remains open. In the next result, we improve the list size, making it linear in |x| (for constant δ). The price is that the procedure works only for strings x with a slightly lower complexity. Theorem 1.2 (Computable list of linear size for increasing Kolmogorov complexity). There exists a computable function f that on input x ∈ {0, 1} * and a rational number δ > 0, returns a list of strings of length |x| with the following properties: 1. The size of the list is O(|x|)poly(1/δ), Further reducing the list size remains an interesting open question. We could not establish a lower bound, and, as far as we currently know, it is possible that even constant list size may be achievable.
In the next result, the complexity-increasing procedure runs in polynomial time in the following sense. The size of the list is only quasi-polynomial, but each string in the list is computed in polynomial time. Note that the procedure in Theorem 1.3 can be readily converted into a polynomial-time probabilistic algorithm, which uses O(log 3 |x|) random bits to pick at random which element from the list to return. This paper is inspired by recent list approximation results regarding another problem in Kolmogorov complexity, namely the construction of short programs (or descriptions) for strings. We recall the standard setup for Kolmogorov complexity, which we also use here. We fix an universal Turing machine U . The universality of U means that for any Turing machine M , there exists a computable "translator" function t, such that for all strings p, M (p) = U (t(p)) and |t(p)| ≤ |p| + O(1). For the polynomial-time constructions we also require that t is polynomial-time computable. If U (p) = x, we say that p is a program (or description) for x. The Kolmogorov complexity of the string x is C(x) = min{|p| | p is a program for x}. If p is a program for x and |p| ≤ C(x) + c, we say that p is a c-short program for x. Using a Berry paradox argument, it is easy to see that it is impossible to effectively construct a shortest program for x (or, even a, say, n/2-short program for x). Remarkably, Bauwens et al. [1] show that effective list approximation for short programs is possible: There is an algorithm that, for some constant c, on input x, returns a list with O(|x| 2 ) many strings guaranteed to contain a c-short program for x. They also show a lower bound: The quadratic size of the list is minimal up to constant factors. Teutsch [8] presents a polynomialtime algorithm with similar parameters, except that the list size is larger than quadratic, but still polynomial. The currently shortest list size for a polynomial time list approximation is given by Zimand [11]. Closer to the stronger type of list approximation in this paper, are the probabilistic list approximation results for short programs from Bauwens and Zimand [2] and Zimand [12]. A polynomial-time probabilistic algorithm from [2], on input (x, k) returns a string p of length bounded by k + O(log 2 n) such that, if the promise k = C(x) holds, then, with 0.99 probability, p is a program for x. In [12], it is shown that the promise can be relaxed to k ≥ C(x). The survey paper [9] presents most of these results. In this paper, we build on the techniques in [2,12].

Techniques and proof overview
We start by explaining why an approach that probably first comes to mind cannot lead to a result with good parameters, such as those obtained in Theorem 1.1 with a more complicated argument.
Given that we want to modify a string x so that it becomes more complex, which in a sense means more random, a simple idea is to just append a random string z to x. Indeed, if we consider strings z of length c, then C(xz) > C(x) + c/2, for most strings z, provided c is large enough. Let us see why this is true. Let k = C(x) and let z be a string that satisfies the opposite inequality, that is Given a shortest program for xz and a self-delimited representation of the integer c, which is 2 log c bits long, we obtain a description of x with at most k + c/2 + 2 log c bits. Note that from different z's satisfying (1), we obtain in this way distinct (c/2 + 2 log c)-short programs for x. By a theorem of Chaitin [4] (also presented as Lemma 3.4.2 in [5]), for any d, the number of d-short programs for x is bounded by O(2 d ). Thus the number of strings z satisfying (1) is bounded by O(2 c/2+2 log c ). Since for large c, O(2 c/2+2 log c ) is much smaller than 2 c , it follows that most strings z of length c satisfy the claimed inequality (the opposite of (1)). Therefore, in this way we can obtain a list with a constant number of strings and most of them have complexity larger than C(x). The problem with appending a random z to x, is that this operation not only increases complexity (which is something we want) but also increases length (which is something we don't want). The natural way to get around this problem is to first compress x to close to minimal description length using the probabilistic algorithms from [2,12] described in the Introduction, and then to append z. However, the algorithms from [2,12] compress x to length C(x) + O(log n), where n is the length of x. After appending a random z of length c, we obtain a string of length C(x) + O(log n) + c, and for this to be n (so that length is not increased), we need Thus, in this way we cannot obtain a procedure that works for all x with C(x) < n − log log n − O(1), such as the one from Theorem 1.1. Our solution is based on a more elaborate construction. The centerpiece is a type of bipartite graph with a low congestion property. Once we have the graph, we view x as a left node, and the list f (x) consists of some of the nodes at distance 2 in the graph from x. (A side remark: Buhrman et al. [3] use graphs as well, namely constant-degree expanders, and they obtain the lists also as the set of neighbors at some given distance.) In our graph, the left side is L = {0, 1} n , the set of n-bit strings, the right side is R = {0, 1} m , the set of m-bit strings, and each left node has degree D. The graphs also depend on three parameters ǫ, ∆, and t, and for our discussion it is convenient to also use δ = ǫ 1/2 and s = δ · ∆. The graphs that we need have two properties. The first one is a low congestion requirement which demands that for every subset B of left nodes of size at most 2 t , (1 − δ) fraction of nodes in B share (1 − δ) fraction of their right neighbors with at most s other nodes in B. 1 The second property is that each right node has at least ∆ neighbors.
Let us now see how to use such graphs to increase Kolmogorov complexity in the list-approximation sense. Suppose we have a graph G with the above properties for the parameters n, δ, ∆, D, s, and t. We claim that for each x of length n and with complexity C(x) < t, we can obtain a list with D · ∆ many strings, all having length n, such that at least a fraction of (1 − 2δ) of the strings in the list have complexity larger than C(x). Indeed, let x be a string of length n with C(x) = k < t. Consider the set Note that the size of B is bounded by 2 t . A node that does not have the low-congestion property is said to be δ-BAD(B). By the low-congestion of G, there are at most δ|B| elements in B that are δ-BAD(B). It can be shown that x is not δ-BAD(B). The reason is, essentially, that the strings that are δ-BAD(B) can be enumerated and they make a small fraction of B and therefore can be described with less than k bits. Now, to construct the list, we view x as a left node in G and we "go-right-then-go-left." This means that we first "go-right," i.e., we take all the D neighbors of x, and for each such neighbor y we "go-left," i.e., we take ∆ of the y's neighbors and put them in the list. Since x is not δ-BAD(B), (1 − δ)D of its neighbors have at most s = δ · ∆ elements in B. Overall, only 2δ · D · ∆ of the strings in the list can be in B, and so at least a fraction of (1 − 2δ) of the strings in the list have complexity larger than k = C(x). Our claim is proved.
For our main results (Theorem 1.1, Theorem 1.2, and Theorem 1.3), we need graphs with the above properties for different settings of parameters. Such graphs can be obtained from randomness extractors, which have been extensively studied in the theory of pseudo-randomness (for example, see Vadhan's monograph [10]). The graphs required by Theorem 1.1 and Theorem 1.2 are constructed using the probabilistic method in Lemma 3.2, and the graph required by Theorem 1.3 is obtained in Lemma 3.3 from a randomness extractor of Raz, Reingold, and Vadhan [7].

Balanced graphs
We define here formally the type of graphs that we need. We work with families of graphs G n = (L, R, E ⊆ L × R), indexed by n, which have the following structure: 1. Vertices are labeled with binary strings: where we view L as the set of left nodes, and R as the set of right nodes. The parameter a can be positive or negative, and in absolute value is typically small (less than poly(log n)).
2. All left nodes have the same degree D, D = 2 d is a power of two, and the edges outgoing from a left node x are labeled with binary strings of length d.
3. We allow multiple edges between two nodes. For a node x, we write N (x) for the multiset of x's neighbors, each element being taken with the multiplicity equal to the number of edges from x landing into it.
A bipartite graph of this type can be viewed as a function EXT : where EXT(x, y) = z iff there is an edge between x and z labeled y. We want EXT to yield a (k, ǫ) randomness extractor whenever we consider the modified function EXT k which on input (x, y) returns EXT(x, y) from which we cut the last n − k bits. Note that the output of EXT k has k − a bits.
From the function EXT k , we go back to the graph representation, and we obtain the "prefix" bipartite graph G n,k = (L = {0, 1} n , R k = {0, 1} k−a , E k ⊆ L × R k ), where in G n,k we merge the right nodes of G n that have the same prefix of length k − a. Since we allow multiple edges between nodes, the left degrees in the prefix graph do not change. However, right degrees may change, and as m k gets smaller, right degrees typically get larger due to merging.
The requirement that G n,k is a (k, ǫ) randomness extractor means that for every subset B ⊆ L of size |B| ≥ 2 k , for every A ⊆ R k , where E k (B, A) is the set of edges between B and A in G n,k .
We also want to have the guarantee that each right node in G n,t has degree at least ∆, where ∆ and t are parameters.
Accordingly, we have the following definition.
Definition 3.1. A graph G n = (L, R, E ⊆ L × R) as above is (ǫ, ∆, t)balanced if the following requierments hold: 1. For every k ∈ {1, . . . , n}, let G n,k be the graph corresponding to EXT k described above. We require that, for every k ∈ {1, . . . , n}, G n,k is a (k, ǫ) extractor, i.e., G n,k has the property in Equation (2). 2. In the graph G n,t , every right node with non-zero degree has degree at least ∆.
In our applications, we need balanced graphs in which the neighbors of a given node can be found effectively, or even in time that is polynomial in n. As usual, we consider families of graphs (G n ) n≥1 , and we say that such a family is computable if there is an algorithm that on input (x, y), where x is a left node, and y is the label of an edge outgoing from x, outputs z, where z is the right node where the edge y lands. If the algorithm runs in time polynomial in n, we say that the family (G n ) n≥1 is explicit. For polynomial-time list approximation, we actually need a stronger property which essentially states that going from right to left can also be done in polynomial time (see the "Moreover..." part in Lemma 3.3).
The following two lemmas provide the balanced graphs that are used in the proofs of the main result as explained in the proof overview in Section 2. The proof of Lemma 3.2 is by the standard probabilistic method, and is presented in Section 5.1. Moreover, there is an algorithm that on input (z, y) (and n), where z ∈ R = {0, 1} m and y ∈ {0, 1} d computes a list of ∆ left neighbors of z reachable from z by edges labeled y, or NIL if there are less than ∆ such neighbors. This algorithm computes the list implicitly, in the sense that given an index i, it returns the i-th element in the list in time polynomial in n and log i.

The proof of Lemma 3.3 is based on a randomness extractor of Raz,
Reingold, and Vadhan [7] and is presented in Section 5.2.
Let us now proceed to the proofs of Theorem 1.  The theorems have essentially identical proofs, except that balanced graphs with different parameters are used. The following lemma shows a generic transformation of a balanced graph into a function that on input x produces a list so that most of its elements have complexity larger than C(x).
Lemma 4.1. Suppose that for every constant δ > 0, there is t = t(n), a = a(n), and a computable (respectively, explicit and satisfying the property stated in the "moreover" part of Lemma 3 where D is the left degree. Then there exists a computable (respectively, polynomial-time computable) function f that on input a string x and a rational number δ > 0 returns a list containing strings of length |x| and 1. The size of the list is 2(1/δ) 3 D 2 2 a , 2. If C(x) ≤ t, then (1 − 2δ) of the elements in the list have complexity larger than C(x).
Proof of Lemma 4.1.
We can assume without loss of generality that 1/δ is sufficiently large (for the following arguments to be valid) and also that it is a power of 2. Let ǫ = δ 2 . Let x be a binary string of length n, with complexity C(x) = k. We assume that k ≤ t. We explain how to compute the list f (x), with the property stipulated in the theorem's statement.
We take G n to be the (ǫ, ∆, t)-balanced graph with left nodes of length n promised by the hypothesis. Let G n,t be the "prefix" graph obtained from G n by cutting the last n − t bits in the labels of right nodes (thus preserving the prefix of length t − a in the labels).
The list f (x) is computed in two steps: 1. First, we view x as a left node in G n,t and take N (x), the multiset of all neighbors of x in G n,t .
2. Secondly, for each p in N (x), we take A p to be a set of ∆ neighbors of p in G n,t (say, the first ∆ ones in some canonical order). We set f (x) = p∈N (x) A p (if p appears n p times in N (x), we take A p in the union also n p times; note that f (x) is a multiset).
Note that all the elements in the list have length n, and the size of the list is |f (x)| = ∆ · D = (1/δ) 3 D 2 2 a . The rest of the proof is dedicated to showing that the list f (x) satisfies the second item in the statement. Let and let S n,k = ⌊log |B n,k |⌋. Thus, 2 S n,k ≤ |B n,k | < 2 S n,k +1 . Later we will use the fact that S n,k ≤ k ≤ t.
We want to use the properties of extractors for sources with min-entropy S n,k and therefore we consider the graph G n,S n,k , which is obtained, as we have explained above, from G n by taking the prefixes of right nodes of length S n,k − a. To simplify notation, we use G instead of G n,S n,k . The set of left nodes in G is L = {0, 1} n and the set of right nodes in G is R = {0, 1} m , for m = S n,k − a.
We view B n,k as a subset of the left nodes in G. Let us introduce some helpful terminology. In the following all the graph concepts (left node, right node, edge, neighbor) refer to the graph G. We say that a right node z in G is (1/ǫ)-light if it has at most (1/ǫ) · |B n,k |·D |R| neighbors in B n,k . A node that is not (1/ǫ)-light is said to be (1/ǫ)-heavy. Note that and thus an (1/ǫ)-light node has at most δ∆ many neighbors in B n,k . We also say that a left node in B n,k is δ-BAD with respect to B n,k if at least a δ fraction of the D edges outgoing from it land in right neighbors that are (1/ǫ)-heavy. Let δ-BAD(B n,k ) be the set of nodes that are δ-BAD with respect to B n,k .
We show the following claim. (In other words: for every x ′ in B n,k , except at most a 2δ fraction, at least a (1 − δ) fraction of the edges going out from x ′ in G land in right nodes that have at most ∆ ′ neighbors with complexity at most k.) We defer for later the proof of Claim 4.2, and continue the proof of the theorem.
For any positive integer k, let Let I k = {n | k ≤ t(n)}. Note that |B k | = n∈I k |B n,k |. Let x ′ ∈ B k , and let n ′ = |x ′ |. We say that x ′ is δ-BAD with respect to B k if in G n ′ , x ′ is δ-BAD with respect to B n ′ ,k . We denote δ-BAD(B k ) the set of nodes that are δ-BAD with respect to B k . We upper bound the size of δ-BAD(B k ): Note that the set δ-BAD(B k ) can be enumerated given k and δ. Therefore a node x ′ that is δ-BAD with respect to B k can be described by k, δ and its ordinal in the enumeration of the set δ-BAD(B k ). We write the ordinal on exactly k+2−log(1/δ) bits and δ in a self-delimited way on 2 log log(1/δ) bits (recall that 1/δ is a power of 2), so that k can be inferred from the ordinal and δ. It follows that if x ′ is δ-BAD with respect to B k , then, provided 1/δ is sufficiently large, Now, recall our string x ∈ {0, 1} n which has complexity C(x) = k. The inequality (4) implies that x cannot be δ-BAD with respect to B k , which means that (1 − δ) of the edges going out from x land in neighbors in G having at most δ∆ neighbors in B k . The same is true if we replace G by G n,t , because, by the inequality (3), right nodes in G are prefixes of right nodes in G n,t . Now suppose we pick at random a neighbor p of x in G n,t , and then find a set A p of ∆ neighbors of p in G n,t . Then with probability 1 − δ, only a fraction of δ of the elements of A p can be in B k . Recall that we have defined the list f (x) to be It follows that (1 − 2δ) of elements in f (x) have complexity larger than C(x) and this ends the proof.
It remains to prove Claim 4.2.
Proof of Claim 4.2. Let A be the set of right nodes that are (1/ǫ)-heavy. Then |A| ≤ ǫ|R|.
Indeed the number of edges between B n,k and A is at least |A|·(1/ǫ)· |B n,k |·D |R| (by the definition of (1/ǫ)-heavy), but at the same time the total number of edges between B n,k and R is |B n,k | · D (because each left node has degree D).
Next we show that For this, note that G is a (S n,k , ǫ) randomness extractor and B n,k has size at least 2 S n,k . Therefore by the property (2) of extractors, On the other hand the number of edges linking B n,k and A is at least the number of edges linking δ-BAD(B n,k ) and A and this number is at least |δ-BAD(B n,k | · δD. Thus, Combining the last two inequalities, we obtain End of the proofs of Claim 4.2 and of Lemma 4.1. Theorem 1.1, Theorem 1.2 , and Theorem 1.3 are obtained by plugging, respectively, into the above lemma the balanced graphs from Lemma 3.2 (a), Lemma 3.2 (b) and Lemma 3.3, with parameter ǫ = δ 2 in every case.

Proof of Lemma 3.2.
We first prove part (b), since we can give a self-contained and elementary argument . We use the probabilistic method. For some constant c that will be fixed later, we consider a random function EXT : {0, 1} n × {0, 1} d → {0, 1} n+d−2 log(1/ǫ)−c . We show the following two claims, which imply that a random function has the desired properties with positive probability. Since the properties can be checked effectively, we can find a graph as stipulated in part (b) by exhaustive search. We use the notation from Definition 3.1 and from the paragraph preceding it.
Claim 5.1. For some constant c, with probability ≥ 3/4, it holds that for every k ∈ {1, . . . , n}, in the bipartite graph G n, Claim 5.2. For every sufficiently large positive integer n, with probability ≥ 3/4, every right node in the graph G n,n−log n−log log n has degree at least ∆.
Proof of Claim 5.1. First we fix k ∈ {1, . . . , n} and let K = 2 k and N = 2 n . Let us consider B ⊆ {0, 1} n of size |B| ≥ K, and A ⊆ R k . For a fixed x ∈ B and y ∈ {0, 1} d , the probability that EXT k (x, y) is in A is |A|/|R k |. By the Chernoff bounds, The probability that relation (6) fails for a fixed k, some B ⊆ {0, 1} k of size |B| ≥ K and some A ⊆ R k is bounded by 2 K·D·ǫ 2 ·2 −c · N K · 2 −Ω(K·D·ǫ 2 ) , because A can be chosen in 2 K·D·ǫ 2 ·2 −c ways, and we can consider that B has size exactly K and there are N K possible choices of such B's. If D = Ω((n − k)/ǫ 2 ) and c is sufficiently large, the above probability is much less than (1/4)2 −k . Therefore the probability that relation (6) fails for some k, some B and some A is less than 1/4.
Proof of Claim 5.2. We use a standard "coupon collector" argument. Let t = n − log n − c ′ , where c ′ is a constant that will be fixed later. Let N = 2 n and C = 2 c , where c is the constant for which Claim 5.1 holds.. We work in the bipartite graph G n,n−log n−c ′ = (L, R, E ⊆ L × R) in which every left node has degree D = 2 d , L = {0, 1} n , and . For a left node x, an edge labeled y ∈ {0, 1} d and a right node z, we say that (x, y) hits z if the ylabeled edge outgoing from x lands in z. We want to show that with high probability each z is hit at least ∆ times. Let us order {0, 1} n × {0, 1} d in, say, lexicographical order {(x, y) 1 < (x, y) 2 < . . . < (x, y) N D }. We define ∆ groups of "shooting" at R by taking (x, y) 1 , . . . , (x, y) r in the first group, (x, y) r+1 , . . . , (x, y) 2r in the second group, and so on with r left nodes in each group, where r will be fixed later. The probability that a fixed z is not hit by some (x, y) i is (1 − 1/|R|) ≤ e −1/|R| . The probability that a fixed z is not hit by any element in a given group is at most e −r/|R| and the probability that there exists some z ∈ R that is not hit by a given group is bounded by |R|e −r/|R| . We take r = |R|(ln |R| + ln(4∆)), and the above probability is bounded by 1/(4∆). Therefore, the probability that some z in R is not hit by some group in the set of ∆ groups is at most 1/4. Note that, for some appropriate choice of c ′ , r · ∆ ≤ N D, provided n is large enough, and thus all the groups fit into {0, 1} n × {0, 1} d .
Part (a). Similarly to part (b), we take a random function EXT : {0, 1} n × {0, 1} d → {0, 1} n . The analogue of Claim 5.1 holds true in the same way since the only modification is that this time R k = {0, 1} k . The "coupon collector" argument needed to prove the analogue of Claim 5.2 is done as follows. We consider the graph G n,n−log log n−c for some constant c that will be fixed later. This graph is obtained from the above function EXT as explained in Definition 3.1. The graph G n,n−log log n−c is a bipartite graph with left side L = {0, 1} n , right side R ′ = {0, 1} n−log log n−c and each left node has degree D = 2 d . We show that with probability ≥ 3/4, every right node in G n,n−log log n−c has degree at least ∆. The random process consists of drawing for each x ∈ L and edge y ∈ {0, 1} d a random element from R ′ . Thus we draw at random N D times, with replacement, from a set with |R| ′ many "coupons." Newman and Shepp [6] have shown that to obtain at least h times each coupon from a set of p coupons, the expected number of draws is p log p + (h − 1)p log log p + o(p). By Markov's inequality, if the number of draws is 4 times the expected value, we collect each coupon p times with probability 3/4. In our case, we have p = 2 n−log log n−c and h = ∆ and it can be checked readily that, for an appropriate choice of the constant c, 4(p log p + (h − 1)p log log p + o(p)) < N D, provided n is large enough.
End of the proof of Lemma 3.2.

Proof of Lemma 3.3.
The construction relies on the randomness extractor of Raz, Reingold, and Vadhan [7]. (1) d = O(log 3 (n) log 2 (1/ǫ)), (2) m = n − c · d, for some constant c, (3) For every k ≤ n, the function EXT k obtained by computing EXT and cutting the last n − k bits of the output is a (k, ǫ) extractor, (4) For every y ∈ {0, 1} d(n) , the function f y (x) = EXT(x, y) is a linear function from (GF [2]) n to (GF [2]) m (where we view x ∈ {0, 1} n as an element of (GF [2]) n in the natural way). In other words, EXT(x, y) = A y ·x, where A y is an m-by-n matrix with entries in GF [2], computable from y in time polynomial in n.
Note. Item (4) is not explicitly stated in [7], so we provide here a short explanation. The construction given in [7] of EXT : {0, 1} n ×{0, 1} d → {0, 1} m , views x as the specification of a function u x (·, ·) of two variables (in a way that we present below), defines some functions g 1 (y), h 1 (y), . . . , g m (y), h m (y), each one computable in time polynomial in n, and then sets EXT(x, y) = u x (g 1 (y), h 1 (y)), . . . , u x (g m (y), h m (y)), i.e., the i-th bit is u x (g i (y), h i (y)). Thus, it is enough to check that f v,w (x) = u x (v, w) is linear in x. Let us now describe u x . The characteristic sequence of u x is the Reed-Solomon code of x. More precisely, for some s, x is viewed as a polynomial p x over the field GF[2 s ]. The elements of GF [2 s ] are viewed as s-dimensional vectors over GF [2] in the natural way. Note that in this view the evaluation of p x at point v is a linear transformation of x, i.e., p x (v) = A v x for some s-by-n matrix A v with entries from GF [2]. Finally, u x (v, w) is defined as the inner product w · p x (v) and therefore u x (v, w) = (wA v )x, and thus it is a linear function in x. Now we plug h i (y) as w and g i (y) as v, and we build the matrix A y , by taking its i-th row to be h i (y)A g i (y) . Using the Equation (7), we obtain item (4) in the theorem. Now let us proceed to the actual proof of Lemma 3.3. The function EXT from Theorem 5.3 defines the explicit bipartite graph G n . Let t = n − (log ∆ − c · d). By removing the last n − t bits in each right node we obtain the graph G n,t . We only need to check that in the bipartite graph G n,t = (L t = {0, 1} n , R t = {0, 1} mt , E t ⊆ L t × R t ) (where m t = n − log ∆), every right node with non-zero degree has degree at least ∆. This follows easily from the linearity of EXT t (x, y) defined to be EXT(x, y) from which we cut the last n − t bits.
Indeed, let z in {0, 1} mt be a right node with non-zero degree. This means that there exist x and y such that EXT t (x, y) = z. Since the function f y (x) = EXT t (x, y) is linear in x, it follows that {x ′ | EXT(x ′ , y) = z} = {x ′ | A y · x ′ = z} (i.e., the preimage of z) is an affine space over GF [2] with dimension at least n − m t = log ∆, and therefore z has degree at least ∆. Moreover, given y, we can find ∆ preimages of z in time polynomial in n, by solving the linear system.

Acknowledgments
The author is grateful to Bruno Bauwens for his insightful observations. He is also grateful to Nikolay Vereshchagin for pointing out an error in an earlier version.