50 research outputs found
On The Multiparty Communication Complexity of Testing Triangle-Freeness
In this paper we initiate the study of property testing in simultaneous and
non-simultaneous multi-party communication complexity, focusing on testing
triangle-freeness in graphs. We consider the model,
where we have players receiving private inputs, and a coordinator who
receives no input; the coordinator can communicate with all the players, but
the players cannot communicate with each other. In this model, we ask: if an
input graph is divided between the players, with each player receiving some of
the edges, how many bits do the players and the coordinator need to exchange to
determine if the graph is triangle-free, or from triangle-free?
For general communication protocols, we show that
bits are sufficient to test triangle-freeness in
graphs of size with average degree (the degree need not be known in
advance). For protocols, where there is only one
communication round, we give a protocol that uses bits
when and when ; here, again, the average degree does not need to be
known in advance. We show that for average degree , our simultaneous
protocol is asymptotically optimal up to logarithmic factors. For higher
degrees, we are not able to give lower bounds on testing triangle-freeness, but
we give evidence that the problem is hard by showing that finding an edge that
participates in a triangle is hard, even when promised that at least a constant
fraction of the edges must be removed in order to make the graph triangle-free.Comment: To Appear in PODC 201
Distributed Testing of Excluded Subgraphs
We study property testing in the context of distributed computing, under the
classical CONGEST model. It is known that testing whether a graph is
triangle-free can be done in a constant number of rounds, where the constant
depends on how far the input graph is from being triangle-free. We show that,
for every connected 4-node graph H, testing whether a graph is H-free can be
done in a constant number of rounds too. The constant also depends on how far
the input graph is from being H-free, and the dependence is identical to the
one in the case of testing triangles. Hence, in particular, testing whether a
graph is K_4-free, and testing whether a graph is C_4-free can be done in a
constant number of rounds (where K_k denotes the k-node clique, and C_k denotes
the k-node cycle). On the other hand, we show that testing K_k-freeness and
C_k-freeness for k>4 appear to be much harder. Specifically, we investigate two
natural types of generic algorithms for testing H-freeness, called DFS tester
and BFS tester. The latter captures the previously known algorithm to test the
presence of triangles, while the former captures our generic algorithm to test
the presence of a 4-node graph pattern H. We prove that both DFS and BFS
testers fail to test K_k-freeness and C_k-freeness in a constant number of
rounds for k>4
Allowing each node to communicate only once in a distributed system: shared whiteboard models
International audienceIn this paper we study distributed algorithms on massive graphs where links represent a particular relationship between nodes (for instance, nodes may represent phone numbers and links may indicate telephone calls). Since such graphs are massive they need to be processed in a distributed way. When computing graph-theoretic properties, nodes become natural units for distributed computation. Links do not necessarily represent communication channels between the computing units and therefore do not restrict the communication flow. Our goal is to model and analyze the computational power of such distributed systems where one computing unit is assigned to each node. Communication takes place on a whiteboard where each node is allowed to write at most one message. Every node can read the contents of the whiteboard and, when activated, can write one small message based on its local knowledge. When the protocol terminates its output is computed from the final contents of the whiteboard. We describe four synchronization models for accessing the whiteboard. We show that message size and synchronization power constitute two orthogonal hierarchies for these systems.We exhibit problems that separate these models, i.e., that can be solved in one model but not in a weaker one, even with increased message size. These problems are related to maximal independent set and connectivity. We also exhibit problems that require a given message size independently of the synchronization model
The Sketching Complexity of Graph and Hypergraph Counting
Subgraph counting is a fundamental primitive in graph processing, with
applications in social network analysis (e.g., estimating the clustering
coefficient of a graph), database processing and other areas. The space
complexity of subgraph counting has been studied extensively in the literature,
but many natural settings are still not well understood. In this paper we
revisit the subgraph (and hypergraph) counting problem in the sketching model,
where the algorithm's state as it processes a stream of updates to the graph is
a linear function of the stream. This model has recently received a lot of
attention in the literature, and has become a standard model for solving
dynamic graph streaming problems.
In this paper we give a tight bound on the sketching complexity of counting
the number of occurrences of a small subgraph in a bounded degree graph
presented as a stream of edge updates. Specifically, we show that the space
complexity of the problem is governed by the fractional vertex cover number of
the graph . Our subgraph counting algorithm implements a natural vertex
sampling approach, with sampling probabilities governed by the vertex cover of
. Our main technical contribution lies in a new set of Fourier analytic
tools that we develop to analyze multiplayer communication protocols in the
simultaneous communication model, allowing us to prove a tight lower bound. We
believe that our techniques are likely to find applications in other settings.
Besides giving tight bounds for all graphs , both our algorithm and lower
bounds extend to the hypergraph setting, albeit with some loss in space
complexity
Being Fast Means Being Chatty: The Local Information Cost of Graph Spanners
We introduce a new measure for quantifying the amount of information that the
nodes in a network need to learn to jointly solve a graph problem. We show that
the local information cost () presents a natural lower bound on
the communication complexity of distributed algorithms. For the synchronous
CONGEST-KT1 model, where each node has initial knowledge of its neighbors' IDs,
we prove that bits are
required for solving a graph problem with a -round algorithm that
errs with probability at most . Our result is the first lower bound
that yields a general trade-off between communication and time for graph
problems in the CONGEST-KT1 model.
We demonstrate how to apply the local information cost by deriving a lower
bound on the communication complexity of computing a -spanner that
consists of at most edges, where . Our main result is that any -time
algorithm must send at least bits in the
CONGEST model under the KT1 assumption. Previously, only a trivial lower bound
of bits was known for this problem.
A consequence of our lower bound is that achieving both time- and
communication-optimality is impossible when designing a distributed spanner
algorithm. In light of the work of King, Kutten, and Thorup (PODC 2015), this
shows that computing a minimum spanning tree can be done significantly faster
than finding a spanner when considering algorithms with
communication complexity. Our result also implies time complexity lower bounds
for constructing a spanner in the node-congested clique of Augustine et al.
(2019) and in the push-pull gossip model with limited bandwidth
Survey of Distributed Decision
We survey the recent distributed computing literature on checking whether a
given distributed system configuration satisfies a given boolean predicate,
i.e., whether the configuration is legal or illegal w.r.t. that predicate. We
consider classical distributed computing environments, including mostly
synchronous fault-free network computing (LOCAL and CONGEST models), but also
asynchronous crash-prone shared-memory computing (WAIT-FREE model), and mobile
computing (FSYNC model)
Robust Lower Bounds for Graph Problems in the Blackboard Model of Communication
We give lower bounds on the communication complexity of graph problems in the multi-party blackboard model. In this model, the edges of an -vertex input graph are partitioned among parties, who communicate solely by writing messages on a shared blackboard that is visible to every party. We show that any non-trivial graph problem on -vertex graphs has blackboard communication complexity bits, even if the edges of the input graph are randomly assigned to the parties. We say that a graph problem is non-trivial if the output cannot be computed in a model where every party holds at most one edge and no communication is allowed. Our lower bound thus holds for essentially all key graph problems relevant to distributed computing, including Maximal Independent Set (MIS), Maximal Matching, ()-coloring, and Dominating Set. In many cases, e.g., MIS, Maximal Matching, and -coloring, our lower bounds are optimal, up to poly-logarithmic factors