Many fundamental local distributed algorithms are non-uniform, that is, they assume that all nodes know good estimations of one or more global parameters of the network, e.g., the maximum degree $\Delta$or the number of nodes $n$. In , we introduce a rather general technique for transforming a non-uniform algorithm into a uniform one with same asymptotic complexity.

Modularity has been introduced as a quality measure for graph partitioning by Newman and Girvan. It has received considerable attention in several disciplines, especially complex systems. In order to better understand this measure from a graph theoretical point of view, we study in  , the asymptotic modularity of a variety of graph classes.

In , , we study the measurement of the Internet according to two graph parameters: treewidth and hyperbolicity.

Motivated by multipath routing, we introduce in , a multi-connected variant of spanners.

$\delta -$Hyperbolic metric spaces have been defined by M. Gromov in 1987 via a simple 4-point condition: for any four points $u,v,w,x$, the two larger of the distance sums $d(u,v)+d(w,x),d(u,w)+d(v,x),d(u,x)+d(v,w)$differ by at most $2\delta$. They play an important role in geometric group theory, geometry of negatively curved spaces, and have recently become of interest in several domains of computer science, including algorithms and networking. In paper, we study un- weighted $\delta -$hyperbolic graphs. Using the Layering Partition technique, we show that every $n-$vertex $\delta$-hyperbolic graph with $\delta \ge 1/2$has an additive $O(\delta logn)-$spanner with at most $O\left(\delta n\right)$edges and provide a simpler, in our opinion, and faster con- struction of distance approximating trees of $\delta$-hyperbolic graphs with an additive error $O(\delta logn)$. The construction of our tree takes only linear time in the size of the input graph. As a consequence, we show that the family of $n-$vertex $\delta -$hyperbolic graphs with $\delta \ge 1/2$admits a routing labeling scheme with $O\left(\delta {log}^{2}n\right)$bit labels, $O(\delta logn)$additive stretch and $O\left({log}_2\left(4\delta \right)\right)$time routing protocol, and a distance labeling scheme with $O\left({log}^{2}n\right)$bit labels, $O(\delta logn)$additive error and constant time distance decoder.

Graph sandwich problems were introduced by Golumbic et al. (1994) in [12] for DNA physical mapping problems and can be described as follows. Given a property $\Pi$of graphs and two disjoint sets of edges $E_1$, $E_2$with $E_1\subseteq E_2$on a vertex set $V$, the problem is to find a graph $G$on $V$with edge set $E_s$having property $\Pi$and such that $E_1\subseteq E_s\subseteq E_2$. In paper, we exhibit a quasi-linear reduction between the problem of finding an independent set of size $k\ge 2$in a graph and the problem of finding a sandwich homogeneous set of the same size $k$. Using this reduction, we prove that a number of natural (decision and counting) problems related to sandwich homogeneous sets are hard in general. We then exploit a little further the reduction and show that finding efficient algorithms to compute small sandwich homogeneous sets would imply substantial improvement for computing triangles in graphs.

In , we propose a new algorithm for computing the diameter of undirected unweighted graphs. Even though, in the worst case, this algorithm has complexity $O\left(nm\right)$, where $n$is the number of nodes and $m$is the number of edges of the graph, we experimentally show (on almost 200 real-world graphs) that in practice our method works in linear time. Moreover, we show how to extend our algorithm to the case of undirected weighted graphs and, even in this case, we present some preliminary very positive experimental results.

An edge-Markovian process with birth-rate $p$and death-rate $q$generates infinite sequences of graphs $(G_0,G_1,G_2,\dots )$with the same node set $\left[n\right]$such that $G_t$is obtained from $G_{t-1}$as follows: if $e\notin E\left(G_{t-1}\right)$then $e\in E\left(G_t\right)$with probability $p$, and if $e\in E\left(G_{t-1}\right)$then $e\notin E\left(G_t\right)$with probability $q$. In , we establish tight bounds on the complexity of flooding in edge-Markovian graphs, where flooding is the basic mechanism in which every node becoming aware of an information at step t forwards this information to all its neighbors at all forthcoming steps $t\prime >t$. These bounds complete previous results obtained by Clementi et al. Moreover, we also show that flooding in dynamic graphs can be implemented in a parsimonious manner, so that to save bandwidth, yet preserving efficiency in term of simplicity and completion time. For a positive integer $k$, we say that the flooding protocol is $k-$active if each node forwards an information only during the $k$time steps immediately following the step at which the node receives that information for the first time. We define the reachability threshold for the flooding protocol as the smallest integer $k$such that, for any source s[n] , the $k-$active flooding protocol from s completes (i.e., reaches all nodes), and we establish tight bounds for this parameter. We show that, for a large spectrum of parameters p and q, the reachability threshold is by several orders of magnitude smaller than the flooding time. In particular, we show that it is even constant whenever the ratio $p/(p+q)$exceeds $logn/n$. Moreover, we also show that being active for a number of steps equal to the reachability threshold (up to a multiplicative constant) allows the flooding protocol to complete in optimal time, i.e., in asymptotically the same number of steps as when being perpetually active. These results demonstrate that flooding can be implemented in a practical and efficient manner in dynamic graphs. The main ingredient in the proofs of our results is a reduction lemma enabling to overcome the time dependencies in edge-Markovian dynamic graphs.

Inspired by sequential complexity theory, in we focus on a complexity theory for distributed decision problems. We first study the intriguing question of whether randomization helps in local distributed computing, and to what extent. Our main result provides a sharp threshold for the impact of randomization on decision hereditary problems. In addition, we investigate the impact of non-determinism on local decision, and establish some structural results inspired by classical computational complexity theory. Specifically, we show that non-determinism does help, but that this help is limited, as there exist languages that cannot be decided non-deterministically. Perhaps surprisingly, it turns out that it is the combination of randomization with non-determinism that enables to decide all languages in constant time. Finally, we introduce the notion of local reduction, and establish some completeness results

In order to capture the core of asynchronous distributed decision model, we address in the wait-freemodel with crash failures. The set of tasks whose input is a pair $(s,t)$and deciding whether $t\in \Delta \left(s\right)$, i.e. whether $t$is a valid output for $s$, has been proven to be decidable in this model.

In , we partially answer the question of decidability of any language for mobile agents in a 2D environment like telecom networks or robots. It is proven that, for every agent, verifying whether (i) he/she is alone or not and (ii) he/she is able to capture the environment, is associated with the question of pertaining to an equivalence class of a map. A positive answer helps in the non-deterministic decision for any language for mobile agent.

In , we consider the setting of randomly weighted graphs. Under this setting, weighted graph properties typically become random variables and we are interested in computing their statistical features. Unfortunately, this turns out to be computationally hard for some weighted graph properties albeit the problem of computing the properties per se in the traditional setting of algorithmic graph theory is tractable. For example, there are well known efficient algorithms that compute the diameter of a given weighted graph, yet, computing the expected diameter of a given randomly weighted graph is ♯P-hard even if the edge weights are identically distributed. In this paper, we define a family of weighted graph properties and show that for each property in this family, the problem of computing the $k$'th moment (and in particular, the expected value) of the corresponding random variable in a given randomly weighted graph $G$admits a fully polynomial time randomized approximation scheme (FPRAS) for every fixed $k$. This family includes fundamental weighted graph properties such as the diameter of $G$, the radius of $G$(with respect to any designated vertex) and the weight of a minimum spanning tree of $G$.

In , we establish two new lower bounds on the message complexity of the controller problem. We first prove a simple lower bound stating that any $(M,W)$-controller must send $\Omega (Nlog\frac{M}{W+1})$messages. Second, for the important case when $W$is proportional to $M$(this is the common case in most applications), we use a surprising reduction from the (centralized) monotonic labeling problem to show that any $(M,W)$-controller must send $\Omega (NlogN)$messages. In fact, under a long lasting conjecture regarding the complexity of the monotonic labeling problem, this lower bound is improved to a tight $\Omega \left(N{log}^{2}N\right)$.

In , we consider a model for online computation in which the online algorithm receives, together with each request, some information regarding the future, referred to as advice. We are interested in the impact of such advice on the competitive ratio, and in particular, in the relation between the size $b$of the advice, measured in terms of bits of information per request, and the (improved) competitive ratio. In this paper we propose the above model and illustrate its applicability by considering two of the most extensively studied online problems, namely, metrical task systems (MTS) and the $k$-server problem.

In , we 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 simultaneously $\tilde{O}\left(\right|E\left|\right)$messages and $\tilde{O}(\sqrt{n}+D)$time, where $\left|E\right|$is the number of edges in the given graph $G$and $D$is $G$'s diameter. On the negative side, we show that any MST verification algorithm must send $\Omega \left(\right|E\left|\right)$messages and incur $\tilde{\Omega }(\sqrt{n}+D)$time in worst case. Our upper bound result appears to indicate that the verification of an MST may be easier than its construction.

In , we initiate a systematic study of distributed verification, and give almost tight lower bounds on the running time of distributed verification algorithms for many fundamental problems such as connectivity, spanning connected subgraph, and $s-t$cut verification. We then show applications of these results in deriving strong unconditional time lower bounds on the hardness of distributed approximation for many classical optimization problems including minimum spanning tree, shortest paths, and minimum cut. Many of these results are the first non-trivial lower bounds for both exact and approximate distributed computation and they resolve previous open questions. Moreover, our unconditional lower bound of approximating minimum spanning tree (MST) subsumes and improves upon the previous hardness of approximation bound of Elkin [STOC 2004] as well as the lower bound for (exact) MST computation of Peleg and Rubinovich [FOCS 1999]. Our result implies that there can be no distributed approximation algorithm for MST that is significantly faster than the current exact algorithm, for any approximation factor. Our lower bound proofs show an interesting connection between communication complexity and distributed computing which turns out to be useful in establishing the time complexity of exact and approximate distributed computation of many problems.

In , we address the problem of verification by model- checking of the basic population protocol (PP) model of Angluin et al. . This problem has received special attention in the last two years and new tools have been proposed to deal with it. We show that the problem can be solved by using the existing model-checking tools, e.g., Spin and Prism. In order to do so, we apply the counter abstraction to get an abstraction of the PP model which can be efficiently verified by the existing model-checking tools. Moreover, this abstraction preserves the correct stabilization property of PP models. To deal with the fairness assumed by the PP models, we provide two new recipes. The first one gives sufficient conditions under which the PP model fairness can be replaced by the weak fairness implemented in Spin. We show that this recipe can be applied to several PP models. In the second recipe, we show how to use probabilistic model-checking and, in particular, Prism to take completely in consideration the fairness of the PP models. The correctness of this recipe is based on existing theorems involving finite discrete Markov chains. An abstract of this paper has been also published in .

What does it mean to solve a distributed task? In Paxos, Lamport proposed a definition of solvability in which every process is split into a proposer that submits commands to be executed, an acceptor that takes care of the command execution order, and a learner that receives the outcomes of executed commands. The resulting perspective of computation in which every proposed command can be executed, be its proposer correct or faulty, proved to be very useful when processes take steps on behalf of each other, i.e., in simulations.

Most interesting tasks cannot be solved asynchronously, and failure detectors were proposed to circumvent these impossibilities. Alas, when it comes to solving a task using a failure detector, we cannot leverage simulation-based techniques. A process cannot perform steps of failure detector-based computation on behalf of another process, since it cannot access the remote failure-detector module.

In , we propose a new definition of solving a task with a failure detector in which computationprocesses that propose inputs and provide outputs are treated separately from synchronizationprocesses that coordinate using a failure detector. In the resulting framework, any failure detector is shown to be equivalent to the availability of some $k$-set agreement. As a corollary, we obtain a complete classification of tasks, including ones that evaded comprehensible characterization so far, such as renaming.

Shared objects like atomic register, test-and-set, cmp-and-swap are classical hardware primitives that help to develop fault-tolerant distributed applications. In order to compare shared objects, in , we consider their implementations in message passing models. With the minimal failure detector for each object, we get a new hierarchy that has only two levels. This paper summarizes recent works and results on this topic.

In , we first define the basic notions of localand non-localtasks for distributed systems. Intuitively, a task is local if, in a system with no failures, each process can compute its output value locally by applying some local function on its own input value (so the output value of each process depends only on the process' own input value, not on the input values of the other processes); a task is non-local otherwise. All the interesting distributed tasks, including all those that have been investigated in the literature (e.g., consensus, set agreement, renaming, atomic commit, etc.) are non-local.

In this paper we consider non-local tasks and determine the minimum information about failures that is necessary to solve such tasks in message-passing distributed systems. As part of this work, we also introduces weak set agreement— a natural weakening of set agreement— and show that, in some precise sense, it is the weakest non-local task in message-passing systems.

At the heart of distributed computing lies the fundamental result that the level of agreement that can be obtained in an asynchronous shared memory model where t processes can crash is exactly t + 1. In other words, an adversary that can crash any subset of size at most t can prevent the processes from agreeing on t values. But what about all the other $2^{2^n-1}-(n+1)$adversaries that are not uniform in this sense and might crash certain combination of processes and not others? In , we present a precise way to classify all adversaries. We introduce the notion of disagreement power: the biggest integer k for which the adversary can prevent processes from agreeing on k values. We show how to compute the disagreement power of an adversary and derive n equivalence classes of adversaries.

So far, the distributed computing community has either assumed that all the processes of a distributed system have distinct identifiers or, more rarely, that the processes are anonymous and have no identifiers. These are two extremes of the same general model: namely, $n$processes use $\ell$different authenticated identifiers, where $1\le \ell \le n$. In , we ask how many identifiers are actually needed to reach agreement in a distributed system with $t$Byzantine processes.

We show that having $3t+1$identifiers is necessary and sufficient for agreement in the synchronous case but, more surprisingly, the number of identifiers must be greater than $\frac{n+3t}{2}$in the partially synchronous case. This demonstrates two differences from the classical model (which has $\ell =n$): there are situations where relaxing synchrony to partial synchrony renders agreement impossible; and, in the partially synchronous case, increasing the number of correctprocesses can actually make it harder to reach agreement. The impossibility proofs use the fact that a Byzantine process can send multiple messages to the same recipient in a round. We show that removing this ability makes agreement easier: then, $t+1$identifiers are sufficient for agreement, even in the partially synchronous model.

In , we address the impact of optimizing the memory size on the time complexity, and show that this carries at most a small cost in terms of time in the context of MST. Specifically, we present a self stabilizing distributed verification algorithm whose time complexity is $O\left({log}^{2}n\right)$in synchronous networks, or $O(△{log}^{2}n)$in asynchronous networks, where $△$denotes the largest degree of a node. More importantly, the memory size at each node remains optimal- $O(logn)$bits throughout the execution. This answers an open problem posed by Awerbuch and Varghese (FOCS 1991). We also show that $\Omega (logn)$time is necessary if the memory size is restricted to $O(logn)$bits, even in synchronous networks. We demonstrate the usefulness of our verification scheme by using it as a module in a new self stabilizing MST construction algorithm. This algorithm has the important property that, if faults occur after the construction ended, they are detected by some nodes within $O\left({log}^{2}n\right)$time in synchronous networks, or within $O(△{log}^{2}n)$time in asynchronous networks. The rest of the nodes detect within $O(Dlogn)$time, where $D$denotes the diameter. Moreover, if a constant number of faults occur, then, within the required detection time above, they are detected by some node in the $O(logn)$locality of each of the faults. The memory size of the self stabilizing MST construction is $O(logn)$bits per node (optimal), and the time complexity is $O\left(n\right)$. This time complexity is significantly better than the best time complexity of previous self stabilizing MST algorithms, that was $\Omega \left(n^2\right)$even when using memory of $\Omega \left({log}^{2}n\right)$bits, and even without having the above localized fault detection property.The time complexity of previous algorithms that used $O(logn)$memory size was $O\left(n\right|E\left|\right)$.

In , the problem of estimating the proportion of satisfiable instances of a given CSP (constraint satisfaction problem) can be tackled through weighting. It consists in putting onto each solution a non-negative real value based on its neighborhood in a way that the total weight is at least 1 for each satisfiable instance. We define in this paper a general weighting scheme for the estimation of satisfiability of general CSPs. First we give some sufficient conditions for a weighting system to be correct. Then we show that this scheme allows for an improvement on the upper bound on the existence of non-trivial cores in 3-SAT obtained by Maneva and Sinclair (2008) to 4.419. Another more common way of estimating satisfiability is ordering. This consists in putting a total order on the domain, which induces an orientation between neighboring solutions in a way that prevents circuits from appearing, and then counting only minimal elements. We compare ordering and weighting under various conditions.

Eigenvalues of tridiagonal (including main) Toeplitz matrices are analytically known under some regular distance to the main diagonal. Any eigenvector may be easily computed then, through a backward process; instead, in , we give an analytical form for each component through the reciprocation of the underlied trinomial. More generally, the connection to the Riordan group follows some bilinear iterative process.

In , we provide a global search algorithm for maximizing a piecewise convex function $F$over a compact $D$. We propose to iteratively refine the function $F$at local solution $y$by a virtual cuttingfunction $p_y(·)$and to solve

$max\{min\{F\left(x\right)-F\left(y\right),p_y\left(x\right)\}\mid x\in D\}$instead. We call this function either a patch, when it avoids returning back to the same local solutions, or a pseudo patch, when it possibly yields a better point. It is virtualin the sense that the role of cutting constraints is played by additional convex pieces in the objective function. We report some computational results, that represent an improvement on previous linearization based techniques.

It is well known that maximization of any difference of convex functions could be turned into a convex maximization; in , we aim at a piecewise convex maximization problem instead. Despite, it may seem harder, sometimes the dimension may be reduced by 1 and the local search improved by using extreme points of the closure of the convex hull of better points. We show that it is always the case for both binary and permutation problems and give, as such instances, piecewise convex formulations for the maximum clique problem and the quadratic assignment problem.

in , we consider mathematical programming problems with the so-called piecewise convex objective functions. A solution method for this interesting and important class of nonconvex problems is presented. This method is based on Newton’s law of universal gravitation, multicriteria optimization and Helly’s theorem on convex bodies. Numerical experiments using well known classes of test problems on piecewise convex maximization, convex maximization as well as the maximum clique problem show the efficiency of the approach.