Sublinear Random Access Generators for Preferential Attachment Graphs

A linear time randomized algorithm for efficiently generating BA-graphs is given in Betagelj and Brandes [4]. See also Kumar et al. [11] and Nobari et al. [19]. A parallel algorithm is given in Alam et al. [1]. See also Yoo and Henderson [26]. An external memory algorithm was presented by Meyer and Peneschuck [17].

Goldreich, Goldwasser and Nussboim initiate the study of the generation of huge random objects [8] while using a “small” amount of randomness. They provide an efficient query access to an object modeled as a function, when the object has a predetermined property, for example graphs which are connected. They guarantee that these objects are indistinguishable from random objects that have the same property. This refers to the setting where the size of the object is exponential in the number of queries to the function modeling the object. We note that our generator provides access to graphs which are random BA-graphs and not just indistinguishable from random BA-graphs.

Mansour, Rubinstein, Vardi and Xie [15] consider local generation of bipartite graphs for local simulation of Balls into Bins online algorithms. They assume that the balls arrive one by one and that each ball picks $d$ bins independently, and then assigned to one of them. The local simulation of the algorithm locally generates a bipartite graph. Mansour et al. show that with high probability one needs to inspect only a small portion of the the bipartite graph in order to run the simulation and hence a random seed of logarithmic size is sufficient.

One reason for generating large BA-graphs is to simulate algorithms over them. Such algorithms often access only small portions of the graphs. In such instances, it is wasteful to generate the whole graph. An interesting example is sublinear approximation algorithms [21, 27, 18, 20] which probe a constant number of neighbors. ¹¹1Strictly speaking, sublinear approximation algorithms apply to constant degree graphs and BA-graphs are not constant degree. However, thanks to the power-law distribution of BA-graphs, one can “omit” high degree vertices and maintain the approximation. See also [22]. In addition, local computation algorithms probe a small number of neighbors to provide answers to optimization problems such as maximal independent sets and approximate maximum matchings [6, 7, 22, 23, 2, 15, 16, 12, 13, 14]. Support of adjacency list queries is especially useful for simulating (partial) DFS and BFS over graphs.

The main difficulty in providing the on-the-fly generator is in “inverting” the random choices of the BA process. That is, we need to be able to randomly choose the next “child” of a given node $x$, although it will only “arrive in the future” and its choice of a parent in the BA-graph will depend on what will have happened until it arrives (i.e., on the node degrees in the BA-graph when that node arrives). One possibility to do so is to maintain, for any future node which does not yet have a parent, how many potential parents it still has, and then go sequentially over the future nodes and randomly decide if its parent will indeed be $x$. This is too costly not only because we will need to go sequentially over the nodes, but mainly because it may be too costly in computation time to calculate, given the random choices already done in response to previous queries, what is the probability that the parent of a node $y$ that does not have yet a parent, will be node $x$.

To overcome this difficulty we define for any node, even if it has already a parent, its probability to be a candidate to be a child of $x$. We show how these probabilities can be calculated efficiently given the previous choices taken in response to previous queries, and show how, based on these probabilities, we can define an efficient process to chose the next candidate. The candidate node may however already have a parent, and thus cannot be a child of $x$. If this is the case we repeat the process and choose another candidate, until we chose an eligible candidate which then is chosen to be the actual next child of $x$. We show that with high probability this process terminates quickly and finds an eligible candidate, so that with high probability we have an efficient process to find “into the future” the next child of $x$. This is done while sampling exactly according to the distribution defined by the BA-graphs process.

In addition to the above technique, which is arguably the crux of our result, we use a number of data structures, based on known constructions, to be able to run the on-the-fly generator with polylogarithmic time and space complexities. In the sequel we give, in addition to the formal definitions of the algorithms, some supplementary intuitive explanations into our techniques.

We give a naïve implementation of a next-child query, with time complexity $O(n)$, with the purpose of illustrating the main properties of this query and in order contrast it with the more efficient implementation later. We do so in a simpler manner without looking into the “type”. The naïve implementation of next-child  is listed in Figure 3. This implementation, and that of parent, share an array of pointers $u$, both updating it. A query $\texttt{next-child}(i,k)$ is processed by scanning the vertices one-by-one starting from $k+1$. If $u(x)=i$, then $x$ is the next child. If $u(x)$ is $\mathsf{nil}$, then a coin $c(x)$ is flipped and $u(x)=i$ is set when $c(x)$ comes out $1$; the probability that $c(x)$ is $1$ is $1/\varphi(x)$. If $c(x)=0$, we proceed to the next vertex. The loop ends when some $c(x)$ is $1$ or all vertices have been exhausted. In the latter case the query returns $n+1$.

The correctness of naïve-next-child, i.e., the fact that the graph is generated according to the required probability distribution, is based on the observation that, conditioned on the event that $u(x)\not\in\textit{not-u-parent-candidate}(x)$, all the vertices in $\text{$\Phi$}(x)$ are equally likely to serve as $u(x)$. Note that the description above does not explain how $\varphi(x)$ is computed.

We first shortly discuss the challenges on the way to an efficient implementation of next-child. Consider the simple special case where the only two queries issued are, for some $j$, a single $\texttt{parent}(j)$ followed by a single $\texttt{next-child}(j)$ (to simplify this discussion we assume that the the value of $k$ is globally known). Consider the situation after the query $\texttt{parent}(j)$. Every vertex $x\in[j+1,n]$ may be a $u$-child of $j$ I.e., because at this point $\textit{front}(i)=\mathsf{nil}$, for every $i$, $\varphi(x)=x-1$ and $\mathbf{Pr}[u(x)=j]=1/(x-1)$. Let $P_{x}$ denote the probability that vertex $x$ is the first child of $j$. Then $P_{x}=\frac{1}{x-1}\cdot\prod_{\ell=j+1}^{x-1}(1-\frac{1}{\ell-1})=\frac{j-1}{(x-1)(x-2)}$ and for $P_{n+1}$ (i.e., $j$ has no child) $P_{n+1}=\frac{j-1}{n-1}$. Since each of the probabilities $P^{\prime}_{k}=\sum_{x=j+1}^{k}P_{x}$ can be calculated in $O(1)$ time, this random choice can be done in $O(\log n)$ time by a choosing uniformly at random a number in $[0,1]$ and performing a binary search on $[j+1,n+1]$ to find which index it represents (see a more detailed an accurate statement of this procedure below). However, in general, at the time of a certain next-child query, limitations may exits, due to previous queries, on the possible consistent values of certain pointers $u(x)$. There are two types of limitations: (i) $u(x)$might have been already determined, or (ii) $u(x)$is still $\mathsf{nil}$ but the option of $u(x)=i$ has been excluded since $\textit{front}(i)>x$. These limitations change the probabilities $P_{x}$ and $P^{\prime}_{x}$, rendering them more complicated and time-consuming to compute, thus rendering the above-defined process not efficient (i.e., not doable in $O(\log n)$ time). In the rest of this section we define and analyze a modified procedure that uses $\mbox{polylog}(n)$ random bits, takes $\mbox{polylog}(n)$ time, and increases the space by $\mbox{polylog}(n)$. This procedure will be at the heart of the efficient implementation of next-child.

The efficient implementation of next-child  (and of parent) makes use of the following data structures.

• •

  An array of length $n$, $u(j)$

• •

  An array of length $n$, $type(j)$

• •

  An array of length $n$, $\textit{front}(j)$ (We also maintain an array $\textit{front}^{-1}(i)$ with the natural definition.)

• •

  An array of $n$ balanced search trees, called $\texttt{child}(j)$, each holding the set of nodes $i>j$ such that $u(i)=j$. For technical reasons all trees $\texttt{child}(j)$ are initiated with $n+1\in\texttt{child}(j)$.

• •

  A number of additional data structures that are implicit in the listing, described and analyzed in the sequel.

In the implementation of the on-the-fly generator of the pointers tree we will maintain two invariants that are described below. We will later discuss the cost (in running time and space) of maintaining these invariants.

We will use this invariant to infer that $\textit{front}(j)\neq\mathsf{nil}$ implies that $u(j)\neq\mathsf{nil}$. One can easily maintain this invariant by introducing a $\texttt{parent}(j)$ query as the first step of the implementation of the $\texttt{next-child-tp}(j,\cdot,\cdot)$ query (for technical reasons we do that in a lower-level procedure next-child.)

The second invariant is maintained by issuing an “internal” $\texttt{next-child}(\textit{front}(j),\textit{front}(j))$ query whenever $\textit{front}(j)$ is updated. This is done recursively, the base of the recursion being node $n+1$. When analyzing the complexities of our algorithm we will take into account these recursive calls. Let $\textit{front}^{-1}(j)$ denote the vertex $i$ such that $\textit{front}(i)=j$, if such a vertex $i$ exists; (note that there can be at most one such node $i$, except for the case of $j=n+1$); otherwise $\textit{front}^{-1}(j)=\mathsf{nil}$. We get that if $\textit{front}^{-1}(j)\neq\mathsf{nil}$, then $u(j)\neq\mathsf{nil}$.

We note that if at a give time we consider a node $j$ such that $u(j)=\mathsf{nil}$ (i.e., its parent in the pointers tree is not yet determined), then the set $\Phi(j)$ is the set of all the nodes that can still be the parent of node $j$ in the pointers tree. The set $\Phi$ is however defined also for nodes for which their parent is already determined.

The following lemma proves that $\{\text{$\Phi$}(x)\}_{x}$ is a nondecreasing chain. It also characterizes a sufficient condition for $\varphi(x+1)-\varphi(x)\leq 1$, and a necessary and sufficient condition for $\text{$\Phi$}(x+1)=\text{$\Phi$}(x)$ (and hence $\varphi(x+1)=\varphi(x)$).

Thus, by Lemma 7, we have that for any $x\in[1,n-1]$:

We are now ready to describe the implementation of $\texttt{next-child-tp}(j,k,type)$ and $\texttt{next-child}(j)$. As seen in Figure 4, $\texttt{next-child-tp}(j,k,type)$ is merely a loop of $\texttt{next-child-from}(j,k)$, and $\texttt{next-child-from}(j,k)$ is essentially a call to $\texttt{next-child}(j)$. The “real work” is done in the implementation of $\texttt{next-child}(j)$ and $\texttt{next-child-from}(j,k)$ that we describe now. Note that if $j$ does not have children larger than $k$, then $\texttt{next-child-from}(j,k)$ returns $n+1$.

If $\textit{front}(j)>k$ when $\texttt{next-child-from}(j,k)$ is called, then the next child is already fixed and it is just extracted from the data structures. Otherwise, an interval $I=[a,b]$ is defined, and it will contain the answer of $\texttt{next-child}(j)$. Let $a=\textit{front}(j)+1$ if $\textit{front}(j)\neq\mathsf{nil}$; and $a=j+1$, if $\textit{front}(j)=\mathsf{nil}$. Let $b=\min\{\{\ell>\textit{front}(j),u(\ell)=j\}\cup\{n+1\}\}$ if $\textit{front}(j)\neq\mathsf{nil}$; and $b=\min\{\{\ell>j,u(\ell)=j\}\cup\{n+1\}\}$, if $\textit{front}(j)=\mathsf{nil}$ (i.e., $b$ is the smallest indirectly exposed child of $j$ beyond the “fully known area” for $j$, or $n+1$ if no such child exists). Observe that no vertex $x\in F\cap[a,b)$ can satisfy $u(x)=j$. Hence, the answer is in $I\setminus(F\setminus\{b\})$.

The next child can be sampled according to the desired distribution in a straightforward way by going sequentially over the vertices in $I\setminus F\setminus\{b\}$, and tossing for each vertex $x$ a coin that has probability $1/\varphi(x)$ to be $1$, until indeed one of those coins comes out $1$, or all vertices are exhausted (in which case node $b$ is taken as the next child). We denote by $D(x)$, $x\in I\setminus F$, the probability that $x$ is chosen when the the above procedure is applied. This procedure, however, takes linear time.

In order to start building our efficient implementation for next-child we note that by the definition of $K$, $K\subseteq F$, and we consider a process where we toss $|[a,b)\setminus K|$ coins sequentially for the vertices in $[a,b)\setminus K$. The probability that the coin for $x\in[a,b)\setminus K$ is $1$ is still $1/\varphi(x)$. We stop as soon as $1$ is encountered or on $b$ if all coins are $0$. The vertex on which we stop, denote is $x$, is a candidate next $u$-child. If $x\in F\setminus K\setminus\{b\}$, then $x$ cannot be a child of $j$ so we proceed by repeating the same process, but with the interval $[x+1,b]$ instead of the interval $[a,b]$. We denote by $D^{\prime}(x)$, $x\in I\setminus F$, the probability that $x$ is chosen when this procedure is applied.

We now build our efficient procedure that selects the candidate, without sequentially going over the nodes. To this end, observe that the sequence of probabilities of the coins tossed in the last-described process behaves “nicely”. Namely, the probabilities $1/\varphi(x)$, for $x\in[a,b)\setminus K$, form the harmonic sequence starting from $1/\varphi(a)$ and ending in $1/(\varphi(a)+|[a,b)\setminus K|-1)$. Indeed, Eq. (1) implies that if vertex $i$ is the smallest vertex in $I\setminus K$, then $\varphi(i)=\varphi(a)$ and an increment between $\varphi(x)$ and $\varphi(x+1)$ occurs if and only if $x\notin K$. Let $s=|[a,b)\setminus K|$ and let $P_{h}$, $0\leq h\leq s$ be the probability that the node of rank $h$ in $([a,b)\setminus K)\cup\{b\}$ is chosen as candidate in the sequential procedure defined above. Since $1/\varphi(x)$ forms the harmonic sequence for $x\in[a,b)\setminus K$, we can, given $\varphi(a)$, calculate in $O(1)$ time, for any $0\leq i\leq s+1$, the probability $P^{\prime}_{i}=\sum_{q<i}P_{q}$ (i.e., the probability that a node of some rank $q$, $q<i$, is chosen). Indeed, for $i=0$, $P_{i}=\frac{1}{\varphi(a)}$; for $0<i<s$, $P_{i}=\frac{1}{\varphi(a)+i}\cdot\prod_{\ell=0}^{i-1}\left(1-\frac{1}{\varphi(a)+\ell}\right)=\frac{\varphi(a)-1}{(\varphi(a)+i-1)(\varphi(a)+i)}$; and for $i=s$, $P_{s}=\prod_{\ell=0}^{s-1}\left(1-\frac{1}{\varphi(a)+\ell}\right)=\frac{\varphi(a)-1}{\varphi(a)+s-1}$. Hence, for $0\leq i\leq s$, $P^{\prime}_{i}=1-\frac{\varphi(a)-1}{\varphi(a)+(i-1)}$, and for $i=s+1$, $P^{\prime}_{s+1}=1$. This allows us to simulate one iteration (i.e., choosing the next candidate next $u$-child) by choosing uniformly at random a single number in $[0,1]$, and then performing a binary search over $0$ to $s$ to decide what rank $h$ this number “represents”. After the rank $h\in[0,s]$ is selected, $h$ is then mapped to the vertex of rank $h$ in $([a,b)\setminus K)\cup\{b\}$, denote it $x$, and this is the candidate next $u$-child. As before, if $x\in F\setminus K\setminus\{b\}$, then $x$ cannot be a child of $j$ so we ignore it and proceed in the same way, this time with the interval $[x+1,b]$. We denote by $\hat{D}(x)$, $x\in I\setminus F$ the probability that $x$ is chosen when this third procedure is applied. See Figure 4 for a formal definition of this procedure and that of next-child.

Observe that this procedure takes $O(\log s)$ time (see Section 6.4 for a formal statement of the time and randomness complexities). We note that we cannot perform this selection procedure in the same time complexity for the set $[a,b)\setminus F$, because we do not have a way to calculate each and every probability $P^{\prime}_{i}$, $i\in[a,b)\setminus F$, in $O(1)$ time, even if $\varphi(a)$ is given.

To conclude the description of the implementation of next-child, we give the following lemma which states that the probability distribution on the next child is the same for all three processes described above.