## Section: New Results

### Distributed Computing

#### Local Conflict Coloring

Locally finding a solution to symmetry-breaking tasks such as vertex-coloring, edge-coloring, maximal matching, maximal independent set, etc., is a long-standing challenge in distributed network computing. More recently, it has also become a challenge in the framework of centralized local computation. In [30], we introduce conflict coloring as a general symmetry-breaking task that includes all the aforementioned tasks as specific instantiations — conflict coloring includes all locally checkable labeling tasks from [Naor&Stockmeyer, STOC 1993]. Conflict coloring is characterized by two parameters $l$ and $d$, where the former measures the amount of freedom given to the nodes for selecting their colors, and the latter measures the number of constraints which colors of adjacent nodes are subject to. We show that, in the standard LOCAL model for distributed network computing, if $l/d>\Delta $, then conflict coloring can be solved in $\tilde{O}\left(\sqrt{\Delta}\right)+{log}^{*}n$ rounds in $n$-node graphs with maximum degree $\Delta $, where $\tilde{O}$ ignores the polylog factors in $\Delta $. The dependency in $n$ is optimal, as a consequence of the $\Omega \left({log}^{*}n\right)$ lower bound by [Linial, SIAM J. Comp. 1992] for $(\Delta +1)$-coloring. An important special case of our result is a significant improvement over the best known algorithm for distributed $(\Delta +1)$-coloring due to [Barenboim, PODC 2015], which required $\tilde{O}\left({\Delta}^{3/4}\right)+{log}^{*}n$ rounds. Improvements for other variants of coloring, including $(\Delta +1)$-list-coloring, $(2\Delta -1)$-edge-coloring, T-coloring, etc., also follow from our general result on conflict coloring. Likewise, in the framework of centralized local computation algorithms (LCAs), our general result yields an LCA which requires a smaller number of probes than the previously best known algorithm for vertex-coloring, and works for a wide range of coloring problems.

#### A Hierarchy of Local Decision

In [29], we extend the notion of *distributed decision* in the framework of distributed network computing, inspired by recent results on so-called *distributed graph automata*. We show that, by using distributed decision mechanisms based on the interaction between a *prover* and a *disprover*, the size of the certificates distributed to the nodes for certifying a given network property can be drastically reduced. For instance, we prove that minimum spanning tree can be certified with $O(logn)$-bit certificates in $n$-node graphs, with just one interaction between the prover and the disprover, while it is known that certifying MST requires $\Omega \left({log}^{2}n\right)$-bit certificates if only the prover can act. The improvement can even be exponential for some simple graph properties. For instance, it is known that certifying the existence of a nontrivial automorphism requires $\Omega \left({n}^{2}\right)$ bits if only the prover can act. We show that there is a protocol with two interactions between the prover and the disprover enabling to certify nontrivial automorphism with $O(logn)$-bit certificates. These results are achieved by defining and analysing a *local hierarchy* of decision which generalizes the classical notions of *proof-labelling schemes* and *locally checkable proofs*.

#### Distributed Testing of Excluded Subgraphs

In [35], 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 triangle-freeness. 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\ge 5$ 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\ge 5$.

#### Asynchronous Coordination Under Preferences and Constraints

Adaptive renaming can be viewed as a coordination task involving a set of asynchronous agents, each aiming at grabbing a single resource out of a set of resources totally ordered by their desirability. Similarly, musical chairs is also defined as a coordination task involving a set of asynchronous agents, each aiming at picking one of a set of available resources, where every agent comes with an a priori preference for some resource. In [22], we foresee instances in which some combinations of resources are allowed, while others are disallowed. We model these constraints, i.e., the restrictions on the ability to use some combinations of resources, as an undirected graph whose nodes represent the resources, and an edge between two resources indicates that these two resources cannot be used simultaneously. In other words, the sets of resources that are allowed are those which form independent sets in the graph. E.g., renaming and musical chairs are specific cases where the graph is stable (i.e., it the empty graph containing no edges). As for musical chairs, we assume that each agent comes with an a priori preference for some resource. If an agent's preference is not in conflict with the preferences of the other agents, then this preference can be grabbed by the agent. Otherwise, the agents must coordinate to resolve their conflicts, and potentially choose non preferred resources. We investigate the following problem: given a graph, what is the maximum number of agents that can be accommodated subject to non-altruistic behaviors of early arriving agents? We entirely solve this problem under the restriction that agents which cannot grab their preferred resources must then choose a resource among the nodes of a predefined independent set. However, the general case, where agents which cannot grab their preferred resource are then free to choose any resource, is shown to be far more complex. In particular, just for cyclic constraints, the problem is surprisingly difficult. Indeed, we show that, intriguingly, the natural algorithm inspired from optimal solutions to adaptive renaming or musical chairs is sub-optimal for cycles, but proven to be at most 1 to the optimal. The main message of this paper is that finding optimal solutions to the coordination with constraints and preferences task requires to design " dynamic " algorithms, that is, algorithms of a completely different nature than the "static" algorithms used for, e.g., renaming.

#### Making Local Algorithms Wait-Free: The Case of Ring Coloring

When considering distributed computing, reliable message-passing synchronous systems on the one side, and asynchronous failure-prone shared-memory systems on the other side, remain two quite independently studied ends of the reliability/asynchrony spectrum. The concept of locality of a computation is central to the first one, while the concept of wait-freedom is central to the second one. This work proposes a new DECOUPLED model in an attempt to reconcile these two worlds. It consists of a synchronous and reliable communication graph of n nodes, and on top a set of asynchronous crash-prone processes, each attached to a communication node. To illustrate the DECOUPLED model, the paper [21] presents an asynchronous 3-coloring algorithm for the processes of a ring. From the processes point of view, the algorithm is wait-free. From a locality point of view, each process uses information only from processes at distance $O\left({log}^{*}n\right)$ from it. This local wait-free algorithm is based on an extension of the classical Cole and Vishkin vertex coloring algorithm in which the processes are not required to start simultaneously.

#### t-Resilient Immediate Snapshot Is Impossible

An immediate snapshot object is a high level communication object, built on top of a read/write distributed system in which all except one processes may crash. It allows each process to write a value and obtains a set of pairs (process id, value) such that, despite process crashes and asynchrony, the sets obtained by the processes satisfy noteworthy inclusion properties. Considering an n-process model in which up to t processes are allowed to crash (t-crash system model), the paper [25] is on the construction of t-resilient immediate snapshot objects. In the t-crash system model, a process can obtain values from at least $(n-t)$ processes, and, consequently, t-immediate snapshot is assumed to have the properties of the basic $(n-1)$-resilient immediate snapshot plus the additional property stating that each process obtains values from at least $(n-t)$ processes. The main result of the work is the following. While there is a (deterministic) $(n-1)$-resilient algorithm implementing the basic $(n-1)$-immediate snapshot in an $\left(n-1\right)$-crash read/write system, there is no t-resilient algorithm in a t-crash read/write model when $t\in [1...(n-2\left)\right]$. This means that, when $t<n-1$, the notion of t-resilience is inoperative when one has to implement t-immediate snapshot for these values of t: the model assumption “at most $t<n-1$ processes may crash” does not provide us with additional computational power allowing for the design of a genuine t-resilient algorithm (genuine meaning that such an algorithm would work in the t-crash model, but not in the $(t+1)$-crash model). To show these results, we rely on well-known distributed computing agreement problems such as consensus and k-set agreement.

#### Perfect Failure Detection with Very Few Bits

A *failure detector* is a distributed oracle that provides the processes with information about failures. The *perfect* failure detector provides accurate and eventually complete information about process failures. In [34], we show that, in asynchronous failure-prone message-passing systems, perfect failure detection can be achieved by an oracle that outputs at most $\lceil log\alpha \left(n\right)\rceil +1$ bits per process in $n$-process systems, where $\alpha $ denotes the inverse-Ackermann function. This result is essentially optimal, as we also show that, in the same environment, no failure detectors outputting a constant number of bit per process can achieve perfect failure detection.

#### Decentralized Asynchronous Crash-Resilient Runtime Verification

Runtime Verification (RV) is a lightweight method for monitoring the formal specification of a system during its execution. It has recently been shown that a given state predicate can be monitored consistently by a set of crash-prone asynchronous *distributed* monitors, only if sufficiently many different verdicts can be emitted by each monitor. In [27], we revisit this impossibility result in the context of LTL semantics for RV. We show that employing the four-valued logic RVLTL will result in inconsistent distributed monitoring for some formulas. Our first main contribution is a family of logics, called LTL$\left(k\right)$, that refines RVLTL incorporating $2k+4$ truth values, for each $k\ge 0$. The truth values of LTL$\left(k\right)$ can be effectively used by each monitor to reach a consistent global set of verdicts for each given formula, provided $k$ is sufficiently large. Our second main contribution is an algorithm for monitor construction enabling fault-tolerant distributed monitoring based on the aggregation of the individual verdicts by each monitor.

#### Asynchronous Consensus with Bounded Memory

The paper [11] presents a bounded memory size Obstruction-Free consensus algorithm for the asynchronous shared memory model. More precisely for a set of n processes, this algorithm uses $n+2$ multi-writer multi-reader registers, each of these registers being of size $O(logn)$ bits. From this, we get a bounded memory size space complexity consensus algorithm with single-writer multi-reader registers and a bounded memory size space complexity consensus algorithm in the asynchronous message passing model with a majority of correct processes. As it is easy to ensure the Obstruction-Free assumption with randomization (or with leader election failure detector $\Omega $) we obtain a bounded memory size randomized consensus algorithm and a bounded memory size consensus algorithm with failure detector.

#### Implementing Snapshot Objects on Top of Crash-Prone Asynchronous Message-Passing Systems

Distributed snapshots, as introduced by Chandy and Lamport in the context of asynchronous failure-free message-passing distributed systems, are consistent global states in which the observed distributed application might have passed through. It appears that two such distributed snapshots cannot necessarily be compared (in the sense of determining which one of them is the “first”). Differently, snapshots introduced in asynchronous crash-prone read/write distributed systems are totally ordered, which greatly simplify their use by upper layer applications. In order to benefit from shared memory snapshot objects, it is possible to simulate a read/write shared memory on top of an asynchronous crash-prone message-passing system, and build then snapshot objects on top of it. This algorithm stacking is costly in both time and messages. To circumvent this drawback, the paper [24] presents algorithms building snapshot objects directly on top of asynchronous crash-prone message-passing system. “Directly” means here “without building an intermediate layer such as a read/write shared memory”. To the authors knowledge, the proposed algorithms are the first providing such constructions. Interestingly enough, these algorithms are efficient and relatively simple.

#### Set-Consensus Collections are Decidable

A natural way to measure the power of a distributed-computing model is to characterize the set of tasks that can be solved in it. In general, however, the question of whether a given task can be solved in a given model is undecidable, even if we only consider the wait-free shared-memory. In [23], we address this question for restricted classes of models and tasks. We show that the question of whether a collection $C$ of $(\ell ,j)$-set consensus objects, for various $\ell $ (the number of processes that can invoke the object) and j (the number of distinct outputs the object returns), can be used by n processes to solve wait-free $k$-set consensus is decidable. Moreover, we provide a simple $O\left({n}^{2}\right)$ decision algorithm, based on a dynamic programming solution to the Knapsack optimization problem. We then present an adaptive wait-free set-consensus algorithm that, for each set of participating processes, achieves the best level of agreement that is possible to achieve using $C$. Overall, this gives us a complete characterization of a read-write model defined by a collection of set-consensus objects through its set-consensus power.

#### Minimizing the Number of Opinions for Fault-Tolerant Distributed Decision Using Well-Quasi Orderings

The notion of deciding a *distributed language* $L$ is of growing interest in various distributed computing settings. Each process ${p}_{i}$ is given an input value ${x}_{i}$, and the processes should collectively decide whether their set of input values $x={\left({x}_{i}\right)}_{i}$ is a valid state of the system w.r.t. to some specification, i.e., if $x\in L$. In *non-deterministic* distributed decision each process ${p}_{i}$ gets a local certificate ${c}_{i}$ in addition to its input ${x}_{i}$. If the input $x\in L$then there exists a certificate $c={\left({c}_{i}\right)}_{i}$ such that the processes collectively accept $x$, and if $x\notin L$, then for every $c$, the processes should collectively reject $x$. The collective decision is expressed by the set of *opinions* emitted by the processes, and one aims at minimizing the number of possible opinions emitted by each process. In [33], we study non-deterministic distributed decision in asynchronous systems where processes may crash. In this setting, it is known that the number of opinions needed to deterministically decide a language can grow with $n$, the number of processes in the system.We prove that every distributed language $L$ can be non-deterministically decided using only three opinions, with certificates of size $\lceil log\alpha \left(n\right)\rceil +1$ bits, where $\alpha $ grows at least as slowly as the inverse of the Ackerman function. The result is optimal, as we show that there are distributed languages that cannot be decided using just two opinions, even with arbitrarily large certificates. To prove our upper bound, we introduce the notion of *distributed encoding of the integers*, that provides an explicit construction of a long *bad sequence* in the *well-quasi-ordering*$({\{0,1\}}^{*},{\le}_{*})$ controlled by the successor function. Thus, we provide a new class of applications for well-quasi-orderings that lies outside logic and complexity theory. For the lower bound we use combinatorial topology techniques.

#### Collision-Free Network Exploration

In [9], we consider a network exploration setting in which mobile agents start at different nodes of an $n$-node network.
The agents synchronously move along the network edges in a *collision-free* way, i.e., in no round two agents may occupy the same
node. An agent has no knowledge of the number and initial positions of
other agents. We are looking for the shortest time required to reach
a configuration in which each agent has visited all nodes and
returned to its starting location. In the scenario when each mobile
agent knows the map of the network, we provide tight (up to a constant
factor) lower and upper bounds on the collision-free exploration time in
arbitrary graphs, and the exact bound for the trees.
In the second scenario, where the network is unknown to the agents, we
propose collision-free exploration strategies running in $O\left({n}^{2}\right)$ rounds
in tree networks and in $O({n}^{5}logn)$ rounds in networks with an
arbitrary topology.

#### When Patrolmen Become Corrupted: Monitoring a Graph Using Faulty Mobile Robots

In [10], we consider a setting in which a team of $k$ mobile robots is deployed on a weighted graph whose edge weights
represent distances. The robots perpetually move along the domain, represented by
all points belonging to the graph edges, not exceeding their maximal speed. The robots
need to patrol the graph by regularly visiting all points of the domain. We consider a team of robots (patrolmen), at most $f$ of which may be unreliable, failing to comply with their patrolling duties.
What algorithm should be followed so as to minimize the maximum time between successive visits of every edge point by a reliable patrolmen? The corresponding measure
of efficiency of patrolling called *idleness* has been widely accepted in the
robotics literature. We extend it to the case of untrusted patrolmen; we
denote by ${I}_{k}^{f}\left(G\right)$ the maximum time that a point of the domain may
remain unvisited by reliable patrolmen. The objective is to find patrolling
strategies minimizing ${I}_{k}^{f}\left(G\right)$.

We investigate this problem for various classes of graphs. We design optimal algorithms for line segments, which turn out to be surprisingly different from strategies for related patrolling problems proposed in the literature. We then use these results to provide algorithms for general graphs. For Eulerian graphs $G$, we give an optimal patrolling strategy with idleness ${I}_{k}^{f}\left(G\right)=(f+1)E\left(G\right)/k$, where $E\left(G\right)$ is the sum of the lengths of the edges of $G$. For arbitrary graphs and given ratio $r$ of faulty robots, $r:=f/k<1/2$, we design a strategy which is a $(1+\u03f5)$ approximation of the optimal one, for sufficiently large $k$. Further, we show the hardness of the problem of computing the idle time for three robots, at most one of which is faulty, by reduction from 3-edge-coloring of cubic graphs — a known NP-hard problem. A byproduct of our proof is the investigation of classes of graphs minimizing idle time (with respect to the total length of edges); an example of such a class is known in the literature under the name of Kotzig graphs.

#### Noisy Rumor Spreading and Plurality Consensus

Error-correcting codes are efficient methods for handling noisy communication channels in the context of technological networks. However, such elaborate methods differ a lot from the unsophisticated way biological entities are supposed to communicate. Yet, it has been recently shown by Feinerman, Haeupler, and Korman [PODC 2014] that complex coordination tasks such as rumor spreading and majority consensus can plausibly be achieved in biological systems subject to noisy communication channels, where every message transferred through a channel remains intact with small probability $1+\epsilon $, without using coding techniques. This result is a considerable step towards a better understanding of the way biological entities may cooperate. It has nevertheless been established only in the case of 2-valued opinions: rumor spreading aims at broadcasting a single-bit opinion to all nodes, and majority consensus aims at leading all nodes to adopt the single-bit opinion that was initially present in the system with (relative) majority. In [32], we extend this previous work to k-valued opinions, for any constant $k\ge 2$. Our extension requires to address a series of important issues, some conceptual, others technical. We had to entirely revisit the notion of noise, for handling channels carrying k-valued messages. In fact, we precisely characterize the type of noise patterns for which plurality consensus is solvable. Also, a key result employed in the bivalued case by Feinerman et al. is an estimate of the probability of observing the most frequent opinion from observing the mode of a small sample. We generalize this result to the multivalued case by providing a new analytical proof for the bivalued case that is amenable to be extended, by induction, and that is of independent interest.