Distributed Data Summarization in Well-Connected Networks

TL;DR

This paper develops efficient distributed algorithms for data summarization tasks in well-connected networks, achieving near-optimal round complexity and demonstrating strong simulation capabilities between the GOSSIP and CONGEST models.

Contribution

It introduces new algorithms for exact and approximate data summarization in well-connected graphs, linking GOSSIP and CONGEST models and improving round complexity bounds.

Findings

Exact sum computation in rac{( ext{mixing time})}{ ext{rounds}} for well-connected graphs.

New GOSSIP algorithm approximates frequency moments with rac{ ext{( ext{error})}}{ ext{rounds}} complexity.

Strong simulation of GOSSIP in CONGEST model with near-perfect accuracy.

Abstract

We study distributed algorithms for some fundamental problems in data summarization. Given a communication graph $G$ of $n$ nodes each of which may hold a value initially, we focus on computing $\sum_{i=1}^N g(f_i)$, where $f_i$ is the number of occurrences of value $i$ and $g$ is some fixed function. This includes important statistics such as the number of distinct elements, frequency moments, and the empirical entropy of the data. In the CONGEST model, a simple adaptation from streaming lower bounds shows that it requires $\tilde{\Omega}(D+ n)$ rounds, where $D$ is the diameter of the graph, to compute some of these statistics exactly. However, these lower bounds do not hold for graphs that are well-connected. We give an algorithm that computes $\sum_{i=1}^{N} g(f_i)$ exactly in $\tau_G \cdot 2^{O(\sqrt{\log n})}$ rounds where $\tau_G$ is the mixing time of $G$. This also has applications in computing the top $k$ most frequent elements. We demonstrate that there is a high similarity between the GOSSIP model and the CONGEST model in well-connected graphs. In particular, we show that each round of the GOSSIP model can be simulated almost-perfectly in $\tilde{O}(\tau_G $ rounds of the CONGEST model. To this end, we develop a new algorithm for the GOSSIP model that $1\pm \epsilon$ approximates the $p$-th frequency moment $F_p = \sum_{i=1}^N f_i^p$ in $\tilde{O}(\epsilon^{-2} n^{1-k/p})$ rounds, for $p \geq2$, when the number of distinct elements $F_0$ is at most $O\left(n^{1/(k-1)}\right)$. This result can be translated back to the CONGEST model with a factor $\tilde{O}(\tau_G)$ blow-up in the number of rounds.

Equations

$$\mathrm{Pr}\left(t(u)=v|\underset{z\in Z}{\bigwedge }t(z)\right)\in \left[\frac{1-\lambda }{n},\frac{1+\lambda }{n}\right].$$

$$\left|P_u^t(v_i)-\frac{\mathrm{deg}(v_i)}{2m}\right|\le \frac{\mathrm{deg}(v_i)}{2mn}.$$

$$\left|P_u^t(v_i)-\frac{\mathrm{deg}(v_i)}{2m}\right|\le \lambda .$$

$$\left(\frac{\mathrm{deg}(v)}{2m}+\frac{1}{2mn}\right)\cdot \frac{1}{\mathrm{deg}(v)}\le \frac{1}{m}.$$

$$nk\cdot \frac{0.9}{2m}$$

$$\frac{\frac{k}{2m}-k{\lambda }^{\prime }}{n\left(\frac{k}{2m}+k{\lambda }^{\prime }\right)}$$

$$\frac{1}{n}\cdot \frac{1-2m{\lambda }^{\prime }}{1+2m{\lambda }^{\prime }}$$

$$\frac{1}{n}\cdot (1-8m{\lambda }^{\prime })$$

$$\frac{1}{n}\cdot (1-\lambda )$$

$$\Pr\left(\mathcal{E}_{v}\big{|}\bigwedge_{z\in Z}t(z)\right)\in\left[\frac{k}{2m}-k\lambda^{\prime},\frac{k}{2m}+k\lambda^{\prime}\right]$$

$$\Pr\left(\mathcal{E}\big{|}\bigwedge_{z\in Z}t(z)\right)\in\left[n(\frac{k}{2m}-k\lambda^{\prime}),n(\frac{k}{2m}+k\lambda^{\prime})\right]~{}.$$

$$\Vert x{\Vert }_q\le \left(n^{1/q-1/p}\right)\Vert x{\Vert }_p\text{, for 0<q<p .}$$

$${\left(K{n}^{1/(p-1)}\right)}^{1-1/p}{\Vert f^{\prime }\Vert }_p$$

$$\Vert f^{\prime }{\Vert }_p$$

$$F_p$$

$${\hat{F}}_k=\frac{n^{k-1}}{T}\cdot \sum _{j=1}^T\sum _{v=1}^n{I}_{j,v}.$$

$$\text{E}\left[{\hat{F}}_k\right]$$

$$\mathrm{Pr}\left(\left|{\hat{F}}_k-F_k\right|\ge ϵF_k\right)$$

$${\hat{F}}_p=\widehat{F_k}\cdot f_i^{p-k}.$$

$$\text{E}\left[{\hat{F}}_p\right]$$

$$=(1\pm O(ϵ))F_p.$$

$$\text{V}\left[{\hat{F}}_p\right]$$

$$\le 2F_k{F}_{2p-k}.$$

Full text

In the $\mathsf{CONGEST}$ model, a simple adaptation from streaming lower bounds shows that it requires $\tilde{\Omega}(D+n)$ rounds, where $D$ is the diameter of the graph, to compute some of these statistics exactly. However, these lower bounds do not hold for graphs that are well-connected. We give an algorithm that computes $\sum_{i=1}^{N}g(f_{i})$ exactly in $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds where $\tau_{G}$ is the mixing time of $G$. This also has applications in computing the top $k$ most frequent elements.

We demonstrate that there is a high similarity between the $\mathsf{GOSSIP}$ model and the $\mathsf{CONGEST}$ model in well-connected graphs. In particular, we show that each round of the $\mathsf{GOSSIP}$ model can be simulated almost perfectly in $\tilde{O}(\tau_{G})$ rounds of the $\mathsf{CONGEST}$ model. To this end, we develop a new algorithm for the $\mathsf{GOSSIP}$ model that $1\pm\epsilon$ approximates the $p$-th frequency moment $F_{p}=\sum_{i=1}^{N}f_{i}^{p}$ in $\tilde{O}(\epsilon^{-2}n^{1-k/p})$ rounds 111$\tilde{O}$ omits $\operatorname{\text{{\rm polylog}}}(n)$ factors., for $p\geq 2$, when the number of distinct elements $F_{0}$ is at most $O\left(n^{1/(k-1)}\right)$. This result can be translated back to the $\mathsf{CONGEST}$ model with a factor $\tilde{O}(\tau_{G})$ blow-up in the number of rounds.

1 Introduction

Motivation

Analyzing massive datasets has become an increasingly important and challenging problem. Collecting the entire data to one single machine is usually infeasible due to memory, I/O, or network bandwidth constraints. Furthermore, in many cases, data are distributed over the network and we hope to aggregate some of their properties efficiently. In this work, we consider several fundamental data summarization problems in distributed networks, specifically in the $\mathsf{CONGEST}$ and $\mathsf{GOSSIP}$ models.

In this problem, we have a graph $G=(V,E)$ of $n$ nodes. Each node $v$ in the graph may hold a value $\operatorname{val}\left(v\right)$ in the range $\{1,\ldots,N\}\cup\{\textup{NULL}\}$ where NULL simply means that the node does not hold a value. If $\operatorname{val}\left(v\right)=\textup{NULL}$, we call $v$ an empty node.

We often use the notation $[N]:=\{1,\ldots,N\}$. Let $f_{i}$ be the number of nodes that hold value $i$, i.e., $f_{i}=\left|\{v\in V:\operatorname{val}\left(v\right)=i\}\right|$. We want to compute $\sum_{i=1}^{N}g(f_{i})$ for some fixed function $g$. To demonstrate some important cases, consider the following examples.

Consider $g(f_{i})=1$ if $f_{i}>0$ and 0 otherwise. This corresponds to the problem of counting the number of distinct elements (or computing the 0-th frequency moment $F_{0}$). The problem may arise in the following situation: Each node stores a version of a file (e.g. the hash of a blockchain), and we want to know how many different versions there are in the network.

If $g(f_{i})=f_{i}^{p}$ for some fixed $p=2,3,\ldots$, then this corresponds to the problem of computing the $p$-th frequency moment $F_{p}$. We note that $F_{p}$ is a basic, yet very important statistic of a dataset. $F_{2}$ measures the variance and could be used to estimate the size of a self-join in database applications. For higher $p$, $F_{p}$ measures the skewness of the dataset (see [AMS99]). Note that $F_{1}$ can be computed in $O(D)$ rounds by aggregating along a breath-first-search (BFS) tree.

Another example is $g(f_{i})=-(f_{i}/F_{1})\cdot\log(f_{i}/F_{1})$. In this case, the sum is the empirical entropy of the data. Computing the empirical entropy is motivated by network applications such as detecting anomalies [GMT05, XZB05, WP05].

Models

We now give a formal description of the $\mathsf{CONGEST}$ and $\mathsf{GOSSIP}$ models, where the running time of an algorithm is measured by the number of rounds.

Definition 1.1**.**

In the $\mathsf{CONGEST}$ model, we are given a graph $G=(V,E)$ of $n$ nodes, in each synchronous round, each node can talk (send and receive message) to each of its neighbors and then perform local computations. Each message is restricted to be at most $O(\log n)$ bits.

Definition 1.2**.**

In the $\mathsf{GOSSIP}(\lambda)$ model with $n$ nodes, in each synchronous round, each node $u$ samples a node $t(u)$ from a distribution that satisfies the following: For any node $v$ and any subset of nodes $Z$ where $u\notin Z$,

[TABLE]

In the above, “$\bigwedge_{z\in Z}t(z)$” means conditioning on any assignment of each $t(z)$ for $z\in Z$. Then, $u$ can PUSH a message of size $O(\log n)$ to $t(u)$ or PULL a message of size $O(\log n)$ from $t(u)$. Then, after performing some local computations, it proceeds to the next round. We refer $\mathsf{GOSSIP}$ model as the $\mathsf{GOSSIP}(0)$ model.

1.1 Our results

We organize our main results into three categories: a) results in the $\mathsf{CONGEST}$ model, b) an emulation of the $\mathsf{GOSSIP}$ model in the $\mathsf{CONGEST}$ model, and c) results in the $\mathsf{GOSSIP}$ model.

Results in the $\mathsf{CONGEST}$ model

We briefly show how to adapt streaming algorithms to approximate $F_{p}$ (for $p=0,2,3,\ldots)$ in the $\mathsf{CONGEST}$ model. We also demonstrate some lower bounds and conditional lower bounds that give evidence that such algorithms are optimal or near-optimal.

The lower bounds show that computing $F_{p}$ exactly for $p=0,2,3,\ldots$ requires $\tilde{\Omega}(D+n)$ rounds and approximating $F_{p}$ within a constant factor requires polynomial rounds in $n$ for $p\geq 3$. Roughly speaking, the hard instances in the $\mathsf{CONGEST}$ model are graphs with a small balanced cut of $O(1)$ size that causes an information bottleneck. However, such bottleneck does not occur in graphs that are well-connected. Our first main result aims to answer the following question: Could one design more efficient algorithms for well-connected graphs? We give a positive answer to this question.

By using the permutation routing algorithms of Ghaffari et al. [GKS17] (later improved by Ghaffari and Li [GL18]), we show that there exists an algorithm running in $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds that computes $\sum_{i=1}^{N}g(f_{i})$ for all fixed and computable functions $g$ with high probability (w.h.p.) 222We consider $1-1/\operatorname{\text{{\rm poly}}}(n)$ as high probability. . This includes all the aforementioned quantities such as the number of distinct elements, higher frequency moments, and the empirical entropy. Thus, if the graph has small mixing time such as expanders [Gol11, HLW06], where $\tau_{G}=\operatorname{\text{{\rm polylog}}}(n)$, then we obtain a much more efficient sub-polynomial in $n$ algorithm compared to the adaptation of the streaming counterpart.

Theorem 1.1** (Main result 1).**

There exists an algorithm that computes $\sum_{i=1}^{N}g(f_{i})$ exactly for all (fixed and computable) functions $g$ in the $\mathsf{CONGEST}$ model in $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds w.h.p.

Our algorithm can also easily be extended to find the top $k$ frequent elements in $O(k)+\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds.

From $\mathsf{CONGEST}$ to $\mathsf{GOSSIP}$

The lower bounds do not apply directly to the $\mathsf{GOSSIP}$ model either. This is because for any balanced cut of the nodes, one expects $O(n)$ messages to be sent across in one round. Moreover, the expected communication degree per node in the $\mathsf{GOSSIP}$ model is $O(1)$. Intuitively, the graph formed by the communication pattern in the $\mathsf{GOSSIP}$ model is similar to an expander graph.

In fact, we show that well-connected graphs can emulate the $\mathsf{GOSSIP}$ model efficiently. In particular, one round of the $\mathsf{GOSSIP}(1/\operatorname{\text{{\rm poly}}}(n))$ model can be emulated in $\tau_{G}\cdot\operatorname{\text{{\rm polylog}}}(n)$ rounds in the $\mathsf{CONGEST}$ model where the underlying graph is $G$. Therefore, any algorithm that works in the $\mathsf{GOSSIP}(1/\operatorname{\text{{\rm poly}}}(n))$ model can be turned into an algorithm in the $\mathsf{CONGEST}$ model with an $\tilde{O}(\tau_{G})$ factor blow-up.

Consider our results in the $\mathsf{CONGEST}$ model. The permutation routing algorithms of [GKS17] and [GL18] introduces a super-logarithmic factor, $2^{O(\sqrt{\log n})}$, on top of the mixing time. It becomes the bottleneck in graphs with small mixing times (e.g., expanders). Improving the permutation routing algorithm directly yields improvements to our results in the $\mathsf{CONGEST}$ model (and many other problems). However, it is unclear if it can be improved. This emulation result serves as an alternative route to circumvent the $2^{O(\sqrt{\log n})}$ factor, if one develops efficient $\mathsf{GOSSIP}$ algorithms.

Theorem 1.2** (Main result 2).**

For $\lambda=1/\operatorname{\text{{\rm poly}}}(n)$, one round of the $\mathsf{GOSSIP}(\lambda)$ model can be emulated in $\tilde{O}(\tau_{G})$ rounds in the $\mathsf{CONGEST}$ model where $G$ is a connected graph denoting the underlying network.

We believe that this emulation result may be of independent interest. Jelasity et al. [JVG*+*07] studied how to implement the gossip-based peer sampling service empirically. Our result is an additional way to implement the service with theoretical guarantees.

Results in the $\mathsf{GOSSIP}$ model

Motivated by our emulation result, we develop algorithms for the $\mathsf{GOSSIP}$ model. In particular, we are interested in the following question: Suppose the number of non-empty nodes are sublinear in $n$. Could we take advantage of the computational power of the empty nodes?

Suppose that the number of non-empty nodes is at most $O(n^{1/(k-1)})$ (or more generally, $F_{0}\leq O(n^{1/(k-1)})$). We show that for any $p\geq 2$, $F_{p}$ can be approximated within a $1\pm\epsilon$ factor in $O(\epsilon^{-2}n^{1-k/p}\log^{2}n)$ rounds with high probability.

Theorem 1.3** (Main result 3).**

If $F_{0}=O(n^{1/(k-1)})$ for some integer $2\leq k\leq p$, then there exists an algorithm that approximates $F_{p}$ up to a $1\pm\epsilon$ factor in $O(\epsilon^{-2}n^{1-k/p}\log^{2}n)$ rounds in the $\mathsf{GOSSIP}(1/n^{c})$ model, for some sufficiently large constant $c$, w.h.p.

The $\mathsf{GOSSIP}(1/n^{c})$ model will incur a $\pm 1/\operatorname{\text{{\rm poly}}}(n)$ additive error which we consider insignificant. Since $F_{0}\leq n$, we have an algorithm that approximates $F_{2}$ in $\tilde{O}(\epsilon^{-2})$ rounds by setting $k=2$. When $k>2$, the empty nodes serve as the extra computation power to solve the problem. In such scenarios, we are able to obtain running time that is not known to be achievable by adapting the streaming counterpart. For example, when $k=3$, $F_{0}=O(n^{1/2})$, we may approximate $F_{3}$ within a constant factor in $\operatorname{\text{{\rm polylog}}}(n)$ rounds. Direct adaption of known streaming algorithms [AKO11, MW10, AMS99] requires super-logarithmic rounds, even in the case where $F_{0}=O(n^{1/2})$.

Combining Theorem 1.3 and Theorem 1.2 with $k=p$, we have the following corollary.

Corollary 1.4**.**

If $F_{0}=O(n^{1/(p-1)})$, then there exists an algorithm in the $\mathsf{CONGEST}$ model that approximates $F_{p}$ up to a $1\pm\epsilon$ factor in $\tilde{O}(\epsilon^{-2}\cdot\tau_{G})$ rounds w.h.p.

1.2 Related work and preliminaries

Related work

In the distributed setting, Kuhn et al. [KLS08] studied the problem of finding the mode, i.e., the most frequent element, in the $\mathsf{CONGEST}$ model. Let $D$ is the diameter of the graph, and $f^{*}$ is the largest number of occurrences among the values. They gave an algorithm that uses $O(D+F_{2}/f^{*}\cdot\log k)$ rounds. They also briefly explained how to implement streaming algorithms for approximating $F_{0}$ and $F_{2}$ in the $\mathsf{CONGEST}$ models. Also related to data summarization, Kuhn et al. [KLW07] designed selection algorithms in the $\mathsf{CONGEST}$ model.

In the data stream model, each stream token $(i,x)$ corresponds to the update $f_{i}\leftarrow f_{i}+x$. The problem of approximating the number of distinct elements $F_{0}$ and frequency moments $F_{p}$ have been extensively studied. An incomplete list includes [BJK*+*02, GT01, KNW10, AMS99, IW05, Ind06, AKO11, Woo04, Gan15]. Roughly speaking, the space complexity for approximating $F_{p}$ in the data stream model is $\tilde{O}(\epsilon^{-2})$ for $0\leq p\leq 2$ and $\tilde{O}(\epsilon^{-2}n^{1-2/p})$ for $p\geq 2$. Furthermore, it is known that approximating $F_{\infty}$ (or identifying the mode) is not possible in sublinear space. In the data stream model, researchers have also studied the problem of approximating the entropy [HNO08, CBM06, CCM10].

We will briefly discuss the similarities between the data stream model and the $\mathsf{CONGEST}$ model. Roughly speaking, since streaming algorithms use little memory, they can be adapted to the $\mathsf{CONGEST}$ model by passing the memory state of the corresponding algorithm along the breadth-first-search tree. Similarly, lower bounds from streaming algorithms literature can also be translated into lower bounds in the $\mathsf{CONGEST}$ model. Data aggregation problems have also been studied in directed networks [KO11].

There is also a rich literature in the $\mathsf{GOSSIP}$ model started by the work of [DGH*+*87]. Some examples include spreading message [FG85, Pit87, KSSV00], computing the sum and average [KDG03, CP12, KDN*+*06], renaming [GKW13], and quantile computation [HMS18].

Preliminaries

We introduce basic notations and algorithmic building blocks in the $\mathsf{CONGEST}$model.

To ease our presentation, we assume $N=O(\operatorname{\text{{\rm poly}}}(n))$. In our algorithms, we often want to learn about the sum of all the values (or hash values, indicator variables) held by the nodes; this can be done in $O(D)$ rounds. Another algorithmic primitive, based on downcasts and upcasts, is to broadcast the $k$ smallest values in $O(D+k)$ rounds.

We define the mixing time similarly to [GKS17]. A lazy random walk is a random walk in which at each step, we stay at the same node with probability 0.5 and move to a random neighbor with probability 0.5. Lazy random walk ensures the existence of a unique stationary distribution (i.e., the walk is aperiodic). From now on, we simply refer to a lazy random walk as a random walk.

Let $P^{t}_{u}=(P^{t}_{u}(v_{1}),\ldots,P^{t}_{u}(v_{n}))\in[0,1]^{n}$ denotes the probability distribution on the nodes after $t$ steps of a lazy random walk that starts at $u$. A crucial property of a random walk is that it will converge to the stationary distribution $(\deg(v_{1})/2m,\ldots,\deg(v_{n})/2m)$. Define the mixing time $\tau_{G}$ to be the minimum $t$ such that for any starting node $u$ and any node $v_{i}$,

[TABLE]

Using an $O(D)$-round pre-proscessing, we can assume that each node has a unique $\operatorname{ID}$ in $[n]$. Suppose we want the nodes in a graph to have unique IDs in $[n]$. We can elect a leader and build a breadth-first-search (BFS) tree that is rooted at the leader in $O(D)$ rounds [Pel00]. Each node $u$ can learn about the number of nodes in $T_{v}$ where $v$ is a child of $u$ and $T_{v}$ is the subtree that is rooted at $v$. This is done by aggregating the size from the leaves upward. It is then straightforward to assign the $\operatorname{ID}$s to the nodes based on the depth-first-search (DFS) ordering. Specifically, the root notifies each of its children $v$ the range of the $\operatorname{ID}$s in $T_{v}$, based on the DFS ordering, and then recurse on $T_{v}$. From now on, we can refer to the nodes by their $\operatorname{ID}$s, i.e., $\operatorname{ID}(v)=v$.

We will also make use of hash functions. An $O(1)$-wise independent hash function $h:[a]\rightarrow[b]$ where $a$ and $b$ are at most $\operatorname{\text{{\rm poly}}}(n)$ can be stored in $O(\log n)$ bits. Hence, if we need to use a hash function, a leader can broadcast such hash function (using a BFS tree) in $O(D+\log n)$ rounds in the $\mathsf{CONGEST}$model and $O(\log n)$ rounds in the $\mathsf{GOSSIP}$model.

2 Algorithms in the CONGEST Model

2.1 Approximation algorithms

Upper bounds

We show that we can adapt the streaming algorithms given by Bar-Yossef et al. [BJK*+*02] (for approximating $F_{0}$) and by Alon et al. [AMS99] (for approximating $F_{p}$, where $p\geq 2$) to the $\mathsf{CONGEST}$ model (see Appendix A). This is not of particular novelty though we need some careful pipelining arguments to optimize the number of rounds. Kuhn et al. [KLS08] also briefly outlined similar results. However, the exact round-complexity for a good approximation w.h.p. is not very clear from their paper.

Theorem 2.1**.**

There exists an $O(D+\epsilon^{-2}\log n)$-round algorithm in the $\mathsf{CONGEST}$ model that computes a $1\pm\epsilon$ approximation of $F_{0}$ and $F_{2}$ w.h.p. Furthermore, for $p>2$, there exists an $O(D+\epsilon^{-2}\min(n,N)^{1-1/p}\log n)$-round algorithm that computes a $1\pm\epsilon$ approximation of $F_{p}$ w.h.p.

Lower bounds

We show that the dependence on $\epsilon$ is tight via a conditional lower bound. Moreover, computing $F_{p}$ exactly requires $\tilde{\Omega}(n)$ rounds. The lower bounds are obtained by adapting the existing streaming lower bounds to the $\mathsf{CONGEST}$ model. Due to space constraint, we refer to Appendix A for the discussion.

Theorem 2.2**.**

We have the following lower bounds in the $\mathsf{CONGEST}$ model.

• •

If the conjecture in **[BC09]** holds, then approximating $F_{p}$ (for fixed $p\neq 1$) up to a $1\pm\epsilon$ factor requires $\Omega(D+\epsilon^{-2}/\log n)$ rounds.

• •

A $(1\pm 0.1)$-approximation of $F_{p}$, for $p>2$, requires $\Omega\left(D+\left(N^{1-\frac{2}{p}}+n^{\frac{1-2/p}{1+1/p}}\right)/\log n\right)$ rounds.

• •

Computing $F_{p}$ exactly requires $\Omega(D+n/\log n)$ rounds.

Hence, we cannot expect a sublinear algorithms (in terms of $N,n$) when $\epsilon\ll 1/\sqrt{n}$ or when we want to obtain the exact answer. The lower bounds arise in graphs with a small balanced cut which causes an information bottleneck. This observation motivates us to design an exact algorithm when the graph is well-connected.

2.2 An exact algorithm in near mixing-time

In this subsection, we show that it is possible to beat the lower bounds and achieve an exact algorithm in sublinear time if the graph has fast mixing time. For example, expander graphs are sparse and have $O(\operatorname{\text{{\rm polylog}}}n)$ mixing time.

Suppose each node has a set of messages (of size $\operatorname{\text{{\rm polylog}}}(n)$) each of which has a destination that is another node. In parts of our algorithms, we want to route messages in a small number of rounds. We rely on the following routing algorithm in the $\mathsf{CONGEST}$ model that uses $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds. We note that $2^{O(\sqrt{\log n})}$ is more than $\operatorname{\text{{\rm polylog}}}n$ but smaller than any $n^{\epsilon}$ for $\epsilon>0$. Also note that $D=O(\tau_{G})$. Let $\deg(v)$ be the degree of $v$ in $G$.

Theorem 2.3** ([GL18], [GKS17]).**

If each node of $G$ is the source and the destination of at most $d_{G}(v)\cdot 2^{O(\sqrt{\log n})}$ messages, then there is a randomized algorithm in the $\mathsf{CONGEST}$model that delivers all the messages in $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds w.h.p.

We also rely on the idea of sorting networks. Recall that we refer to the nodes by their unique $\operatorname{ID}$s in $[n]$. In a sorting network, in each step $r$, the sorting network will pick a set of disjoint pairs of nodes. We use $\operatorname{val}\left(x,r\right)$ to denote the value that node $x$ holds in the beginning of step $r$. For each pair $x$ and $y$ (where $x<y$) that is picked, $x$ will keep the smaller value $\min(\operatorname{val}\left(x,r\right),\operatorname{val}\left(y,r\right))$ and $y$ will keep the larger value $\max(\operatorname{val}\left(x,r\right),\operatorname{val}\left(y,r\right))$. We treat NULL as $-\infty$. The sorting network can be constructed, solely based on $n$, so that after $t=O(\log n)$ steps, the values are sorted [AKS83]. That is if $x<y$, then $\operatorname{val}\left(x,t\right)\leq\operatorname{val}\left(y,t\right)$.

In the $\mathsf{CONGEST}$ model, each node can generate the sorting network (note that the construction of the sorting network is independent of the topology of $G$ and the values held by the nodes). Furthermore, each step can be simulated by invoking Theorem 2.3. Thus, we have the following.

Lemma 2.4**.**

In the $\mathsf{CONGEST}$ model, we can sort the nodes’ values in $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds w.h.p.

We now complete the proof of our first main result.

Proof of Theorem 1.1.

We now use $\operatorname{val}\left(v\right)$ to refer to the value that $v$ holds after sorting. We say a node $v$ is a head or a tail if $\operatorname{val}\left(v\right)\neq-\infty$ and its $\operatorname{ID}$ is the smallest or the largest respectively among the $\operatorname{ID}$s of the nodes that hold the value $\operatorname{val}\left(v\right)$. A node $v$ can tell that if it is a head or a tail by checking with the nodes $v+1$ and $v-1$ respectively using the routing algorithm in Theorem 2.3. We use $\operatorname{head}\left(i\right)$ and $\operatorname{tail}\left(i\right)$ to denote the $\operatorname{ID}$s of the head and the tail of value $i$ respectively.

Now, every node that is not a head or a tail marks its value as $-\infty$. Each remaining node forms a token consisting of its value, $\operatorname{ID}$, and whether if it is a head or a tail (or both). We then use sorting networks again to sort the values in the graph. We will also swap the tokens if two nodes swap their values. Afterward, the head and the tail tokens of a value $i$ will be at some two nodes $v$ and $v+1$ (or just at a node $v$ if $f_{i}=1$). To this end, each node $v$ that holds a head token (that is not also a tail token) with value $i$ will check with nodes $v+1$ and $v-1$, using the routing algorithm, to collect $\operatorname{tail}\left(i\right)$ since either $v+1$ or $v-1$ must have the tail token of $i$. Now, $v$ can compute $g(f_{i})=g(\operatorname{tail}\left(i\right)-\operatorname{head}\left(i\right)+1)$ and set this as its value. All the nodes that do not hold a head token set their values to 0. We then compute $\sum_{i=1}^{N}g(f_{i})$ using the BFS tree in $O(D)$ rounds. ∎

The algorithm above is more robust compared to the AMS sketch since it can handle all fixed and computable functions $g$. The AMS sketch cannot guarantee sublinear space in the streaming model (or sublinear time in the $\mathsf{CONGEST}$ model) for many functions [BO10, BC15, BCWY16]. The above algorithm also immediately leads to an algorithm that finds the top $k$ frequent elements.

Finding the top $k$ frequent elements

At the end of the above algorithm, the occurrence of each value $i$ is held by some node $v$. Recall we can find the top $k$ elements in the graph using $O(D+k)$ rounds via upcasts. This immediately leads to the following result.

Theorem 2.5**.**

There exists an algorithm that finds the top $k$ elements (along with their occurrences) in the $\mathsf{CONGEST}$ model in $O(k+\tau_{G}\cdot 2^{O(\sqrt{\log n})})$ rounds w.h.p.

3 Emulation of GOSSIP Model in the CONGEST Model

In Section 2, we have shown that the moments can be computed exactly in $\tau_{G}\cdot 2^{O(\sqrt{\log n})}$ rounds. If the permutation routing algorithm can be improved to $\operatorname{\text{{\rm polylog}}}(n)$ rounds, then the running time of our algorithms would be improved to $\tilde{O}(\tau_{G})$ rounds. Whether the $2^{O(\sqrt{\log n})}$ factor can be improved to $\operatorname{\text{{\rm polylog}}}(n)$ is an intriguing open question.

Instead of tackling the complexity of permutation routing, in this section, we show that one round of the GOSSIP model can be emulated almost-perfectly in $\tilde{O}(\tau_{G})$ rounds in the CONGEST model. Therefore, if there is a $\operatorname{\text{{\rm polylog}}}(n)$-round algorithm in the GOSSIP model, it implies a $\tilde{O}(\tau_{G})$ rounds algorithm in the CONGEST model. In Section 4, we present efficient algorithms in the $\mathsf{GOSSIP}$ model when $F_{0}$ is small (or when the number of empty nodes is large) which can be translated back to the CONGEST model using the emulation result in this section.

Recall that $P^{t}_{u}=(P^{t}_{u}(v_{1}),\ldots,P^{t}_{u}(v_{n}))\in[0,1]^{n}$ denotes the probability distribution on the nodes after $t$ steps of a lazy random walk that starts at $u$ (see Section 1.2). Given $\lambda$, we let $\tau_{G}(\lambda)$ be the smallest $t$ such that for any starting node $u$ and any node $v_{i}$,

[TABLE]

Note that if $\lambda=1/\operatorname{\text{{\rm poly}}}(n)$ then $\tau_{G}(\lambda)=O(\tau_{G})$ [GKS17, Definition 2.1].

We will run several random walks in parallel. The following lemma from [GKS17] shows that the parallel random walks can be performed efficiently in the CONGEST model.

Lemma 3.1** ([GKS17], Lemma 2.5).**

Let $G=(V,E)$ be an $n$-node graph and let $t\geq 1$ be a positive integer. Assume that we perform $T=O(\operatorname{\text{{\rm poly}}}(n))$ steps of a collection of independent random walks in parallel. If each node $u\in V$ is the starting node of at most $t\cdot\deg(u)$ random walks, w.h.p., the $T$ steps of all the random walks can be performed in $O((t+\log n)\cdot T)$ rounds in the $\mathsf{CONGEST}$model.

The main technical difficulty of the emulation lies in the fact that the stationary distribution is not necessarily uniform in general graphs. If $G$ is regular, we could let each node $u$ start a random walk that runs for $O(\tau_{G})$ steps. The probability that $u$ ends at each node is (nearly) uniform. If it ends at $v$ then we set $t(u)=v$. Moreover, by Lemma 3.1, all the random walks can be performed simultaneously in $\tilde{O}(\tau_{G})$ rounds.

In irregular graphs, such approach does not work because the stationary distribution is not uniform. One remedy is to regularize the random walk (i.e. adding self-loops to non-maximum degree nodes). However, this may significantly increase the mixing time of the graph (e.g., a star graph). In the following, we give an emulation algorithm whose running time is within a $\operatorname{\text{{\rm polylog}}}(n)$ factor of the mixing time.

For each node $u$ in $G$, we split it into $\deg(u)$ compartments. When a random walk enters a node, it is assigned randomly to one of its compartments. There are $2m$ compartments in $G$ in total. We outline the emulation algorithm below.

Let $k=\lfloor 1.5m/n\rfloor$. Each node creates $k$ destination tokens and distributes them over the compartments in $G$ so that each compartment contains at most one destination token. Now $n\cdot k\approx 1.5m$ compartments are filled with tokens. 2. 2.

Each node sends out a source token. Each source token starts a random walk to distribute itself randomly over the compartments at the end. If the source token of node $u$ ends in a compartment with the destination token of some node $v$, we set $t(u)=v$. 3. 3.

Route the message between $u$ and $t(u)$ for each $u$ simultaneously.

We explain how to implement each step in details.

Step 1

Each node $u$ creates a destination token $(u,k)$ initially. The first component of the token is its identity while the second component of the token is its multiplicity. The goal is to split the tokens and distribute them across the compartments so that all tokens have multiplicity of 1 and each compartment holds at most one token. We divide Step 1 into the splitting phase and the distributing phase.

The splitting phase is further divided into $\lceil\log k\rceil$ stages. At the beginning of each stage, if $W>1$, each token $(u,W)$ is split into two tokens $(u,\lceil W/2\rceil)$ and $(u,\lfloor W/2\rfloor)$. Then all tokens perform $\tau_{G}$ steps of random walks.

We show that w.h.p., there are at most $O(\log n)$ tokens per compartment at the end of each stage. Given a stage, the probability that a token ends up in a given compartment in node $v$ is at most

[TABLE]

Since there are at most $k\cdot n\leq 1.5m$ tokens, there are at most $O(1)$ tokens ending in a compartment in expectation. By standard Chernoff and union bound argument, w.h.p. there are at most $O(\log n)$ tokens in each compartment.

Moreover, since each node $u$ holds at most $\deg(u)\cdot O(\log n)$ tokens at the beginning of each stage, the random walks can be performed in parallel in $O(\tau_{G}\cdot\log n)$ rounds by Lemma 3.1. Therefore, the splitting phase uses $O((\log k)\cdot(\tau_{G}\cdot(\log n)))=\tilde{O}(\tau_{G})$ rounds. At the end of the splitting phase, the multiplicity of each token is one. Moreover, w.h.p. each compartment contains at most $O(\log n)$ tokens.

In the distributing phase, a compartment containing more than one token will start the random walks on all except one of its token for $\tau_{G}(0.1/2m)$ steps. Again, by Lemma 3.1, this can be done simultaneously for all nodes in $O(\tau_{G}\cdot\log n)$ rounds. At the end of the random walks, we say a token succeeds if it ends at a compartment without any other tokens. If a token does not succeed, it will go back to the origin. The process is repeated until there is no compartment containing more than one token. Since there are at most $n\cdot k\leq 1.5m$ tokens, at most $1.5m$ compartment can be occupied. Since we run the random walks for $\tau_{G}(0.1/2m)$ steps, the probability that a random walk ends at a specific compartment is at most $1.1/2m$. Thus, the probability that a token does not succeed is at most $(1.5m)\cdot(1.1/(2m))=1.65/2$.

Therefore, a token will succeed w.h.p. after at most $O(\log n)$ trials. By a union bound over the tokens, w.h.p. all tokens succeed after $O(\log n)$ trials. The total running time is $O(\log n\cdot(\tau_{G}\log n))=\tilde{O}(\tau_{G})$.

Step 2

Each node $u$ creates a source token. The tokens start to perform random walk for $\tau_{G}(\lambda^{\prime})$ steps, where $\lambda^{\prime}=\min(\lambda/(8m),0.1/m)$ (see Figure 2(a)). If the source token of $u$ ends up in one out of the $k$ compartments with a destination token of $v$, $t(u)$ will be set to $v$. Otherwise, if it ends up in a compartment without any destination tokens, it will restart the random walk. The process will be repeated until the source token ends up in a compartment with some destination token.

By our choice of $\lambda^{\prime}$, the probability that a token ends at a specific node is at least $0.9/(2m)$. Therefore, the probability that a token successfully ends up in a compartment with a destination token after the random walk is at least

[TABLE]

The second inequality follows from $m\geq n-1$ and the third inequality holds for $m\geq 4$. Thus, the number of random walks a token needs to perform until it ends up at a node with some destination token is at most $O(\log n)$ w.h.p. By taking a union bound over all the $n$ tokens, we conclude that w.h.p. every token performs at most $O(\log n)$ random walks. The random walks can be performed simultaneously in $O(\tau_{G}\cdot\log n)$ rounds, so w.h.p. the total number of rounds is $O(\tau_{G}\cdot\log^{2}n)$.

Next, we show that given two nodes $u,v$, $\Pr(t(u)=v)\in[(1-\lambda)/n,(1+\lambda)/n]$. Let $\mathcal{E}_{v}$ denote the event that the source token of $u$ ends up in a compartment with a destination token of $v$. Let $\mathcal{E}$ denote the event that the source token of $u$ ends up in a compartment with some destination token.

By our choice of $\tau(\lambda^{\prime})$, we have that for all $v$, $\Pr(\mathcal{E}_{v})\in\left[\frac{k}{2m}-k\lambda^{\prime},\frac{k}{2m}+k\lambda^{\prime}\right]$ and $\Pr(\mathcal{E})\in\left[n\left(\frac{k}{2m}-k\lambda^{\prime}\right),n\left(\frac{k}{2m}+k\lambda^{\prime}\right)\right]$. Therefore,

[TABLE]

Note that since all the source tokens perform random walks independently, when we condition on the choice of nodes in $Z$ for any $u\notin Z\subseteq V$, it is still true that

[TABLE]

and

[TABLE]

Thus, $\Pr\left(t(u)=v|\bigwedge_{z\in Z}t(z)\right)\in[(1-\lambda)/n,(1+\lambda)/n]$.

Step 3

It remains to show that the messages from $u$ to $t(u)$ can be routed simultaneously for every $u$ in $\tilde{O}(\tau_{G})$ rounds.

Let $mid(u)$ denote the node where the source token of $u$ is located at the end of Step 2. The message from $u$ to $mid(u)$ for every $u$ can be simultaneously routed in $\tilde{O}(\tau_{G})$ rounds by following the same path taken by the random walk of the source token of $u$.

Suppose that $t(u)=v$. After the message reaches $mid(u)$, it will follow the path taken by the random walk of the destination token of $v$ to go to $v$ (see Figure 2(b)). Note that multiple source tokens may be matched to a node $v$ (some possibly from the other destination tokens of $v$). When they follow the paths that lead back to $t(v)$, it is possible that these paths merge and create congestion. However, using a standard Chernoff Bound argument, we can show that for any node $v$ w.h.p. at most $O(\log n)$ different nodes $u$ have $t(u)=v$. Therefore, each step of the parallel random walk can be done with a $O(\log n)$ factor blowup. Thus, the messages between $u$ and $t(u)$ can be routed in $\tilde{O}(\tau_{G})$ rounds. This completes the proof of Theorem 1.2.

4 Algorithms in the GOSSIP Model

In this section, we show that if we have a small number of non-empty nodes, then the empty nodes help approximate $F_{p}$ faster. As stated in Corollary 1.4, this result can be translated back to the $\mathsf{CONGEST}$ model using Theorem 1.2 with a blow-up factor $\tilde{O}(\tau_{G})$. We exhibit a pre-processing step that duplicates the values so that $\Omega(n)$ nodes become non-empty which is crucial for the algorithms to work while preserving the occurrence ratios.

Throughout this section, for the sake of clarity, we consider the $\mathsf{GOSSIP}(0)$ model. However, running our algorithms in $\mathsf{GOSSIP}(1/n^{c})$, for some sufficiently large constant $c$, only incurs a small additive error $1/\operatorname{\text{{\rm poly}}}(n)$.

Lemma 4.1**.**

If the number of non-empty nodes $z<n/3$, we can duplicate the values so that $z\lceil(n/3)/z\rceil$ nodes become non-empty while preserving the occurrences ratios in $O(\log^{2}n)$ rounds in the $\mathsf{GOSSIP}$model.

Proof.

We divide the process into three phases.

Pre-processing

We assume that the number of non-empty nodes is less than $n/3$, otherwise, we are done. First, the nodes compute the number of non-empty nodes $z$ in $O(\log n)$ rounds [KDG03]. Each node $v$ will form a token that contains $\operatorname{val}\left(v\right)$ and $t$ where $t$ is originally set to $\lceil(n/3)/z\rceil$.

Splitting Phase: This phase consists of $O(\log n)$ stages each of which consists of $O(\log n)$ sub-stages. At the beginning of each stage, a node $v$ has a collection of tokens $(x_{1},t_{1}),(x_{2},t_{2}),\ldots$ in its buffer. Each token $(x_{i},t_{i})$ is split into two tokens $(x_{i},\lceil t_{i}/2\rceil)$ and $(x,\lfloor t_{i}/2\rfloor)$. It will send these two tokens to two random nodes using two rounds and delete $(x_{i},t_{i})$ from its buffer. Note that the new tokens $(x_{i},\lceil t_{i}/2\rceil)$ and $(x,\lfloor t_{i}/2\rfloor)$ will not be split until the next stage. Every stage produces at most $z\lceil(n/3)/z\rceil\leq 2n/3$ new tokens. Each new token is sent to a random node and therefore each node contains $O(\log n)$ new tokens w.h.p by Chernoff bound at the end of that stage. Hence, each sub-stage requires at most $O(\log n)$ rounds to split all the tokens in its buffer w.h.p. After $O(\log n)$ stages, w.h.p all nodes contain $O(\log n)$ tokens and all tokens $(x,t)$ satisfy $t=1$.

Distributing Phase: At this point, we only have tokens in the form $(x,1)$, or simply $x$. In each stage, if $v$ holds more than one token, it will send all but one token (say the first that arrives at $v$) to the nodes that it talks to. By a standard Chernoff bound argument, each stage requires $O(\log n)$ rounds since each node always holds at most $O(\log n)$ tokens w.h.p. We say a token $x$ succeeds if it lands in a previously empty node $u$ while no other token lands in $u$ in the same round. Then, $u$ never sends $x$ away from this point onward. Since we have at most $z\cdot\lceil(n/3)/z\rceil\leq 2n/3$ tokens, at least $n/3$ nodes are empty at all times. Consider a token $x$. In each stage, conditioning on all other tokens’ choices, with probability at least $1/3$, $x$ succeeds. Hence, after $O(\log n)$ stages, $x$ succeeds w.h.p and therefore all tokens succeed w.h.p by taking a union bound over all tokens. Since we have at least $\lceil n/3\rceil$ tokens, the number of non-empty nodes is $\Omega(n)$. Note that the occurrence of each value is rescaled by a factor $\lceil(n/3)/z\rceil$. ∎

After we estimate $F_{p}$ of the new instance, we can divide the estimator by $(\lceil(n/3)/z\rceil)^{p}$ to get an estimate for $F_{p}$ in the original instance. From now on, we can safely assume that the number of non-empty nodes $F_{1}=\Omega(n)$, otherwise, we can apply the above pre-processing. A key observation is that $F_{0}\leq z$, and thus we can analyze our algorithms for when $F_{0}$ is small instead.

An $\ell_{p}$-sampling primitive

An $\ell_{p}$-sampling algorithm samples a value $i\in[N]$ with probability $f_{i}^{p}/F_{p}$. More formally, \Pr\left(\text{sample i}\right)={f_{i}^{p}}/{F_{p}}.

The $\ell_{p}$-sampling primitive (for $0\leq p\leq 2$) has been extensively studied in the data stream model. An incomplete list includes [AKO11, JW18, MW10, JST11]. However, most streaming $\ell_{p}$-samplers are rather complicated, and it is unclear how to implement them in the $\mathsf{GOSSIP}$ model.

It is trivial to obtain an $\ell_{1}$-sample by virtue of the $\mathsf{GOSSIP}$ model. To obtain an $\ell_{0}$-sample (a random value that occurs at least once), we broadcast a randomly chosen pairwise hash function $h:[N]\rightarrow[N^{3}]$ and identify the value corresponds to the smallest hash value in $O(\log n)$ rounds.

Assuming that $p$ is fixed, we now show that if $F_{0}=O\left(n^{1/(p-1)}\right)$, then we can perform $\ell_{p}$-sampling in $O(\log n)$ rounds (hence $\ell_{2}$-sampling can always be done in $O(\log n)$ rounds since $F_{0}\leq n$). The sampling algorithm proceeds as follows.

Each node $v$ uses $p$ rounds to talk to $p$ random nodes $u_{1},\ldots,u_{p}$. It declares success if $\operatorname{val}\left(u_{1}\right)=\ldots=\operatorname{val}\left(u_{p}\right)$. In that case, let $\operatorname{val}\left(u_{1}\right)$ be $v$’s sample. Among the successful nodes, to break symmetry, broadcast the sample of the node with the smallest $\operatorname{ID}$. If no node succeeds, repeat the process. The following lemma provides a lower bound on $F_{p}$ based on $F_{0}$.

Lemma 4.2**.**

If $F_{1}=\Omega(n)$ and $F_{0}=O\left(n^{1/(p-1)}\right)$, then $F_{p}=\Omega\left(n^{p-1}\right)$.

Proof.

Let the frequency vector be $f=\left(f_{1},\ldots,f_{N}\right)$. Without loss of generality, suppose the potentially non-zero entries of $f$ be $f_{1},\ldots,f_{Kn^{1/(p-1)}}$ for some constant $K$. Note that based on our assumption, $f_{j}=0$ for all $j>Kn^{1/(p-1)}$. Let $f^{\prime}=\left(f_{1},\ldots,f_{Kn^{1/(p-1)}}\right)$ be the vector formed by the first $Kn^{1/(p-1)}$ entries. Note that $\|f^{\prime}\|_{1}\geq Cn$ for some constant $0<C\leq 1$ as assumed.

We will use the following inequality: if the vector $x$ has $n$ entries then

[TABLE]

Note that $f^{\prime}$ has $Kn^{1/(p-1)}$ entries. Let $K^{\prime}=K^{1-1/p}$. We have

[TABLE]

The last step follows since $K$ and $C$ are constants and $p$ is fixed. ∎

Theorem 4.3**.**

If $F_{0}=O\left(n^{1/(p-1)}\right)$, then the described algorithm obtains an $\ell_{p}$-sample in $O(\log n)$ rounds in the $\mathsf{GOSSIP}$model w.h.p.

Proof.

We can apply the pre-processing step so that $F_{1}=\Omega(n)$ while the occurrences ratios are preserved. The probability that a node succeeds is $\Omega\left(\sum_{i=1}^{N}{f_{i}^{p}}/{n^{p}}\right)=\Omega\left({F_{p}}/{n^{p}}\right)$.

Appealing to Lemma 4.2, $F_{p}\geq n^{p-1}/K^{\prime}$ for some constant $K^{\prime}$. Hence, \Pr\left(\text{v succeeds}\right)\geq 1/(K^{\prime}n). The probability that all $n$ nodes fail is at most $\left(1-1/(K^{\prime}n)\right)^{n}\leq e^{-1/K^{\prime}}$. We therefore succeed w.h.p by repeating $O(\log n)$ times. Given that $v$ succeeds, the probability that it samples value $i$ is $\left({f_{i}^{p}/n^{p}}\right)/\left({\sum_{j=1}^{N}f_{j}^{p}/n^{p}}\right)={f_{i}^{p}}/{F_{p}}$ as required. ∎

Approximating $F_{p}$

The algorithm by Bar-Yossef et al. [BJK*+*02] that we discuss in Appendix A for approximating $F_{0}$ up to a $1\pm\epsilon$ factor w.h.p can be emulated in the $\mathsf{GOSSIP}$ model in $O(\epsilon^{-2}\log^{2}n)$ rounds. We now focus on approximating higher frequency moments. Let $k\leq p$ be an integer. We present an algorithm that w.h.p approximates $F_{p}$ (for $p\geq 2$) in $\tilde{O}\left(\epsilon^{-2}n^{1-k/p}\right)$ rounds if $F_{0}=O\left(n^{1/(k-1)}\right)$. Recall that $F_{0}$ is at most the number of non-empty nodes. To approximate $F_{p}$, our algorithm makes use of an approximation of $F_{k}$ and $\ell_{k}$-sampling. This generalizes the approach in [AKO11, MW10]. We will prove the following theorem.

We first consider the following algorithm that approximates $F_{k}$. For $j=1,\ldots,C\epsilon^{-2}\log n$, where $C$ is some sufficiently large constant, in the $j$-th phase, each non-empty node $v$ uses $k-1$ rounds to talk to $k-1$ random nodes $u_{1},\ldots,u_{k-1}$. It declares success if $\operatorname{val}\left(v\right)=\operatorname{val}\left(u_{1}\right)=\ldots=\operatorname{val}\left(u_{k-1}\right)$. Let $I_{j,v}$ be the indicator variable for the event $v$ succeeds in the $j$-th phase. Let $T=C\epsilon^{-2}\log n$. Return the estimate

[TABLE]

We now prove Theorem 1.3. This theorem first shows that $\hat{F}_{k}$ is a good approximation w.h.p. Then, it combines $\hat{F}_{k}$ with $\ell_{k}$-sampling to compute a good estimate of $F_{p}$ in $O\left(\epsilon^{-2}n^{1-k/p}\log^{2}n\right)$ rounds.

Proof of Theorem 1.3.

We again can assume that $F_{1}=z=\Omega(n)$ as outlined earlier in this section. We first show that $\hat{F}_{k}=(1\pm\epsilon)F_{k}$ w.h.p. In expectation,

[TABLE]

Since the indicator variables $I_{j,v}$ are independent, we can apply Chernoff bound directly.

[TABLE]

The first inequality follows from Lemma 4.2 and the second inequality is because $T=C\epsilon^{-2}\log n$ for some sufficiently large constant $C$. Hence, we can approximate $F_{k}$ up to a $1\pm\epsilon$ factor in $O(\epsilon^{-2}\log n)$ rounds.

To approximate $F_{p}$ for $p>k$, we use the following estimator. Let $i$ be an $\ell_{k}$ sample. We can compute $f_{i}$ exactly in $O(\log n)$ rounds. Specifically, each node with value $i$ will put $1$ on it and 0 otherwise. Then, we can compute the sum using the algorithm in [KDG03]. Consider the following estimator:

[TABLE]

We rely on the following lemma. We defer the proof to the end of this section.

Lemma 4.4**.**

We have $\textup{E}\left[\hat{F}_{p}\right]=(1\pm O(\epsilon))F_{p}$ and ${\textup{V}}\left[\hat{F}_{p}\right]\leq 2n^{1-k/p}F_{p}^{2}$.

Hence, by an application of Chebyshev bound, if we take the average of $O\left(n^{1-k/p}\epsilon^{-2}\right)$ estimators, with constant probability, $\hat{F_{p}}=(1\pm\epsilon)F_{p}$. We can amplify the success probability to $1-1/\operatorname{\text{{\rm poly}}}(n)$ by the standard median trick, i.e., taking the median of $O(\log n)$ such estimators. ∎

Proof of Lemma 4.4.

In expectation,

[TABLE]

We can bound the variance as follows.

[TABLE]

We have $\|f\|_{k}\leq n^{1/k-1/p}\|f\|_{p}$, and therefore $F_{k}\leq n^{1-k/p}F_{p}^{k/p}$. Additionally, $\|f\|_{2p-k}\leq\|f\|_{p}$ which implies $F_{2p-k}\leq F_{p}^{2-k/p}$. Therefore, ${\textup{V}}\left[\hat{F}_{p}\right]\leq 2n^{1-k/p}F_{p}^{2}$. ∎

Appendix A Upper and Lower Bounds for Approximating $F_{p}$ in the CONGEST model

A.1 Upper bounds

Approximating $F_{0}$

We show how to run the algorithm by Bar-Yossef et al. [BJK*+*02] in the $\mathsf{CONGEST}$ model. Kuhn et al. [KLS08] also outlined how to run a different streaming algorithm for estimating $F_{0}$. However, the number of rounds for a $1\pm\epsilon$ approximation w.h.p is unclear in their paper.

The algorithm is as follows. We pick a pairwise hash function $h:[N]\rightarrow[M]$. Let $t=\lceil 100\epsilon^{-2}\rceil$, $M=N^{3}$, and $w$ be the $\lceil t\rceil$-th smallest value among the hash values $W=\{h(\operatorname{val}\left(v\right)):v\in V\}$. We have the following: $tM/w$ is a $1\pm\epsilon$ approximation of $F_{0}$ with probability at least 2/3 [BJK*+*02].

In the $\mathsf{CONGEST}$ model, the leader can broadcast the hash function. Then, each node $v$ computes $h(\operatorname{val}\left(v\right))$. As mentioned above, the nodes can find the $t$-th smallest hash value in $W$ in $O(D+t)$ rounds. Hence, the total number of rounds is $O(D+\epsilon^{-2})$ for constant success probability.

To amplify the success probability to $1-1/\operatorname{\text{{\rm poly}}}(n)$, we use $\log n$ different hash functions and take the median of the corresponding estimates. At first, it is unclear how to pipeline this approach on the BFS tree to run in $O(D+\epsilon^{-2}\log n)$ rounds instead of $O(\log n\cdot(D+\epsilon^{-2}))$ rounds. We show that this is possible. The following lemma generalizes Lemma 4.3.1 in [Pel00].

Lemma A.1**.**

Suppose each element belongs to exactly one of $k$ groups. Upcasting the $t$ smallest elements of $k$ groups on a tree $T$ can be performed in $O(0pt(T)+kt)$ rounds in the $\mathsf{CONGEST}$model.

Proof.

Let the levels of the nodes be $1,2,\ldots,0pt(T)$ where the root is at level $0pt(T)$. For each node $v$, from round $\textup{level}(v)+j$ to $\textup{level}(v)+j+t-1$, it sends the smallest value in group $j$ in its memory that has not been sent before to its parent.

Suppose that the $i$-th smallest element of group $j$ is in the subtree $T_{v}$ (the subtree that is rooted at $v$) originally. Then, we claim that at the end of round $\textup{level}(v)+j+i-1$, it will be stored in $v$. Furthermore, at the end of round $\textup{level}(v)+j+i$, it will be upcasted to $v$’s parent. We prove by triple-induction on $\textup{level}(v),j$ and $i$. The base case where $\textup{level}(v)=1,j=1,i=1$ can easily be checked.

Consider a node $v$ where $\textup{level}(v)=\ell$. Suppose the $i$-th smallest element $x$ of group $j$ is in $T_{v}$ originally. We first need to show that at the end of round $\ell+j+i-1$, the element $x$ is sent to $v$. We know that one of $v$’s children, say $u$, must have $x$ in $T_{u}$; note that $\textup{level}(u)=\ell-1$. By induction, at the end of round $(\ell-1)+j+i$, we know that $u$ must have sent $x$ to $v$. It remains to show that at the end of round $\ell+j+i$, $v$ will send $x$ to its parent. By induction, all the $i^{\prime}$-th smallest elements of group $j$ that are in $T_{v}$, where $i^{\prime}<i$, must have been upcasted to $v$’s parent at the end of round $\ell+j+i-1$. Hence, $v$ must upcast the $i$-th smallest value of group $j$ to its parent at the end of round $\ell+j+i$. Therefore, after $O(0pt(T)+kt)$ rounds, the root must have all the desired values. It can downcast them back to other nodes in $O(0pt(T)+kt)$ rounds. ∎

As a result, we can find all $O(\epsilon^{-2})$ smallest hash values of each of $O(\log n)$ hash functions in $O(D+\epsilon^{-2}\log n)$ rounds using the BFS tree.

Approximating $F_{2}$

To approximate the second frequency moment $F_{2}$, we adapt the well-known tug-of-war sketch in [AMS99] to the $\mathsf{CONGEST}$ model. The adaptation, using $O(D+\epsilon^{-2}\log n)$ rounds, for a $1\pm\epsilon$ approximation with high probability is quite simple and can be found in [KLS08].

Approximating $F_{p}$ (for $p>2$)

The AMS sketch for $F_{p}$ in [AMS99] can be adapted to the $\mathsf{CONGEST}$ model as follows. First, the leader samples a node $v$ and try to compute $r=\left|\{u\in V:u>v\land\operatorname{val}\left(u\right)=\operatorname{val}\left(v\right)\}\right|$. We can compute $r$ in $O(D)$ rounds. After the leader broadcasts $v$, we let $v$ broadcasts its value $\operatorname{val}\left(v\right)$. Finally, each node $u$ now knows if $u>v$ and $\operatorname{val}\left(u\right)=\operatorname{val}\left(v\right)$. Then, we can compute the sum $r=\sum_{u\in V}I\left[u>v\land\operatorname{val}\left(u\right)=\operatorname{val}\left(v\right)\right]$. All of these steps can be done in $O(D)$ rounds. Let $X=n(r^{p}-(r-1)^{p})$. One can argue that $\textup{E}\left[X\right]=F_{p}$. Furthermore, if we repeat $O(\epsilon^{-2}\min(n,N)^{1-1/p}\log n)$ times and take the average as the final estimate $\hat{X}$, it can be shown that $\hat{X}$ is a $1\pm\epsilon$ approximation of $F_{p}$ with high probability [AMS99].Thus, we obtain an $O(D+\epsilon^{-2}\min(n,N)^{1-1/p}\log n)$-round algorithm via a careful pipelining.

We summarize the discussion above in Theorem 2.1.

A.2 Lower bounds

$\Omega(D)$ lower bound for approximating $F_{p}$ up to a $1\pm 0.1$ factor

We now present lower bounds suggesting that these algorithms are tight. This provides a clear context and a good motivation for our exact algorithm in Section 2.2 which is one of our main results. It is easy to see that $\Omega(D)$ rounds are required for some constant approximation. Consider $n$ nodes $a_{1},\ldots,a_{n}$ that are connected to one end $c_{1}$ of a chain $c_{1},\ldots,c_{D}$. Let the nodes $b_{1},\ldots,b_{n}$ connect to the other end $c_{D}$ of the chain. Set $\operatorname{val}\left(a_{i}\right)=i$ for all $i$ and $\operatorname{val}\left(c_{j}\right)=\textup{NULL}$ for all $j$. In the first case, $\operatorname{val}\left(b_{i}\right)=i$ and in the second case $\operatorname{val}\left(b_{i}\right)=i+n$. In order for each $a_{i}$ to distinguish between the two cases, $\Omega(D)$ rounds are clearly needed. In the first case, $F_{0}=n$ and in the second case $F_{0}=2n$ (for $p\neq 0$, the first case corresponds to $F_{p}=n2^{p}$ and the second case corresponds to $F_{p}=2n$). A $(1\pm 0.1)$ approximation for $p\in\{0,2,3,\ldots\}$ distinguishes the two cases and therefore requires $\Omega(D)$ rounds.

Conditional $\tilde{\Omega}(\epsilon^{-2})$ lower bound for approximating $F_{p}$ up to a $1\pm\epsilon$ factor

We now reason why the above algorithms might be optimal for a $1\pm\epsilon$ approximation, in terms of $\epsilon$, based on a conjecture of Brody-Chakrabarti [BC09]. For $F_{p}$ (where $p\neq 1$ is a fixed), we consider the following communication problem in which Alice and Bob have the sets $A\subseteq[N]$ and $B\subseteq[N]$ respectively. Let $C$ be the multiset formed by $A$ and $B$. The goal is to estimate $F_{p}(C)$ up to a $1\pm 1/\sqrt{N}$ factor with some sufficiently large constant success probability. For this problem, Woodruff gave a one-round lower bound $\Omega(N)$ on the number of bits that Alice and Bob need to communicate, via a reduction from the one-way Gap-Hamming-Distance problem of size $N$ [Woo04]. Hence, if $\epsilon=\Theta(1/\sqrt{N})$, this implies an $\Omega(\epsilon^{-2})$ lower bound.

It is conjectured in [BC09] (see conjecture 2) that the total communication of the Gap-Hamming-Distance problem of size $N$, irrespective of the number of rounds, must be $\Omega(N)$ bits. Hence, if Alice and Bob can communicate $O(\log n)$ bits in each round, the number of rounds must be $\Omega(\epsilon^{-2}/\log n)$.

Assuming their conjecture holds, then in the worst case, $\Omega(\epsilon^{-2}/\log n)$ rounds are needed in the $\mathsf{CONGEST}$ model to approximate $F_{p}$ up to a $1\pm\epsilon$ factor. To see this, consider a graph $G$ of $2N$ nodes, i.e., $n=\Theta(N)$. If $i\in A$, then Alice sets $\operatorname{val}\left(i\right)=i$, otherwise, she sets $\operatorname{val}\left(i\right)=\textup{NULL}$. Similarly, if $i\in B$ then Bob sets $\operatorname{val}\left(N+i\right)=i$, otherwise, he sets $\operatorname{val}\left(N+i\right)=\textup{NULL}$. One example that works is that $L$ and $R$ are cliques and $(1,N+1)\in E$. In fact, the conditional lower bound holds for any graph in which $L$ and $R$ are connected component and $|E(L,R)|=O(1)$.

Observe that $G$ is connected as required, but in each round, only $O(\log n)$ bits can be communicated between $L$ and $R$ via the edge $(1,N+1)$. Hence, if we can approximate $F_{p}(C)$ up to a $1\pm\epsilon$ factor in $G$ in $r$ rounds, it means that Alice and Bob can use this as a protocol to approximate $F_{p}(C)$ using $O(r\log n)$ bits of communication and therefore $r=\Omega(\epsilon^{-2}/\log n)$. In this construction, $n=\Omega(N)$.

$\tilde{\Omega}(N^{1-2/p})$ lower bound for approximating $F_{p}$ up to a $1\pm 0.1$ factor

We also observe that approximating $F_{p}$ (for $p>2$) cannot be done in fewer than $O(N^{1-2/p}/\log n)$ rounds. This is based on a suitable modification of the reduction in [AMS99]. In the $t$-player disjointness problem, player $i$ has the set $A_{i}$ and the players want to learn (with some sufficiently high constant success probability) if the all the sets are disjoint (YES case) or they intersect at a unique element (NO case), with the promise that one of the two cases happens. In the blackboard model, the players can send messages to a blackboard for others to see. The total size of all the messages must be at least $\Omega(N/t+\log N)$ [CKS03]. Consider a graph with $t$ parts each of which is a clique of $N$ nodes. The $i$-th part encodes $A_{i}$ in the same fashion above. It is easy to see that if $t>2^{1/p}N^{1/p}$, then, a $(1\pm 0.1)$-approximation of $F_{p}$ can distinguish the YES case ($F_{p}\leq N$) and the NO case ($F_{p}\geq t^{p}>2N$). Each part connects with a node $b$ that serves as a blackboard via a single edge. In each round in the $\mathsf{CONGEST}$ model, the players can send $O(t\log n)$ bits of message to the blackboard in total. Hence, the number of rounds must be $\Omega(N/(t^{2}\log n))=\Omega(N^{1-2/p}/\log n)=\Omega(n^{(1-2/p)/(1+1/p)}/\log n)$, since $n=t\cdot N=\Theta(N^{1+1/p})$.

An $\tilde{\Omega}(n)$ lower bound for computing $F_{p}$ exactly

Next, we give a simple unconditional lower bound for computing $F_{p}$ exactly. Consider the 2-player disjointness problem. In the NO case, we have $F_{0}=|A|+|B|-1$ and in the YES case, we have $F_{0}=|A|+|B|$. For general $p$, the NO case corresponds to $F_{p}=|A|+|B|-2+2^{p}$ and the YES case corresponds to $F_{p}=|A|+|B|$. Hence, for $p\neq 1$, given an exact algorithm for $F_{p}$ in the $\mathsf{CONGEST}$ model that uses $r$ rounds, the two players can use that to solve Disjointness with $O(r\log n)$ bits of communication (they use 2 extra rounds to send each other $|A|$ and $|B|$). Hence, $r=\Omega(n/\log n)$.