7 research outputs found
Tight Bounds For Distributed MST Verification
This paper establishes tight bounds for the Minimum-weight Spanning Tree (MST) verification problem in the distributed setting. Specifically, we provide an MST verification algorithm that achieves {\em simultaneously} messages and time, where is the number of edges in the given graph and is 's diameter. On the negative side, we show that any MST verification algorithm must send messages and incur time in worst case. Our upper bound result appears to indicate that the verification of an MST may be easier than its construction, since for MST construction, both lower bounds of messages and time hold, but at the moment there is no known distributed algorithm that constructs an MST and achieves {\em simultaneously} messages and time. Specifically, the best known time-optimal algorithm (using \tO(\sqrt{n} + D) time) requires messages, and the best known message-optimal algorithm (using \tO(|E|) messages) requires time. On the other hand, our lower bound results indicate that the verification of an MST is not significantly easier than its construction
Distributed Maximum Matching Verification in CONGEST
We study the maximum cardinality matching problem in a standard distributed setting, where the nodes V of a given n-node network graph G = (V,E) communicate over the edges E in synchronous rounds. More specifically, we consider the distributed CONGEST model, where in each round, each node of G can send an O(log n)-bit message to each of its neighbors. We show that for every graph G and a matching M of G, there is a randomized CONGEST algorithm to verify M being a maximum matching of G in time O(|M|) and disprove it in time O(D + ?), where D is the diameter of G and ? is the length of a shortest augmenting path. We hope that our algorithm constitutes a significant step towards developing a CONGEST algorithm to compute a maximum matching in time O?(s^*), where s^* is the size of a maximum matching
An Almost Singularly Optimal Asynchronous Distributed MST Algorithm
A singularly (near) optimal distributed algorithm is one that is (near)
optimal in \emph{two} criteria, namely, its time and message complexities. For
\emph{synchronous} CONGEST networks, such algorithms are known for fundamental
distributed computing problems such as leader election [Kutten et al., JACM
2015] and Minimum Spanning Tree (MST) construction [Pandurangan et al., STOC
2017, Elkin, PODC 2017]. However, it is open whether a singularly (near)
optimal bound can be obtained for the MST construction problem in general
\emph{asynchronous} CONGEST networks.
We present a randomized distributed MST algorithm that, with high
probability, computes an MST in \emph{asynchronous} CONGEST networks and takes
time and messages, where
is the number of nodes, the number of edges, is the diameter of the
network, and is an arbitrarily small constant (both time and
message bounds hold with high probability). Our algorithm is message optimal
(up to a polylog factor) and almost time optimal (except for a
factor). Our result answers an open question raised in Mashregi
and King [DISC 2019] by giving the first known asynchronous MST algorithm that
has sublinear time (for all ) and uses
messages. Using a result of Mashregi and King [DISC 2019], this also yields the
first asynchronous MST algorithm that is sublinear in both time and messages in
the CONGEST model.
A key tool in our algorithm is the construction of a low diameter rooted
spanning tree in asynchronous CONGEST that has depth
(for an arbitrarily small constant )
in time and messages. To the best of
our knowledge, this is the first such construction that is almost singularly
optimal in the asynchronous setting.Comment: 27 pages, accepted to DISC 202
Fast and compact self-stabilizing verification, computation, and fault detection of an MST
This paper demonstrates the usefulness of distributed local verification of
proofs, as a tool for the design of self-stabilizing algorithms.In particular,
it introduces a somewhat generalized notion of distributed local proofs, and
utilizes it for improving the time complexity significantly, while maintaining
space optimality. As a result, we show that optimizing the memory size carries
at most a small cost in terms of time, in the context of Minimum Spanning Tree
(MST). That is, we present algorithms that are both time and space efficient
for both constructing an MST and for verifying it.This involves several parts
that may be considered contributions in themselves.First, we generalize the
notion of local proofs, trading off the time complexity for memory efficiency.
This adds a dimension to the study of distributed local proofs, which has been
gaining attention recently. Specifically, we design a (self-stabilizing) proof
labeling scheme which is memory optimal (i.e., bits per node), and
whose time complexity is in synchronous networks, or time in asynchronous ones, where is the maximum degree of
nodes. This answers an open problem posed by Awerbuch and Varghese (FOCS 1991).
We also show that time is necessary, even in synchronous
networks. Another property is that if faults occurred, then, within the
requireddetection time above, they are detected by some node in the locality of each of the faults.Second, we show how to enhance a known
transformer that makes input/output algorithms self-stabilizing. It now takes
as input an efficient construction algorithm and an efficient self-stabilizing
proof labeling scheme, and produces an efficient self-stabilizing algorithm.
When used for MST, the transformer produces a memory optimal self-stabilizing
algorithm, whose time complexity, namely, , is significantly better even
than that of previous algorithms. (The time complexity of previous MST
algorithms that used memory bits per node was , and
the time for optimal space algorithms was .) Inherited from our proof
labelling scheme, our self-stabilising MST construction algorithm also has the
following two properties: (1) if faults occur after the construction ended,
then they are detected by some nodes within time in synchronous
networks, or within time in asynchronous ones, and (2) if
faults occurred, then, within the required detection time above, they are
detected within the locality of each of the faults. We also show
how to improve the above two properties, at the expense of some increase in the
memory