A Fault-Tolerant Handshake Algorithm for Local Computations

WAINA 2016

Distributed systems have been studied thoroughly. Many applications are based on huge systems and one of the main property
an algorithm running on such systems should verified is fault-tolerance. This paper presents a new randomized algorithm to
solve the handshake problem in a distributed system. This algorithm is designed for an asynchronous distributed network of
anonymous processes under the message passing communication protocol. In addition to its fault-tolerance, this algorithm is
more effective than the existing ones thanks to its asynchronous aspect. To highlight its performance, we provide an experimental
evaluation by comparing it to the most representative algorithm solving the handshake problem. The experimentation is done using
Visidia, a tool for simulating and visualizing distributed algorithms.

The k-mismatch problem revisited

SODA 2016

We revisit the complexity of one of the most basic problems in pattern matching. In the k-mismatch problem we must compute the Hamming distance between a pattern of length m and every m-length substring of a text of length n, as long as that Hamming distance is at most k. Where the Hamming distance is greater than k at some alignment of the pattern and text, we simply output “No”.
We study this problem in both the standard offline setting and also as a streaming problem. In the streaming k-mismatch problem the text arrives one symbol at a time and we must give an output before processing any future symbols. Our main results are as follows:
Our first result is a deterministic O(nk² log k/m + n polylog m)math> time offline algorithm for k-mismatch on a text of length n. This is a factor of k improvement over the fastest previous result of this form from SODA 2000.
We then give a randomised and online algorithm which runs in the same time complexity but requires only O(k² polylog m) space in total.
Next we give a randomised (1 + ∊)-approximation algorithm for the streaming k-mismatch problem which uses O(k² polylog m/∊²) space and runs in O(polylog m/∊²) worst-case time per arriving symbol.
Finally we combine our new results to derive a randomised O(k2 polylog m) space algorithm for the streaming k-mismatch problem which runs in worst-case time per arriving symbol. This improves the best previous space complexity for streaming k-mismatch from FOCS 2009 by a factor of k. We also improve the time complexity of this previous result by an even greater factor to match the fastest known offline algorithm (up to logarithmic factors).

Dictionary Matching in a Stream

ESA 2015

We consider the problem of dictionary matching in a stream. Given a set of strings, known as a dictionary,
and a stream of characters arriving one at a time, the task is to report each time some string in our
dictionary occurs in the stream. We present a randomised algorithm which takes O(log log(k+m))
time per arriving character and uses O(k log m) words of space, where k is the number
of strings in the dictionary and m is the length of the longest string in the dictionary.

On Lower Bounds for the Time and the Bit Complexity of some Probabilistic Distributed Graph Algorithms

SOFSEM 2014

On Lower Bounds for the Time and the Bit Complexity of some Probabilistic Distributed Graph AlgorithmsAllyx Fontaine, Yves Métivier, John Michael Robson, Akka Zemmari

This paper concerns probabilistic distributed graph algorithms to solve classical graph problems such as
colouring, maximal matching or maximal independent set. We consider anonymous networks (no unique identifiers
are available) where vertices communicate by single bit messages. We present a general framework, based on
coverings, for proving lower bounds for the bit complexity and thus the execution time to solve these problems.
In this way we obtain new proofs of some well known results and some new ones. The last part gives impossibility
results on the existence of Las Vegas distributed algorithms to break symmetries at distance k
for k≥3.

Information and Computation 2013

We present and analyse Las Vegas distributed algorithms which compute a MIS or a maximal matching for
anonymous rings. Their bit complexity and time complexity are O(log n)
with high probability. These algorithms are optimal modulo a multiplicative constant. Beyond the complexity
results, the interest of this work stands in the description and the analysis of these algorithms which may
be easily generalised. Furthermore, these results show a separation between the complexity of the MIS problem
(and of the maximal matching problem) on the one hand and the colouring problem on the other. Colouring can be
computed only in Ω(log n) rounds on rings with high probability, while MIS is shown to have a
faster algorithm. This is in contrast to other models, in which MIS is at least as hard as colouring.

Probabilistic algorithms are simple to formulate. However, their analysis can become very complex, especially
in the field of distributed computing. We present algorithms - optimal in terms of bit complexity and solving
the problems of MIS and maximal matching in rings - that follow the same scheme. We develop a method that
unifies the bit complexity lower bound results to solve MIS, maximal matching and coloration problems.The
complexity of these analyses, which can easily lead to errors,together with the existence of many models
depending on implicit assumptionsmotivated us to formally model the probabilistic distributed
algorithms corresponding to our model (message passing, anonymous andsynchronous). Our aim is to formally
prove the properties related to their analysis. For this purpose, we develop a library, called RDA, based
on the Coq proof assistant.