Graph reconstruction in the congested clique

Abstract

In this paper we study the reconstruction problem in the congested clique model. Given a class of graphs $\mathcal{G}$, the problem is defined as follows: if $G\notin \mathcal{G}$, then every node must reject; if $G\in \mathcal{G}$, then every node must end up knowing all the edges of G. The cost of an algorithm is the total number of bits received by any node through one link. It is not difficult to see that the cost of any algorithm that solves this problem is $\mathrm{\Omega }(\log |{\mathcal{G}}_n|/n)$, where ${\mathcal{G}}_n$ is the subclass of all n-node labeled graphs in $\mathcal{G}$. We prove that the lower bound is tight and that it is possible to achieve it with only 2 rounds.

Introduction

The congested clique model –a message-passing model of distributed computing introduced by Lotker, Patt-Shamir, Pavlov, and Peleg [26]– is receiving increasingly more attention [5], [12], [13], [14], [16], [20]. In the congested clique, the underlying communication network is the complete graph. Therefore, in this network of diameter 1, the issue of locality is taken out of the picture. The focus is set on congestion, which is, together with locality, the main issue in distributed computing. The point is the following: if the communication network is a complete graph and the cost of local computation is ignored, then the only obstacle to perform any task is due to congestion alone.

Despite the theoretical motivation of the congested clique model, examples of distributed and parallel systems, where the efficiency depends heavily on the bandwidth and therefore might benefit from our results, are becoming increasingly common. For instance, in [17], the authors show that fast algorithms in the congested clique model can be translated into fast algorithms in the MapReduce model. MapReduce is a well-known, popular parallel-programming framework for processing large scale data [6]. Other similar systems are Pregel [27], Spark [35], Hadoop [34], Dryad [19], etc.

Many theoretical models, aiming to bridge the gap between theory and previously mentioned softwares, have emerged: the Massively Parallel Communication model [2], the MapReduce Computation model [22], the k-Machine model [23]. There is also a precursory model: the Bulk-Synchronous Parallel model of Valiant [33]. All these models are very similar, but not completely identical, to the congested clique model.

The congested clique model is defined as follows. There are n nodes which are given distinct identities (IDs), that we assume for simplicity to be numbers between 1 and n. In this paper we consider the situation where the joint input to the nodes is a graph G. More precisely, each node v receives as input an n-bit boolean vector $x_v\in {\{0,1\}}^n$, which is the indicator function of its neighborhood in G. Note that the input graph G is an arbitrary n-node graph, a subgraph of the communication network $K_n$. Nodes execute an algorithm, communicating with each other in synchronous rounds and their goal is to compute some function f that depends on G. In every round, each of the n nodes may send up to $n-1$ different b-bit messages through each of its $n-1$ communication links. When an algorithm stops every node must know $f(G)$. We call $f(G)$ the output of the distributed algorithm. The parameter b is known as the bandwidth of the algorithm. We denote by R the number of rounds. The product $R\cdot b$ corresponds to the total number of bits received by a node through one link, and we call it the cost of the algorithm.

An algorithm may be deterministic or randomized. We distinguish two sub-cases of randomized algorithms: the private-coin setting, where each node flips its own coin; and the public-coin setting, where the coin is shared between all nodes. An ε-error algorithm $\mathcal{A}$ that computes a function f is a randomized algorithm such that, for every input graph G, $\mathrm{Pr}(\mathcal{A}\mathrm{\text{outputs}}f(G))\ge 1-\epsilon$. In the case where $\epsilon \to 0$ as $n\to \infty$, we say that $\mathcal{A}$ computes f with high probability (w.h.p.). Recall that in this model all nodes compute the same output; therefore, when we run the algorithm either all nodes compute the right answer or none of them does.

The function f defines the problem to be solved; a 0/1-valued function corresponds to a decision problem (such as connectivity [16]). For other, more general types of problems, f may be more appropriately defined as a relation. This happens, for instance, when we want to construct a minimum spanning tree [14], [20], a maximal independent set [13], a 3-ruling set [18], all-pairs shortest-paths [5], etc. We remark that in these references the model does not consider the restriction that all vertices have to know $f(G)$ when the algorithm stops. For instance, in the minimum spanning tree problem each vertex has to output only the subset of its incident edges that belong to the tree.

The most difficult problem one could attempt to solve is the reconstruction problem, where nodes are asked to reconstruct the input graph G. In fact, if at the end of the algorithm every node has full knowledge of G, then, since nodes have unbounded computational power, they could answer any question concerning G.

In centralized, classical graph algorithms, a widely used approach to cope with NP-hardness is to restrict the class of graphs where the input G belongs. We use an analogous approach here, in the congested clique model. But, as we explain later, surprisingly, the complexity of the reconstruction problem will only depend on the cardinality of the subclass of n-node graphs in $\mathcal{G}$.

We introduce two problems, each defined for a fixed set of graphs $\mathcal{G}$. The first one, the strong reconstruction problem $\mathcal{G}$-Strong-Rec, is the following.

Recall that the output is computed by every node of the network. In other words, every node of an algorithm that solves $\mathcal{G}$-Strong-Rec must end up knowing whether G belongs to $\mathcal{G}$; and, in the positive cases, every node also finishes knowing all the edges of G.

We also define a weak reconstruction problem $\mathcal{G}$-Weak-Rec. This is a promise problem, where the input graph G is promised to belong to $\mathcal{G}$. In other words, for graphs that do not belong to $\mathcal{G}$, the behavior of an algorithm that solves $\mathcal{G}$-Weak-Rec does not matter.

What is already known about the (strong) reconstruction problem? The answer to this question is that there exist mainly three different types of algorithms for tackling this problem.

First, we have Lenzen's algorithm, which performs a load balancing procedure [24]. It simply distributes all the edges among the nodes, and then broadcasts everything. Therefore, if the class of input graphs $\mathcal{G}$ consists of a subset of sparse graphs then such algorithm solves the reconstruction problem very quickly. For instance, if the input graph G contains $\mathcal{O}(n)$ edges, then Lenzen's algorithm reconstruct G in a constant number of rounds with bandwidth $\mathcal{O}(\log n)$.

The second approach has been devised for graphs with bounded degeneracy. Recall that a graph G is d-degenerate if one can remove from G a vertex r of degree at most d, and then proceed recursively on the resulting graph $G^{\prime }=G-r$, until obtaining the empty graph. Bounded genus graphs such as planar graphs, bounded tree-width graphs, graphs without a fixed graph H as a minor, are all examples of classes of graphs with bounded degeneracy. In [3], [29] the authors exhibit a one-round deterministic algorithm that solves $\mathcal{G}$-Strong-Rec using bandwidth $\mathcal{O}(d\log n)=\mathcal{O}(\log n)$, where $\mathcal{G}$ is the class of d-degenerate graphs.

Note that the class of d-degenerate graphs is simultaneously sparse and hereditary. A class $\mathcal{G}$ is hereditary if, for every graph $G\in \mathcal{G}$, every induced subgraph of G also belongs to $\mathcal{G}$. Many graph classes are hereditary: forests, planar graphs, bipartite graphs, k-colorable graphs, bounded tree-width graphs, etc. [4]. Moreover, any intersection class of graphs –such as interval graphs, chordal graphs, unit disc graphs, etc.– is also hereditary [4].

The third type of result is related to the reconstruction of particular hereditary graph classes. Authors have studied hereditary classes defined by one fixed forbidden graph H. A graph G is called H-free if H is not an induced subgraph of G. In [21] the authors studied the (one-round) reconstruction problem of H-free classes, for all possible graphs H. In particular, they consider the case when H is the path of 4 nodes $P_4$. They exhibited a one-round, public coin algorithm for solving $\mathcal{G}$-Strong-Rec using bandwidth $\mathcal{O}(\log n)$, where $\mathcal{G}$ is the class of $P_4$-free graphs, known as cographs.

Finally, one can also define a class of graph by forbidding H as a subgraph (instead of forbidding it as an induced subgraph). Any class defined like this is also hereditary. In [7], the authors prove that the degeneracy of the class of graphs defined by forbidding the subgraph H is upper bounded by $4\cdot ex(n,H)/n$, where $ex(n,H)$ is the Turán number of H, defined as the maximum number of edges in an n-node graph not containing an isomorphic copy of H as a subgraph. Therefore, the class of graphs defined by a forbidden subgraph H can be reconstructed deterministically in one round with bandwidth $\mathcal{O}((ex(n,H)\log n)/n)$.

In this short subsection we explain a key aspect of this paper. For any positive integer n, let us define the set ${\mathcal{G}}_n$ as the set of all n-node graphs in $\mathcal{G}$.

There is an obvious lower bound for $R\cdot b$, even for the weak reconstruction problem $\mathcal{G}$-Weak-Rec and even in the public-coin setting. In fact,

$$R\cdot b=\mathrm{\Omega }(\log |{\mathcal{G}}_n|/n).$$

This can be seen by noting that, in the randomized case, there must be at least one outcome of the coin tosses for which the correct algorithm reconstructs the input graph in at least $(1-\epsilon )$ of the cases. In fact, if this was not true, then we would be contradicting the correctness of the algorithm, which states that for every input graph, in at least $(1-\epsilon )$ of the coin tosses, the answer is correct. A useful way to see this is to visualize a matrix where the rows correspond to coin tosses, the columns to input graphs, and each entry is the output given by the algorithm to the corresponding graph and the corresponding sequence of coin tosses.

Now we count the number of bits received by any node. By previous argument, it must be $\mathrm{\Omega }(\log ((1-\epsilon )\cdot |{\mathcal{G}}_n|))=\mathrm{\Omega }(\log |{\mathcal{G}}_n|)$. This holds because in at least one outcome of the coin tosses, the nodes must reconstruct that many different graphs.

On the other hand, the total number of bits received by any node v of the network is $(n-1)\cdot R\cdot b+n$. In fact, $(n-1)\cdot R\cdot b$ bits are received from the other nodes and n bits are known by v at the beginning of the algorithm. Therefore, putting all together, we have $n+(n-1)\cdot R\cdot b=\mathrm{\Omega }(\log |{\mathcal{G}}_n|)$. This implies that $R\cdot b=\mathrm{\Omega }(\log |{\mathcal{G}}_n|/n)$.

In this paper we prove that this bound is essentially tight, even with $R=1$ (if $\mathcal{G}$ is an hereditary class of graphs) and $R=2$ (in the general case).

In Section 3 we give, for every hereditary class of graphs $\mathcal{G}$, a one-round private-coin randomized algorithm that solves $\mathcal{G}$-Strong-Rec with bandwidth $\mathcal{O}({\max }_{k\in [n]}\log |{\mathcal{G}}_k|/k+\log n)$.

We emphasize that our algorithm runs in one round, and therefore it runs in the broadcast congested clique, a restricted version of the congested clique model where, in every round, the $n-1$ messages sent by a node must be the same. This equivalence –which is a consequence of the requirement that all nodes must compute the output after one round– is proved in Section 2. We also remark that for many hereditary graph classes our algorithm is tight. More precisely, our result implies that $\mathcal{G}$-Strong-Rec can be solved in one round with bandwidth $\mathcal{O}(\log n)$ when $\mathcal{G}$ is the class of forests, planar graphs, d-degenerate graphs, interval graphs, unit-circle graphs, or any other hereditary graph class $\mathcal{G}$ such that $|{\mathcal{G}}_n|=2^{\mathcal{O}(n\log n)}$.

In Section 4 we give a very general result, showing that two rounds are sufficient to solve $\mathcal{G}$-Strong-Rec in the congested clique model, for any set of graphs $\mathcal{G}$. More precisely, we provide a two-round deterministic algorithm that solves $\mathcal{G}$-Weak-Rec and a two-round private-coin randomized algorithm that solves $\mathcal{G}$-Strong-Rec w.h.p. We also give a three-round deterministic algorithm solving $\mathcal{G}$-Strong-Rec. All algorithms run using bandwidth $\mathcal{O}(\log |{\mathcal{G}}_n|/n+\log n)$, so they are asymptotically optimal when $|{\mathcal{G}}_n|=2^{\mathrm{\Omega }(n\log n)}$.

Our result implies, in particular, that $\mathcal{G}$-Strong-Rec can be solved in two rounds with bandwidth $\mathcal{O}(\log n)$, when $\mathcal{G}$ is any set of graphs of size $2^{\mathcal{O}(n\log n)}$. The only property of the set of graphs $\mathcal{G}$ used by our algorithm is the cardinality of ${\mathcal{G}}_n$. Our algorithm does not require $\mathcal{G}$ to be closed under isomorphisms.

In Section 5 we revisit the one-round case. Our general algorithm can be adapted to run in one round (i.e., in the broadcast congested clique model) by allowing a larger bandwidth. We show that, for every set of graphs $\mathcal{G}$, there is a one-round deterministic algorithm that solves $\mathcal{G}$-Weak-Rec, and a one-round private-coin algorithm that solves $\mathcal{G}$-Strong-Rec w.h.p., both of them using bandwidth $\mathcal{O}(\sqrt{\log |{\mathcal{G}}_n|\log n}+\log n)$. We finish Section 5 pointing out that our algorithms are tight with respect to the bandwidth as well as the requirement of randomness.

Even though in the congested clique model, by definition, the only complexity measure taken into account is communication, it is important to point out that the general algorithms we present in this paper might run in exponential local time.

Note, however, that unless $P=NP$ (or even if stronger conjectures in computational complexity are false), this difficulty can not be overcome. In fact, for many graph classes $\mathcal{G}$, solving $\mathcal{G}$-Strong-Rec in polynomial local time is impossible.

Let us illustrate this with an example. Consider the hereditary, sparse class of 3-colorable planar graphs, that we denote 3-col-plan. It is NP-complete to decide whether an arbitrary graph belongs to 3-col-plan [11]. Any algorithm in the congested clique model that runs in polynomial local time can be simulated by a sequential algorithm that also runs in polynomial time: simply run the computation of each node one by one at each round. Therefore, unless $P=NP$, there is no algorithm running in polynomial local time solving 3-col-planar-Strong-Rec. Nevertheless, when the class of graphs is decidable in (centralized) polynomial time, there is no reason, a priori, preventing us from finding one-round, polynomial local time reconstruction algorithms in the congested clique model.

The remark above motivates the study of the following question: for what graph classes $\mathcal{G}$ the reconstruction problem $\mathcal{G}$-Strong-Rec can be solved in one round, bandwidth $\mathcal{O}(\log |{\mathcal{G}}_n|/n)$ and polynomial local time? In Section 6 we address this question by devising one-round, public-coin algorithms for reconstructing two hereditary classes of graphs: distance-hereditary graphs and graphs of bounded modular width. Both algorithms use bandwidth $\mathcal{O}(\log n)$, run in polynomial local time, and give the correct answer w.h.p.

We point out that, with respect to the local computation time, there exists an example of a conditional lower-bound. In fact, Drucker et al. [7] show that, assuming the Exponential Time Hypothesis, any randomized algorithm solving triangle-freeness in the broadcast congested clique model such that the local computation time is sub-exponential, has communication cost $\mathrm{\Omega }(n/e^{\sqrt{\log n}})$. The existence of similar lower-bounds for the reconstruction of graph classes is an interesting and challenging open question.