aa r X i v : . [ c s . D S ] F e b Online matching in lossless expanders
Marius Zimand * Abstract
Bauwens and Zimand [BZ19] have shown that lossless expanders have an interesting online matchingproperty. The result appears in an implicit form in [BZ19]. We present an explicit version of this propertywhich is directly amenable to typical applications, prove it in a self-contained manner that clarifies therole of some parameters, and give two applications.A ( K, ǫ ) lossless expander is a bipartite graph such that any subset S of size at most K of nodes onthe left side of the bipartition has at least (1 − ǫ ) D | S | neighbors, where D is the left degree.The mainresult is that any such graph, after a slight modification, admits (1 − O ( ǫ ) D, online matching up tosize K . This means that for any sequence S = ( x , . . . , x K ) of nodes on the left side of the bipartition,one can assign in an online manner to each node x i in S a set A i consisting of (1 − O ( ǫ )) fraction of itsneighbors so that the sets A , . . . , A K are pairwise disjoint. “Online manner” refers to the fact that, forevery i , the set of nodes assigned to x i only depends on the nodes assigned to x , . . . , x i − .The first application concerns storage schemes for representing a set S , so that a membership query“Is x ∈ S ?” can be answered probabilistically by reading a single bit. Buhrman, Miltersen, Radhakr-ishnan and Venkatesh [BMRV00] have shown how to design such schemes based on lossless expanders,and, subsequently, other authors have followed the same approach. All the previous one-probe storageschemes were for a static set S . We show that a lossless expander can be used to construct a one-probestorage scheme for dynamic sets, i.e., sets in which elements can be inserted and deleted without affect-ing the representation of other elements. Moreover, our method works with any lossless expander, whileprevious constructions required a lossless expander with a special efficient list-decoding procedure. Thesecond application is about non-blocking networks. This is a graph that contains nonterminal nodes and N terminal nodes, with N of them designated as input terminals, and the other N designated as outputterminals. The objective is, for any K pairs of the form (input terminal, output terminal) defining a -to- relation, to have K vertex-disjoint paths from the input terminal to the output terminal in eachpair. Moreover, the K pairs arrive sequentially one at a time, and the paths have to be found in an onlinemanner. K is a parameter called bandwidth, and another relevant parameter is the depth which is thelength of the longest path from an input terminal to an output terminal. Using a lossless expander, weconstruct a non-blocking network with constant degree and almost quasilinear number of edges for acertain range of the bandwidth, improving previous constructions that had N edges. * Department of Computer and Information Sciences, Towson University, Baltimore, MD. http://orion.towson.edu/˜mzimand ;The author has been supported in part by the National Science Foundation through grant CCF 1811729. Introduction
Expander graphs are sparse and yet highly connected. These two apparently conflicting properties makethem very useful. Avi Wigderson, in his book that comprehensively overviews theoretical computer sci-ence, says that expanders “play key roles in almost every area of theory of computation: algorithms, datastructures, circuit complexity, de-randomization, error-correcting codes, network design , and more. ... Inmathematics, they touch in fundamental ways different subareas in analysis, geometry, topology, algebra,number theory, and of course graph theory. ... Precious few nontrivial mathematical objects can boast a sim-ilar impact!” [Wig19, page 116]. This paper reveals an online matching property of an important type ofexpanders, called lossless expanders, which enhances in a significant way two of the applications mentionedabove (and we hope that the list will grow).A ( K, ǫ ) lossless expander is a bipartite graph G = ( L ∪ R, E ) such that any subset S of size at most K of nodes on the left side of the bipartition has at least (1 − ǫ ) D | S | neighbors, where D is the left degree.Repeated applications of Hall’s Marriage Theorem show that it is possible, for every S as above, to assign toeach node in S a set containing an approximately (1 − ǫ ) fraction of its neighbors so that the sets assigned todifferent nodes in S are pairwise disjoint (see Section 1.2). The newly discovered property is that essentiallythe same can be achieved with assignments made by online matching. The assignment procedure impliedby Hall’s Theorem needs to have the entire S . In contrast, in online matching , the elements of S appearsequentially one at a time, and the sets that are assigned have to be selected before seeing future arrivals. Inother words, for a sequence S = ( x , . . . , x K ) , the set A x i assigned to x i only depends on { x , x , . . . , x i } (see Definition 1.3 for a rigorous formulation). Theorem 1.1 (Online matching in lossless expanders - informal statement. Implicit in [BZ19] ) . Let G =( L ∪ R, E ) be a ( K, ǫ ) lossless expander.(a) For every sequence S of left nodes, having length K , there are sets { A x } x ∈ S assigned online asexplained above, such that each A x contains at least a fraction (1 − O ( ǫ )) of the neighbors of x , andevery node in R belongs to at most O (log | S | ) sets.(b) One can slightly modify G into another graph G ′ , such that for every sequence S of left nodes of G ′ ,of length K , there are pairwise disjoint sets { A x } x ∈ S assigned online as explained above, such thateach A x contains at least a fraction of (1 − O ( ǫ )) neighbors of x in G ′ . If G is explicit, the runtime of the online assignment procedure that assigns A x to x is poly ( K, D, log | L | ) in (a), and poly ( K, D, log | L | , /ǫ ) in (b).Thus, part (a) says that in a lossless expander, for every set S of K left nodes, it is possible to assignin an online manner to each node in S an (1 − O ( ǫ )) fraction of its neighbors, so that an assigned elementis shared with only O (log | S | ) other elements in S , and part (b) says, that with a slight modification of thegraph, no assigned element is shared.The online matching properties of lossless expanders have been observed only very recently by BrunoBauwens and the author [BZ19]. In that paper, the online matching algorithm is tailored for the objectivestherein, and the property appears in an implicit way. We present here a simplified and more natural versionof the online matching algorithm, with a self-contained analysis. Lossless expanders are closely related [BZ19] introduces the concept of an online invertible function (see [BZ19, Def. 2.1]), which for some settings, is equivalent to abipartite graph that has the online matching property. Theorem 1.1(a) follows from Corollary 2.11 in [BZ19], and Theorem 1.1(b)follows from Corollary 2.13 in [BZ19] (see Appendix A). The procedure in [BZ19] that does the matching is viewed from theperspective of a right node that seeks to be assigned to a left node. In this paper we use the reverse perspective and simplify theconditions of online matching and this allows us to give a version of the algorithm that is more natural for many applications ofmatching (like the ones we present in this paper) and that has arguably a simpler analysis. Online matching is used in [BZ19] toefficiently compress (both in the centralized and the distributed scenarios) finite strings down to almost their minimum descriptionlength.
2o lossless condensers [TSUZ07, Th. 8.1], which have been studied in the theory of pseudorandomness.We investigate online matching for general condensers, and the results in Theorem 1.1 are obtained byparticularization to the case of lossless condensers. The main ideas are the same as in [BZ19].The original contributions of the paper are two applications that push boundaries in the study of twobasic and well-investigated problems. The constructions and the proofs are intuitive and simple, the reasonfor this being that most of the job is done by online matching.The first application is about one-probe schemes for the dictionary data structure. The goal is to store asubset S of a large set U (the “universe”). Let N denote the size of U , and K denote the size of S . A simplestorage scheme is to keep in a table a sorted list of the K elements of S . The table is stored on K log N bits, and, for x ∈ U , one can determine if x is in S or not, by reading ⌈ log K ⌉ · ⌈ log N ⌉ bits from the table.An alternative is to have a table of N bits indexed by the elements in U and to set a bit to if and only itsindex is in S . Now the query “Is x ∈ S ?” can be answered by reading a single bit. Also, one can insertor delete an element by modifying a single bit. The cost is that the table is long (taking into account thattypically N ≫ K ). A one-probe storage scheme is a data structure that answers any membership query“Is x in S ?” by reading a single bit. Buhrman, Miltersen, Radhakrishnan, and Venkatesh [BMRV00] haveused lossless expanders to build randomized one-probe storage schemes. They give both non-explicit andexplicit constructions and the size of their non-explicit data structure is O ((1 /ǫ ) K log N ) , where ǫ is theerror probability. Note that K log N is essentially the information-theoretical lower bound for storing theset even without the one-probe restriction. Ta-Shma [Ta-02] and Guruswami, Umans, and Vadhan [GUV09]have obtained improved explicit one-probe storage schemes (see Section 3.1 for parameters and other de-tails). These one-probe storage schemes work for static sets, in the sense that any updating of S requires therecomputation from scratch of the entire data structure. Using the online matching property of lossless ex-panders, we show that each such expander yields a one-probe storage scheme for dynamic sets. This meansthat, when an element x is inserted or deleted, only the bits assigned to x need to be changed in the datastructure, and membership queries for other elements can be answered without locking the data structureduring the update. The size of the data structure depends on K as before, where K is now the total number ofelements inserted in the dynamic set during its entire history. Plugging a condenser from [BZ19] in our con-struction, yields an explicit one-probe storage scheme for dynamic sets with size K O (log log( N/ǫ ) · log log K ) .For most K , this is better than the previous explicit schemes, in spite of the fact that those schemes were onlyhandling static sets. The proof is simpler and, in particular, it is noteworthy that the previous constructionsof explicit one-probe storage schemes required a lossless expander with a special “list-decoding” property(see [GUV09, Th.7.2]), while our approach works with any lossless expander. Consequently, any futureimprovement in the construction of explicit lossless expanders will directly induce better one-probe storageschemes.The second application is about designing non-blocking networks , which, interestingly, has been themotivation for introducing bipartite expanders fifty years ago [BP73]. In the general setting of the problem,the network has N terminals (plus non-terminals nodes as well), with N of them designated as inputterminals, and the other N designated as output terminals, and K is a parameter called bandwidth . Theobjective is, for any K pairs of the form (input terminal, output terminal) defining a -to- relation, to have K vertex-disjoint paths from the input terminal to the output terminal in each pair. If the K pairs are knownahead of time, a graph satisfying the above requirement is called a rearrangeable network , and if the K pairsarrive sequentially and the paths can be found in an online manner, then the graph is called a non-blockingnetwork. The trivial non-blocking network is the complete bipartite graph with N nodes on each side,which has depth , but N edges (the depth is the length of the longest path from an input terminal to anoutput terminal). In our application, we show that any ( K, (1 − ǫ ) D ) expander G = ( L ∪ R, E ) with | L | = N In the literature, these networks are actually called wide-sense nonblocking networks to distinguish them from strictly non-blocking networks , which satisfy a stronger requirement. D yields via a very simple construction a non-blocking network with N D + | R | edges, anddepth . If we use a condenser from [BZ19] and if K = O ( N / ) we obtain a non-blocking network withan almost quasi-linear number of edges, while, as far as we know, previous methods are only able to obtain N many edges for constant-depth non-blocking networks. The online matching of lossless expandersis a quite general tool and by mixing it with known constructions one can obtain non-blocking networkswith other interesting combinations of parameters. Our goal, however, is to just illustrate the method, andwe do not pursue here this line of investigation. We restrict our attention to bipartite graphs G = ( L ∪ R, E ) with left degree D , i.e, the nodes are partitionedinto the set of left nodes L and the set of right nodes R , all edges connect a left node with a right node, andall left nodes are adjacent to exactly D edges. We allow E to be a multiset (i.e., it is possible to have severaledges between two vertices). We label the edges adjacent to a left node x by a value in [ D ] = { , , . . . , D } ,and sometimes we view the graph as a function Γ : L × [ D ] → R defined by Γ( x, y ) = p if ( x, p ) is anedge in G labeled with y . For every node x , we denote by N ( x ) the multiset of neighbors of x . If there are ℓ edges ( x, p ) , then p has multiplicity ℓ in N ( x ) . Thus, for every x ∈ L , the size of N ( x ) is D . For S ⊆ L ,we define the neighborhood set N ( S ) := { v | ∃ u ∈ S, ( u, v ) ∈ E } . For A ⊆ L, B ⊆ R , E ( A, B ) denotesthe multiset of edges ( u, v ) with u ∈ A and v ∈ B , i.e., the multiset of edges that cross from A to B .We use bipartite vertex expanders (see [Vad12, Def. 4.3]), which, henceforth, we simply call expanders. Definition 1.2 ( expander ) . A graph as above is a ( K, γ ) expander if for every set S ⊆ L of size at most K , | N ( S ) | ≥ γ | S | . Thus ( K, (1 − ǫ ) D ) expander is the same notion as ( K, ǫ ) lossless expander, introduced earlier.The number of occurrences of an element in a multiset A is called the multiplicity of the element. Thesize of A , denoted | A | , is the sum of multiplicities. For example, |{ a, a, b }| = 3 . For multisets A, B , A ⊆ B means that the multiplicity of any element in A is at most its multiplicity in B . P ( A ) is the powerset of A and P multi ( A ) is the set of multisets with elements from A . It is useful to have a general version of matching for bipartite graphs, that we dub ( ℓ, r ) matching. Such amatching assigns to every left node at least ℓ of its neighbors, so that every right node is assigned to at most r left nodes. The larger is ℓ and the smaller is r , the stronger is the property of having an ( ℓ, r ) matching.Let us see an example. Let G be a ( K, γD ) expander. Assume that γD ≥ . Let S be a subset ofleft nodes of size at most K . Since | N ( S ′ ) | ≥ | S ′ | for every S ′ ⊆ S , by Hall’s Marriage Theorem, thegraph obtained from G by restricting the left side to S has an exact matching (i.e., there is a subset of | S | edges, defining a 1-to-1 relation). We assign to each node in S , the right node with whom it is matched.By repeating this process ⌊ γD ⌋ rounds (where after each round we remove the right nodes that have beenmatched), we can assign to each node in S , ⌊ γD ⌋ of its neighbors, so that every right node is assigned to atmost one node in S . In other words, G restricted to S has ( γD, matching, for every subset S of K leftnodes.. In particular, a ( K, ǫ ) lossless expander is by definition a ( K, (1 − ǫ ) D ) expander and thus it has thevery strong property of ( ⌊ (1 − ǫ ) D ⌋ , matching when we restrict the left side to S of size K , for any such S . Our main result is that, essentially, the same is true for online matching.We next define online matching in bipartite graphs. We start with an informal discussion, which is meantto help the interpretation of the formal definition. In online matching, a left node may make a request to get We use calligraphic fonts such as E , N to denote multisets. ( ℓ, r ) matching. The assignment requests arrive and our definition also allows that they depart (butin a restricted way), and each request must be satisfied when it arrives before seeing future arrivals. The setassigned to a node must not change between the arrival and the departure time of the node. The requestsare specified by a list S of left nodes, i.e., a sequence S = ( x , . . . , x K ) with every x i ∈ L , which can beupdated as a stack . A “request arrival” means that an element is pushed in S . A “request departure” meansthat an element is popped from S , in the stack manner. Thus, we assume that the top of the stack S is thelast position, and, when a new element x is inserted, S becomes ( x , . . . , x K , x ) , and only the last elementcan be deleted.The formal definition is as follows. Definition 1.3 ( ( ℓ, r ) online matching ) . Let G = ( L ∪ R, E ) be a bipartite graph, K ∈ N , and let L ≤ K denote the set of lists of elements in L of size at most K . The graph G admits ( ℓ, r ) online matching up tosize K if there is a function f : L ≤ K × L → P multi ( R ) such that for every S ∈ L ≤ K and for every x ∈ L ,1. f ( S, x ) ⊆ N ( x ) ,2. If x S , then f ( S, x ) = ∅ ,3. If x ∈ S , then for every list S ′ ∈ L ≤ K that extends S , f ( S, x ) = f ( S ′ , x ) ,4. If x ∈ S , then | f ( S, x ) | ≥ ℓ , and5. For every p ∈ R , |{ x ∈ S | p ∈ f ( S, x ) }| ≤ r . Lists S ∈ L ≤ K are interpreted as snapshots of the stack of requests at various moments. The assignmentfunction f assigns to every left node in S at least ℓ of its neighbors (using multiplicities in the count), andevery right node is assigned to at most r different neighbors.The online matching is stipulated in property(3), which implies that the set of elements assigned to x does not change for the entire lifetime of x in thestack of requests.Online matching is a stronger requirement than offline. For example, the following graph admits (1 , offline matching up to size K = 2 , but not (1 , online matching up to size K = 2 (consider the case when x arrives first, and the second arrival is chosen adversarially after a node was assigned to x ). x x x y y We convert any graph G that admits ( ℓ, r ) online matching to a graph G ′ that admits ( ℓ ′ , online matchingsuch that ℓ/D ≈ ℓ ′ /D ′ ( D and D ′ are the left degrees of G , respectively G ′ ) and without affecting too muchthe left degree and the size of the right side. The idea is to use hashing to distinguish between the left nodesthat share a right node. The G G ′ transformation. Let G = ( L ∪ R, E ) be a graph with left degree D that admits ( ℓ, r ) online matching up to size K . Let n = ⌈ log | L |⌉ and let t be the smallest power of two that is at least (1 /ǫ )( n − r − , for some parameter ǫ > . We use hashing via polynomials of low degree and for this we label all the left nodes by vectors in5 n . We view each x ∈ L as a polynomial of degree at most n − over F t in the natural way, by consideringeach bit in the label of x as a coefficient of the polynomial (the polynomial x has only , coefficients; F and F t are the finite fields with , respectively t elements).We construct the bipartite graph G ′ = ( L ′ ∪ R ′ , E ′ ) . The left side L ′ is L (so, the same left side as G ).The right side is R ′ = R × ( F t ) . The multiset of edges E ′ of G ′ is defined as follows:For each edge ( x, p ) of G (where x is a left node, and p is a right node in G ), we introduce t edges in G ′ , namely { ( x, ( p, x ( a ) , a )) | a ∈ F t } , where x ( a ) is the value of the polynomial x at a .Note that t = O ((1 /ǫ ) r log | L | ) , the graph G ′ has left degree D ′ = D · t , and the size of the right sideis | R ′ | = | R | · t . Also note that if G is explicit, G ′ is explicit as well. Lemma 1.4 ( G G ′ transformation) . If G admits ( ℓ, r ) online matching up to size K , then G ′ admits ((1 − ǫ ) ℓt, online matching up to size K .Remark . In particular, if G admits ((1 − ǫ ′ ) D, r ) online matching, then G ′ admits ((1 − ǫ − ǫ ′ ) D ′ , online matching. Proof.
We modify the assignment procedure f ( S, x ) for G into an assignment procedure f ′ ( S, x ) for G ′ .Let S = ( x , . . . , x K ) be a list of left nodes (recall that the order in the list is interpreted as the order of“arrival”).The assignment procedure f ′ ( S, x ) works as follows.First we execute f ( S, x ) . Each right node p that f assigns to x (i.e., p ∈ f ( S, x ) ) may also have beenassigned to other r ′ ≤ r − elements that have arrived in S before x , say, to { x , . . . , x r ′ } ∈ S − { x } .For every i ≤ r ′ , the polynomials x and x i can be equal in at most ( n − points in F t , because they havedegree at most n − . Thus there exists a set A of at least t − ( n − r − ≥ (1 − ǫ ) t points in F t suchthat for every a ∈ A , x ( a )
6∈ { x ( a ) , . . . , x r ′ ( a ) } . Then f ′ assigns to x the elements { ( p, x ( a ) , a ) | a ∈ A } (for all p ∈ f ( S, x ) ). By the above estimations, f ′ assigns to each left x at least (1 − ǫ ) ℓt of its neighbors,and the assignment procedure ensures that no right node is assigned to more than one left node. Remark . The assignment procedure for G ′ runs the assignment procedure for G and next calculates x ( a ) for all x ∈ S and all a ∈ F t . The evaluations take time poly ( K, n, t ) = poly ( K, n, r, /ǫ ) (because t = O (1 /ǫ · n · r ) ). Therefore the running time of the assignment procedure for G ′ = running time of theassignment procedure for G + poly ( K, n, r, /ǫ ) . It would be interesting to find a property of bipartite graphs that characterizes graphs admitting onlinematching, similarly to Hall’s Marriage Theorem for offline matching. We do not solve this problem, but wedo identify a property that is sufficient for a strong type of online matching.Clearly, if in a bipartite graph G with left degree D , for every subset S of left nodes, of size at most K ,every node is adjacent to at most r edges coming from S , then G admits ( D, r ) online matching up to size K (we simply assign to each x in S , all its neighbors). Unfortunately, only graphs G with large right side R can have this property.We introduce a relaxed version of the above property, which we dub ( r, K, ǫ ) bounded right degree .Informally, the property requires that for every subset S of left nodes, of size at most K , if we discard ǫD | S | edges, then every right node is adjacent to at most r edges coming from S . We remind that G is explicit if it belongs to a family of graphs indexed by log | L | and there exists an algorithm running in timepoly (log | L | ) that, on input x ∈ L and i ∈ [ D ] , outputs the i -th neighbor of x . S of left nodes, every natural number r , and for every right node p , |E ( S, p ) | denotes the size of the multiset of edges crossing from S to p , and we defineexcess S ( p, r ) = max( |E ( S, p ) | − r, excess S ( r ) = P p ∈ N ( S ) excess S ( p, r ) . Definition 2.1 ( ( r, K, ǫ ) bounded right degree ) . A bipartite graph G = ( L ∪ R, E ) with left degree D has ( r, K, ǫ ) bounded right degree if for every S ⊆ L of size at most K , excess S ( r ) ≤ ǫD | S | .Remark . It is easy to check that G has (1 , K, ǫ ) bounded right degree if and only if G is a ((1 − ǫ ) · D, K ) -expander.We make two claims: The property of ( r, K, ǫ ) bounded right degree,( *) is sufficient for ((1 − O ( ǫ )) D, O (log K · r )) online matching up to size K , and(**) characterizes condenser graphs , a type of graph that has been studied in the theory of pseudorandom-ness and that can be viewed as a generalization of lossless expander graphs.Claim (**) is useful because there are constructions of explicit condenser graphs in which the size of R isnot much larger than K . We prove the two claims above and after that the main results of this section. In this section, G = ( L ∪ R, E ) is a bipartite graph with left degree D that has ( r, K, ǫ ) bounded rightdegree. We need two concepts. Definition 2.3 ( heavy / deficient nodes ) . Let S be a subset of left nodes. • A right node p is heavy for S if it has more than r different neighbors in S . • A left node x in S is deficient for S if |E ( x, HEAVY ) | ≥ ǫD , where HEAVY is the set of nodes thatare heavy for S . The following is the key property of G that is used for online matching. Lemma 2.4.
Let S be a subset of left nodes, of size at most K . Then the subset of elements deficient for S has size at most | S | / .Proof. Let HEAVY be the set of nodes that are heavy for S , and let DEFICIENT be the set of nodes that aredeficient for S . We color the edges in E ( S, R ) , i.e., the edges going out from S . The other edges are ignoredin the rest of the proof. For each right node p , we color in red excess S ( p, r ) edges adjacent to p and color ingreen the other edges. In other words, the red edges are the edges that we “discard” so that each right noderemains with at most r green edges coming from S . Since the number of red edges is at most ǫD | S | and foreach heavy p we color in red more than r adjacent edges, it follows that | HEAVY | < (1 /r ) · ǫD | S | . Suppose | DEFICIENT | > | S | / . Then the total number of edges that cross from DEFICIENT toHEAVY is greater than | S | / · ǫD = 2 ǫD | S | . It follows that the number of green edges adjacent toHEAVY is greater than ǫD | S | (because there are at most ǫD | S | red edges and the rest are green). Since eachnode has at most r green edges adjacent to it, it follows that | HEAVY | > (1 /r ) · ǫD | S | . This contradicts the previous inequality, and ends the proof.7e are ready to prove claim (*).
Theorem 2.5 ( bounded right degree ⇒ online matching ) . If G = ( L ∪ R, E ) is a bipartite graph with leftdegree D that has ( r, K, ǫ ) bounded right degree, then G admits ((1 − ǫ ) D, ⌈ log K ⌉ r ) online matchingup to size K .Furthermore, if the graph G is explicit, then there is an algorithm for the assignment function f ( S, x ) with running time poly ( K, D, log | L | ) .Proof. Let us consider a list of left nodes S of size at most K . If x is not in S , we define f ( S, x ) = ∅ . For x ∈ S , we define f ( S, x ) by the following procedure. Computation of f ( S, x ) j ← the ordinal of the first occurrence of x in the list S ; S ← set of the first j elements in S ; t ← ;while ( x is deficient for S t ) S t +1 ← the set of elements in S t that are deficient for S t ; t ← t + 1 end-while f ( S, x ) ← the multiset of non-heavy for S t neighbors of x (with their multiplicity from N ( x ) )We check that f defined in the above procedure satisfies the requirements (1)-(5) in the Definition 1.3.The first two follow immediately.Requirement (3) is satisfied because the computations of f ( S, x ) and f ( S ′ , x ) start with the same S and are therefore identical.We move to (4). The loop terminates in at most ⌈ log K ⌉ iterations, because, by Lemma 2.4, | S t +1 | ≤| S t | / . If S t decreases to just r elements, then those elements cannot be deficient (because there cannotexist heavy nodes for such S t ). Thus, x eventually becomes non-deficient, and when this happens, it has atleast (1 − ǫ ) D non-heavy neighbors (including the multiplicity in the count). Thus f assigns to x a multisetwith (1 − ǫ ) D of its neighbors.It remains to check (5), i.e., to show that every right node is assigned to at most ⌈ log K ⌉ r nodes in S .Let p be a right node and S = ( x , x , . . . , x K ) . We look at all computations f ( S, x ) , . . . , f ( S, x K ) andestimate in how many of them p is assigned. Claim 2.6. p is assigned to at most r elements at any given iteration of the computations of f ( S, x ) , . . . , f ( S, x K ) .Proof. We analyze an arbitrary iteration t ∗ of the assignment procedures for all x , . . . , x K . Suppose that p is assigned at iteration t ∗ in r + 1 of these procedures, to elements x i , . . . , x i r +1 , where i < . . . , we say that P and Q are ǫ -close, if their statistical distanceis bounded by ǫ . Given a set B , we denote U B a random variable that is uniformly distributed on B . Definition 2.7 ( condenser ) . A function C : { , } n × { , } d → { , } m is a k → ǫ k ′ condenser,if for every random variable X with min-entropy at least k (ranging over { , } n ), the random variable Y = C ( X, U { , } d ) is ǫ -close to a random variable e Y that has min-entropy at least k ′ . A condenser is thus a randomized transformation of random variables X Y ( U { , } d , where d istypically small, is an auxiliary random variable representing the randomness of the transformation). Fortypical settings of parameters, a condenser enhances randomness in the sense that the output Y is closerto having uniform distribution than the input X . The quantity k + d − k ′ is called the entropy loss of thecondenser, because the input has min-entropy k + d and the output is close to having min-entropy k ′ . Weview C as a bipartite graph G in the usual way: the left nodes are the strings in { , } n , the right nodes arethe strings in { , } m and for each x ∈ { , } n , ρ ∈ { , } d there is an edge ( x, C ( x, ρ )) .We actually work with functions that have the condenser property for a large range of values of k .Namely, we use families of functions C indexed by n (but as usual we do not write the index) of thefollowing type(***) C : { , } n × { , } d → { , } m is a k → ǫ k + d − e condenserfor all k ≤ k max such that k ∈ N .Here the parameters d, m, ǫ, k max , and e are functions of n , and with the exception of ǫ are positive integers.Functions of type (***) are very similar to conductors , the difference being that conductors do not havethe restriction that k ∈ N . The parameter e is a bound of the entropy loss for all k ≤ k max and plays animportant role for the online matching property. Lemma 2.8 ( condenser ⇔ bounded right degree ) . A function C has parameters as indicated in condition(***) if and only if the corresponding graph has (2 e , k max , ǫ ) bounded right degree and m ≥ k max + d − e .Proof. “ ⇒ ” Let S ⊆ L with size | S | ≤ k max . Let D = 2 d and k = log | S | . Then U S has min-entropy k ≤ k max , and Y = C ( U S , U { , } d ) is ǫ -close to a random variable Y ′ with min-entropy bounded by k + d − e . Clearly, m ≥ k + d − e because otherwise no random variable with range { , } m can havemin-entropy k + d − e . We need to show that excess S (2 e ) ≤ ǫD | S | . Let A = { p ∈ N ( S ) | |E ( S, p ) | > e } . We have ǫ ≥ Y ( A ) − Y ′ ( A ) = P p ∈ A Y ( p ) − Y ′ ( p ) ≥ P p ∈ A |E ( S,p ) || S |· D − − ( k + d − e ) = | S |· D P p ∈ A ( |E ( S, p ) | − e ) = | S |· D P p ∈ A excess S ( p, e ) = | S | D excess S (2 e ) . which implies the desired inequality.“ ⇐ ” It is well known that it is enough to show the condenser property for all flat distributions X (see [Vad12, Lemma 6.10]). So we take X to be U S , where S ⊆ { , } n with size | S | = 2 k for some k ≤ k max . Let Y = C ( U S , U { , } d ) . 9 laim 2.9. In the graph that corresponds to C , it is possible to redirect ǫD | S | edges so that after redirectionevery element in { , } m has at most e neighbors in S . Proof.
Let A be the set of elements p ∈ { , } m such that |E ( S, p ) | > e and let A = { , } m − A . Let excess be the number of edges that need to be “shaved” so that all nodes in { , } m get to have e edgescoming from S . We have excess ≤ ǫD | S | , because the graph has (2 e , k max , ǫ ) bounded right degree. Wedefine deficit symmetrically to excess (i.e., the deficit is the number of edges that need to be added to get thesame condition). The number of edges adjacent to A is | A | · e + excess and the number of edges adjacentto A is | A | · e − deficit . Since the number of edges adjacent to A ∪ A is D · | S | and | A ∪ A | = 2 m , itfollows that m · e + excess − deficit = D · | S | , which implies that excess ≤ deficit (taking into accountthat m ≥ k max + d − e ). Therefore we can redirect excess many edges coming from S so that instead ofending in A they end in A , and no right node has more than e edges adjacent to it.The redirection yields a random variable Y ′ with range { , } m , with min-entropy at least k + d − e ,and Y ′ is ǫ -close to Y because at most a fraction of ǫ edges have been redirected. We are now prepared to present and prove the results announced in the Introduction.
Theorem 2.10 ( online matching properties of lossless expanders (with sharing) ) . If G = ( L ∪ R, E ) is a bi-partite graph with left degree D that is a ( K max , (1 − ǫ ) D ) expander, then G admits ((1 − ǫ ) D, ⌈ log K max ⌉ ) online matching up to size K max .If G is explicit, then the assignment procedure f ( S, x ) from Theorem 2.5 for G has running timepoly ( K max , D, log | L | ) .Proof. By Remark 2.2, G has (1 , K max , ǫ ) - bounded right degree (this also follows from Ta-Shma, Umans,and Zuckerman [TSUZ07, Th. 8.1] where it is shown that G is a k → ǫ k + d condenser for every k ≤ log K max such that k ∈ N ). So, Theorem 2.5 implies that G admits ((1 − ǫ ) D, ⌈ log K max ⌉ ) onlinematching up to size K max . Theorem 2.11 ( online matching properties of lossless expanders (with no sharing) ) . If G = ( L ∪ R, E ) isa bipartite graph with left degree D that is a ( K max , (1 − ǫ ) D ) expander, then the transformation G G ′ yields a graph G ′ = ( L ′ ∪ R ′ , E ′ ) with left degree D ′ that admits ((1 − ǫ ) D ′ , online matching up to size K max , and G ′ has parameters L ′ = L , | R ′ | = | R | · t , D ′ = D · t , for t = O ((1 /ǫ ) · log | L | · log K max ) .If G is explicit, then G ′ is explicit and the assignment procedure f ( S, x ) from Theorem 2.5 combined withthe G G ′ transformation for G ′ has running time poly ( K max , D ′ , log | L | , /ǫ ) .Proof. The statement follows by combining Theorem 2.3 and the properties of the G G ′ transformationfrom Section 1.3. Theorem 2.12 ( condenser ⇒ online matching (with sharing) ) . If a function C has parameters as incondition (***), then the corresponding graph admits ((1 − ǫ )2 d , · k max · e ) online matching up to size k max .If C is explicit, then the running time of the assignment procedure f ( S, x ) from Theorem 2.5 is poly (2 k max , d , n ) .Proof. This follows by combining Theorem 2.5 and Lemma 2.8 Redirection means changing the right endpoint of the edge. heorem 2.13 ( condenser ⇒ online matching (with no sharing) ) . If a function C has parameters as incondition (***) and G = ( L ∪ R, E ) is the graph corresponding to C , then the transformation G G ′ yieldsa graph G ′ = ( L ′ ∪ R ′ , E ′ ) with left degree D ′ that admits ((1 − ǫ ) D ′ , online matching up to size K max ,and G ′ has parameters L ′ = { , } n , | R ′ | = 2 m · t , D ′ = 2 d · t , for t = O ((1 /ǫ ) · log | L | · log K max · e ) .If C is explicit, then G ′ is explicit and the running time of the assignment procedure f ( S, x ) from Theo-rem 2.5 is poly (2 k max , d , n, /ǫ ) .Proof. The statement follows by combining Theorem 2.12 and the properties of the G G ′ transformationfrom Section 1.3.In short, expander graphs and condenser graphs of type (***) yield bipartite graphs G (or G ′ , after thesimple transformation G G ′ ) with left size L = { , } n , that have good online matching up to size K max := 2 k max . In typical applications, n , k max and ǫ are given, and it is important that the graph hasa right side R , with size not much larger than K max . More precisely, we refer to δ = log( | R | /K max ) as overhead , and it is desirable to have δ = poly (log( n/ǫ )) , or even δ = O (log( n/ǫ )) . It is also desirable that d is small, even though this appears to have somewhat less impact. In most applications it is important thatthe condensers are explicit . We remind that this means that we have a family of condensers indexed by n ,and that C ( x, y ) for x of length n is computable in time polynomial in n .Table 1 presents some condensers from literature, and the online matching property of the correspond-ing graph G . We also indicate the condensers that are strong, and those that are linear, which are usefulproperties in some applications. A k → ǫ k ′ condenser C : { , } n × { , } d → { , } m is strong if, eitherthe output contains the seed at some fixed coordinates, or, if by concatenating the output with the seed, itbecomes a k → ǫ k ′ + d condenser. A condenser is linear , if for every fixed seed y ∈ { , } d , the function C ( · , y ) is linear, i.e., C ( x + x ′ , y ) = C ( x, y ) + C ( x ′ , y ) , for all x, x ′ (‘+‘ is bitwise XOR; in other words, n -bit strings are viewed in the natural way as elements of the additive group F n ; for short proof sketches ofthe linearity of these condensers, see for example the appendix of [BZ20]).Table 2 presents the corresponding bipartite graphs G ′ obtained via the transformation G G ′ fromSection 1.3, which admit online matching with no sharing. If we consider the functional view of a bipartitegraph, the expanders (2), (3) and (5) are linear, because the transformation G G ′ preserves linearity. condenser seed d overhead δ entropy loss e (1) [BMRV00, Lemma 4]non-explicit log( n/ǫ ) + O (1) log( n/ǫ ) 0 (2) [GUV09, Th. 1.7] (1 + 1 /α )(log( n/ǫ ) + log k max ) + O (1) explicit, strong, linear any constant α > α · k max + 2 d (3) [BZ20, Th. 2.11] explicit, strong, linear O (log( n/ǫ )) O ( k max log n · log(1 /ǫ ) + log( n/ǫ )) 0 (4) [BZ19, Prop. 2.8]explicit, strong O (log k max · log( n/ǫ )) 0 d (5) [RRV02, Th. 22(2)]explicit, strong, linear O (log k max · log ( n/ǫ )) 0 O ( d ) (6) [CRVW02] explicit O ( n − k max + log(1 /ǫ ) − O (1)) d + log(1 /ǫ ) + O (1) 0 Table 1:
The notation represents functions C : { , } n × { , } d → { , } k max + δ , that are k → ǫ k + d − e condensersfor all k ≤ k max such that k ∈ N ; n is an arbitrary positive integer, ǫ > and k max is any positive integer ≤ n .The corresponding graph G = ( L ∪ R, E ) , where L = { , } n , R = { , } k max + δ , with left degree D := 2 d , admits ((1 − ǫ ) D, · k max · e ) online matching up to size K max := 2 k max . ipartite expander left degree D ′ size of the right side | R ′ | with online matching(1)non-explicit O ( n k max (1 /ǫ ) ) K max · poly ( n/ǫ ) (2) O (( n/ǫ ) /α ) ) , K αmax · O (( n/ǫ ) /α ) ) explicit, linear any constant α > (3)explicit, linear poly ( n/ǫ ) K O (log(1 /ǫ ) / log n ) max · poly ( n/ǫ ) (4)explicit O (log( n/ǫ ) · log k max ) K max · O (log( n/ǫ ) · log k max ) (5)explicit, linear O (log ( n/ǫ ) · log k max ) K max · O (log ( n/ǫ ) · log k max ) (6)explicit O ( n − k max +log( n/ǫ )) K max · O ( n − k max +log( n/ǫ )) Table 2:
The notation represents bipartite graphs G ′ = ( L ′ ∪ R ′ , E ′ ) , where L ′ = { , } n , with left degree D ′ , thatadmit ((1 − ǫ ) D ′ , online matching up to size K max := 2 k max ; n is an arbitrary positive integer, ǫ > and k max is any number such that K max ∈ N . The graphs are obtained from the corresponding graphs G in Table 1 via thetransformation G G ′ from Section 1.3. Recall from the Introduction that the goal is to store a subset S of size K of a large set U (the “universe”)of size N and that a one-probe storage scheme is a data structure that answers any membership query “Is x in S ?” by reading a single bit. Buhrman, Miltersen, Radhakrishnan, and Venkatesh [BMRV00] have usedlossless expanders to construct randomized one-probe storage schemes with probability of error bounded bya parameter ǫ . They have a scheme based on a non-explicit expander that uses a table of size O ( K · log N · (1 /ǫ ) ) bits and an explicit construction achieving table size O ( K · log N · (1 /ǫ )) . Using improved explicitlossless expanders, there are explicit one-probe storage schemes with smaller tables. Ta-Shma [Ta-02]obtains table size K · O ((log log Nǫ ) ) , and Guruswami, Umans, and Vadhan [GUV09, Theorem 7.4] obtaintable size K · poly ((log N ) /ǫ ) · exp( p log((log N ) /ǫ ) log K ) . The running times for the explicit schemesare poly ( table size , log N ) for building the table, and poly (log N, log(1 /ǫ )) for answering a membershipquery.The one-probe storage schemes mentioned above work for representing a static set S , in the sense thatif S changes by inserting or deleting an element, the entire table that represents S has to be recomputed. Weshow that lossless expanders that admit online matching can be used to represent dynamic sets. This meansthat if an element x is inserted or deleted, then the table is changed only locally in a few positions withoutaffecting the representation of elements x ′ different from x . This is useful in a distributed environment,because if, for some x ′ = x , the query “Is x ′ in S?” is made at the same time x is inserted or deleted, thetable does not have to be locked during the update, and the data structure still answers the query correctlywith probability − ǫ . The previous sentences give the informal meaning of a one-probe storage schemefor dynamic sets, and, to avoid a tedious discussion, we do not give here a formal definition. But it can beinferred from the semantics of the scheme we present below. The condenser (3) appears inside the proof of [BZ20, Th. 2.11] and is a composition of condensers from [TU12, Th. 3.2, alsoTh.4.1] and [GUV09, Th. 4.3, also Th. 1.7]. [BZ20] is a work in progress, and in the final version this condenser will appear in anexplicit form. Also see [HLW06, Th. 10.4].
12e now describe the one-probe storage scheme, presenting its implementation together with its seman-tics.For the implementation, we use a lossless expander G = ( L ∪ R, E ) with left degree D , where L = U (the “universe”), and which admits ((1 − ǫ ) D, online matching for sets up to size K + 1 .The idea is simple. The data structure contains a table T of | R | bits, whose entries are indexed byelements in R . The bits in T are set so that for every x ∈ U , the bits in the positions assigned to x bythe online matching procedure are if x ∈ S , and if x S . Since all but at most an ǫ fraction of rightneighbors are assigned to x , by probing the table at the bit indexed by a random neighbor, we determine if x is in S or not, with probability − ǫ . This works because the list of matching requests has size at most K and every element that is not in S can be viewed as a dummy element in the last position in the list ofmatching requests without going over the allowed bound of K + 1 . So we deduce that the sets of indicesassigned to actual elements and virtually to the dummy element are pairwise disjoint.We continue with the details. The data structure uses the current state of the dynamic set to allow acorect semantics of the operations insert , delete , and membership query in a distributed environment. Thecurrent state is denoted ˜ S and it is the list of distinct elements from U that have been inserted during theentire history of the data structure up to the current time, listed in the order in which they were inserted thefirst time. In addition, each element in ˜ S has a mark which can be either on or off , indicating if currently theelement is in S or, respectively, has been deleted from S . The size | ˜ S | is the number of distinct elementsin the list. For example, if the history of the dynamic set S is insert a, insert b, insert c, delete a, delete b,insert a , then the current state is ˜ S = (( a, on ) , ( b, off ) , ( c, on )) and its size is . We assume that the totalnumber of inserted elements is bounded by K , i.e., | ˜ S | ≤ K for all states ˜ S during the history of the datastructure, and we say that the storage scheme supports up to K insertions. Notice that no element is everdeleted from ˜ S , and therefore we can update ˜ S as a stack, i.e., when some new x is inserted in S , then x ispushed in ˜ S (and its mark is set on ; inserting/deleting elements that have previously been inserted is doneby just switching the on/off mark).The data structure that represents the dynamic set S consists of a table T of bits, having length | R | , whoseentries are indexed by the elements of R , and of the state ˜ S , which can be represented with O ( K log N ) bits. Thus, the total size is | R | + O ( K log N ) .We use ˜ S + x to denote the list obtained by appending x at the end of ˜ S if x ˜ S , and the list ˜ S itself incase x ∈ ˜ S . Let f be an assignment function satisfying the requirements in Definition 1.3 for G . To keepthe notation simple, f views a state ˜ S as a list of elements from U (i.e., f ignores the on/off marks). Thenfor every state ˜ S of size at most K , for every z ˜ S and for every pair u, v of different elements in ˜ S + z ,(i) f ( ˜ S + z, u ) ⊆ N ( u ) ,(ii) | f ( ˜ S + z, u ) | ≥ (1 − ǫ ) · D ,(iii) f ( ˜ S + z, u ) ∩ f ( ˜ S + z, v ) = ∅ ,(iv) if z = u , then f ( ˜ S, u ) = f ( ˜ S + z, u ) .We took into account that the online matching works up to size K + 1 and thus f is correct for ˜ S + z .We next describe the operations insert, delete and membership query . Initially, all the entries in T areset to and the state ˜ S is the empty list. Insert x in S . Lock ˜ S .If x ˜ S push x in ˜ S .Mark x on in ˜ S . Compute f ( ˜ S, x ) and set T ( p ) ← for all p ∈ f ( ˜ S, x ) .Release ˜ S . 13f the lossless expander is explicit, and f is as in Theorem 2.10, then the running time for insert ispoly ( K, D, log N, /ǫ ) . Delete x from S . Lock ˜ S .If x ˜ S , do not do anything.Else: Mark x off in ˜ S . Compute f ( ˜ S, x ) and set T ( p ) ← for all p ∈ f ( ˜ S, x ) .Release ˜ S. If the lossless expander is explicit, and f is as in Theorem 2.10, then the running time for delete ispoly ( K, D, log N, /ǫ ) . Membership query “Is x in S ?” Pick p uniformly at random in N ( x ) .If T ( p ) = 1 , answer “yes” otherwise answer “no.”If the lossless expander G is explicit, the running time for a membership query is poly (log N, log D ) and only one bit of T is read.We now discuss the semantics of the three operations. Note that during the execution of insert and delete the state ˜ S is locked. This implies that the update operations execute sequentially which guarantees that forevery x ∈ U and at every moment in the history of the data structure, x ∈ S ⇔ ( x ∈ ˜ S and its mark is on ) . (1)On the other hand, the membership query operation does not use ˜ S and thus can be executed at the same timewith an update operation. The flip side is that the state ˜ S can change during the execution of the membershipquery operation.We show that the membership query has the following semantics. Claim 3.1.
For every x ∈ U , if during the execution of the membership query “Is x in S ?” no operation insert/delete x is executed and the size of ˜ S remains at most K , then the answer is correct with probability − ǫ .Proof. The assumptions of the claim imply that the locations in T assigned to x are not touched during theexecution, and therefore for every state ˜ S during the execution of the membership query:(a) If x is in ˜ S and its mark is on, then T ( p ) = 1 , for all p ∈ f ( ˜ S, x ) = f ( ˜ S + x, x ) ,(b) If x is in ˜ S and its mark is off, then T ( p ) = 0 , for all p ∈ f ( ˜ S, x ) = f ( ˜ S + x, x ) ,(c) If x is not in ˜ S , then T ( p ) = 0 , for all p ∈ f ( ˜ S + x, x ) .Let p be chosen at random in N ( x ) in the graph G . Let A be the event “ p is in f ( ˜ S + x, x ) .” Properties(a), (b), (c) and relation 1 imply that for every ˜ S during the execution, conditioned on the event A , T ( p ) = 1 ⇔ x ∈ ˜ S and its mark is on ⇔ x ∈ S The conclusion follows because the event A has probability at least − ǫ (by properties ( i ) , ( ii ) )) for every ˜ S that is current during the execution. Bruno Bauwens [private communication, Feb 2021] has shown that it is possible to implement insert and delete inpoly (log
K, D, log N, /ǫ ) amortized time.
14f we use the lossless expanders from Table 2, we obtain one-probe storage schemes for dynamic setswith the above semantics, with various parameters. In particular, we obtain the storage scheme in the nexttheorem.
Theorem 3.2 ( one-probe storage scheme for dynamic sets ) . For every functions k := k ( n ) ≤ n , ǫ := ǫ ( n ) > , there exists a one-probe storage scheme for dynamic subsets of U = { , } n , supporting up to K := 2 k insertions, with table size K · O (log( n/ǫ ) · log k ) .The running times are poly ( K, O (log( n/ǫ ) · log k ) , /ǫ ) for the insert/delete operations, and poly ( n, log 1 /ǫ ) for membership query.Proof. These parameters are obtained if the above one-probe storage scheme is implemented using thelossless expander (4) from Table 2.Except for the case of relatively small K , the parameters in Theorem 3.2 are as good or better than inthe storage schemes in [BMRV00, Ta-02, GUV09], which have the limitation of only handling static sets. In this assessment, we are comparing the table sizes, the running time for insert/delete in Theorem 3.2 vs.the running time for bulding the table for the static case in the earlier schemes, and the running time for themembership query.
One-probe storage scheme for a stack.
In case the dynamic set S behaves like a stack (i.e., the elementthat is deleted is the last element that has been inserted), then a lossless expander yields a one-probe storagescheme for S which works provided S has at most K elements at each time during its history (note that thenumber of total insertions can be larger than K ). This works in the same way as the scheme above, exceptthat we use S itself in the role of ˜ S . Here we use the fact that the assignment function f ( S, x ) satisfyingDefinition 1.3 allows S to be a stack. The first application of expanders has been to design networks that have some type of low congestion [BP73,Mar73]. Unsurprisingly, expanders that admit online matching can be used to design such networks in whichrouting requests can be satisfied in an online manner.To illustrate, we consider the following problem. The goal is to construct a directed graph G , in which wedistinguish a set V of N vertices called input terminals , and a set V of N vertices called output terminals , V ∩ V = ∅ , such that for any sequence (the “routing requests”) of K pairs ( u , v ) , ( u , v ) , . . . , ( u K , v K ) in V × V , with all u i ’s distinct, and all v i ’s distinct, there exist K vertex-disjoint paths from u i to v i for all i ∈ [ K ] . Such graphs are called rearrangeable networks , and we refer to K as bandwidth , and to the lengthof the longest path between input and output terminals as depth . If the graph can handle online routing, thenit is called a non-blocking network . Online routing means that the K pairs arrive in order, and when the i -thpair arrives, the path from u i to v i has to be established before seeing the future arrivals, i.e. the path from u i to v i only depends on the paths from u j to v j , for j < i .A simple solution is to take G to be the complete bipartite graph with left side V and right side V . Thebandwidth is N and the depth is , but the number of edges is N . Bassalygo and Pinsker [BP73] showedvia the probabilistic method the existence of non-blocking networks with bandwidth N , depth O (log N ) , O ( N log N ) edges, and constant degree. Margulis [Mar73] gives an explicit construction, and there havebeen many papers studying various variants of the problem (see [ALM96] and the references therein). The table size obtained in [GUV09] is smaller than the table size in Theorem 3.2 in case log K/ (log log K ) References [ALM96] Sanjeev Arora, F. Thomson Leighton, and Bruce Maggs. On-line algorithms for path selectionin a nonblocking network. SIAM Journal on Computing , 25:149–158, 1996.16BMRV00] Harry Buhrman, Peter Bro Miltersen, Jaikumar Radhakrishnan, and Srinivasan Venkatesh. Arebitvectors optimal? In F. Frances Yao and Eugene M. Luks, editors, Proceedings of the Thirty-Second Annual ACM Symposium on Theory of Computing, May 21-23, 2000, Portland, OR,USA , pages 449–458. ACM, 2000.[BP73] L. A. Bassalygo and M. S. Pinsker. Complexity of an optimum nonblocking switching networkwithout reconnections. Problems of Information Transmission , 9:64–66, 1973.[BZ19] Bruno Bauwens and Marius Zimand. Universal almost optimal compression and Slepian-Wolfcoding in probabilistic polynomial time. CoRR/arxiv , abs/1911.04268, 2019.[BZ20] Bruno Bauwens and Marius Zimand. Universal codes in the shared-randomness model forchannels with general distortion capabilities. CoRR , abs/2007.02330, 2020.[CRVW02] M. R. Capalbo, O. Reingold, S. P. Vadhan, and A. Wigderson. Randomness conductors andconstant-degree lossless expanders. In John H. Reif, editor, STOC , pages 659–668. ACM,2002.[GUV09] Venkatesan Guruswami, Christopher Umans, and Salil P. Vadhan. Unbalanced expanders andrandomness extractors from Parvaresh–Vardy codes. J. ACM , 56(4), 2009.[HLW06] S. Hoory, N. Linial, and A. Wigderson. Expander graphs and their applications. Bull. Amer.Math. Soc. , 43:439–561, 2006.[Mar73] G. A. Margulis. Explicit constructions of concentrators. Problems of Information Transmission ,9:325–332, 1973.[RRV02] Ran Raz, Omer Reingold, and Salil P. Vadhan. Extracting all the randomness and reducing theerror in Trevisan’s extractors. J. Comput. Syst. Sci. , 65(1):97–128, 2002.[Ta-02] Amnon Ta-Shma. Storing information with extractors. Inf. Process. Lett. , 83(5):267–274, 2002.[TSUZ07] A. Ta-Shma, C. Umans, and D. Zuckerman. Lossless condensers, unbalanced expanders, andextractors. Combinatorica , 27(2):213–240, 2007.[TU12] Amnon Ta-Shma and Christopher Umans. Better condensers and new extractors fromParvaresh-Vardy codes. In Proceedings of the 27th Conference on Computational Complex-ity, CCC 2012, Porto, Portugal, June 26-29, 2012 , pages 309–315. IEEE Computer Society,2012.[Vad12] Salil P. Vadhan. Pseudorandomness. Foundations and Trends in Theoretical Computer Science ,7(1-3):1–336, 2012.[Wig19] Avi Wigderson. Mathematics + Computation. A theory revolutionizing technology and science .Princeton University Press, 2019. A Appendix: Connection with Bauwens, Zimand [BZ19] We briefly explain how the online matching properties of lossless expanders follow from results in [BZ19].[BZ19] introduces the concept of ( K, ε ) -invertible function: Definition A.1 (Definition 2.1 in [BZ19]) . A probabilistic function F : X → Y is ( K, ε ) -invertible if thereexists a deterministic partial function g : X ≤ K × Y → X such that for all S ∈ X ≤ K and all x ∈ S : Pr [ g S (F( x )) = x ] ≥ − ε , here g S ( y ) = g ( S, y ) . F is online ( K, ε ) -invertible if there exists such a function g that is monotone in S :if list S ′ extends S , then the function y g S ′ ( y ) is an extension of y g S ( y ) . (Note: X ≤ K is the set of allsequences of length at most K with elements from the set X .) If the sets X and Y are finite and if the function F is using the same amount of randomness, say d bits,for each input in X , we can associate to the invertible function in the standard way a bipartite graph, with leftdegree D = 2 d , where the left side is X , the right side is Y , and ( x, p ) is an edge if there is a random string ρ such that F( x, ρ ) = p . In this view, an invertible ( K, ǫ ) function is a bipartite graph that has ((1 − ǫ ) D, online matching. In this way results from [BZ19] about online invertible functions can be translated in thelanguage of this paper to refer to bipartite graphs that admit online matching.With this translation and taking into account that the conductors defined in [BZ19] are standard conduc-tors with entropy loss d , Corollary 2.13 in [BZ19] states in the language of this paper that a ( K, ǫ ) conductorwith loss entropy d , after a transformation similar to the G G ′ transformation in this paper, produces agraph that admits (1 − O ( ǫ ) D, online matching up to size K . Therefore a ( K, ǫ ) lossless expander (whichis equivalent to a conductor with entropy loss [TSUZ07, Th. 8.1]) also admits ((1 − O ( ǫ )) D, onlinematching up to size K , and this is Theorem 1.1(b).In a similar way, Corollary 2.11 in [BZ19] states that a ( K, ǫ ) conductor with loss entropy d correspondsto a graph that admits ((1 − ǫ ) D, D log(2 K )) online matching up to size K . This is almost the sameas Theorem 1.1(a), except that entropy loss should be (so that the graph is a lossless expander), and theonline matching should have sharing parameter O (log K ) instead of D log(2 K ))