We study the standard communication problem of broadcast for mobile agents moving in a network, where a single agent called source, has to transmit a vital information to all other agents in the network. The agents move autonomously in the network and can communicate with other agents only when they meet at a node. Previous studies of this problem were restricted to static networks while, in this paper, we consider the problem in dynamic networks modeled as an evolving graph. The dynamicity of the graph is unknown to the agents; in each round an adversary selects which edges of the graph are available, and an agent can choose to traverse one of the available edges adjacent to its current location. The only restriction on the adversary is that the subgraph of available edges in each round must span all nodes; in other words the evolving graph is constantly connected. The agents have global visibility allowing them to see the location of all agents in the graph and move accordingly. Depending on the topology of the underlying graph, we determine the minimum value of k > 0 , such that the broadcast from a source agent to k other agents can be solved in dynamic networks. While k = 2 agents are sufficient for ring networks, much larger teams of agents are necessary for denser graphs such as grid graphs and hypercubes, and finally for complete graphs of n nodes k ≥ n − 2 agents are necessary and sufficient. We show lower bounds on the number of agents and provide algorithms for solving broadcast using the minimum number of agents, for various topologies. These results show how the connectivity of the underlying graph affects the communication capability of a team of mobile agents in constantly connected dynamic networks.

Leader Election is an important primitive for programmable matter, since it is often an intermediate step for the solution of more complex problems. Although the leader election problem itself is well studied even in the specific context of programmable matter systems, research on fault tolerant approaches is more limited. We consider the problem in the previously studied Amoebot model on a triangular grid, when the configuration is connected but contains nodes the particles cannot move to (e.g., obstacles). We assume that particles agree on a common direction (i.e., the horizontal axis) but do not have chirality (i.e., they do not agree on the other two directions of the triangular grid). We begin by showing that an election algorithm with explicit termination is not possible in this case, but we provide an implicitly terminating algorithm that elects a unique leader without requiring any movement. These results are in contrast to those in the more common model with chirality but no agreement on directions, where explicit termination is always possible but the number of elected leaders depends on the symmetry of the initial configuration. Solving the problem under the assumption of one common direction allows for a unique leader to be elected in a stationary and deterministic way under a semi-synchronous scheduler, which until now was only possible for simply connected configurations under a sequential scheduler.

The problem of electing a unique leader is central to all distributed systems, including programmable matter systems where particles have constant size memory. In this paper, we present a silent self-stabilising, deterministic, stationary, election algorithm for particles having constant memory, assuming that the system is simply connected. Our algorithm is elegant and simple, and requires constant memory per particle. We prove that our algorithm always stabilises to a configuration with a unique leader, under a daemon satisfying some fairness guarantees (Gouda fairness [Gouda 2001]). We use the special geometric properties of programmable matter in 2D triangular grids to obtain the first self-stabilising algorithm for such systems. This result is surprising since it is known that silent self-stabilising algorithms for election in general distributed networks require $Ω(\log{n})$ bits of memory per node, even for ring topologies [Dolev et al. 1999].

Abstract Depth first search is a natural algorithmic technique for constructing a closed route that visits all vertices of a graph. The length of such a route equals, in an edge-weighted tree, twice the total weight of all edges of the tree and this is asymptotically optimal over all exploration strategies. This paper considers a variant of such search strategies where the length of each route is bounded by a positive integer B (e.g. due to limited energy resources of the searcher). The objective is to cover all the edges of a tree T using the minimum number of routes, each starting and ending at the root and each being of length at most B. To this end, we analyze the following natural greedy tree traversal process that is based on decomposing a depth first search traversal into a sequence of limited length routes. Given any arbitrary depth first search traversal R of the tree T, we cover R with routes $$R_1,\ldots ,R_l$$ R 1 , … , R l , each of length at most B such that: $$R_i$$ R i starts at the root, reaches directly the farthest point of R visited by $$R_{i-1}$$ R i - 1 , then $$R_i$$ R i continues along the path R as far as possible, and finally $$R_i$$ R i returns to the root. We call the above algorithm piecemeal-DFS and we prove that it achieves the asymptotically minimal number of routes l, regardless of the choice of R. Our analysis also shows that the total length of the traversal (and thus the traversal time) of piecemeal-DFS is asymptotically minimum over all energy-constrained exploration strategies. The fact that R can be chosen arbitrarily means that the exploration strategy can be constructed in an online fashion when the input tree T is not known in advance. Each route $$R_i$$ R i can be constructed without any knowledge of the yet unvisited part of T. Surprisingly, our results show that depth first search is efficient for energy constrained exploration of trees, even though it is known that the same does not hold for energy constrained exploration of arbitrary graphs.

We study the standard communication problem of broadcast for mobile agents moving in a network. The agents move autonomously in the network and can communicate with other agents only when they meet at a node. In this model, broadcast is a communication primitive for information transfer from one agent, the source, to all other agents. Previous studies of this problem were restricted to static networks while, in this paper, we consider the problem in dynamic networks modelled as an evolving graph. The dynamicity of the graph is unknown to the agents; in each round an adversary selects which edges of the graph are available, and an agent can choose to traverse one of the available edges adjacent to its current location. The only restriction on the adversary is that the subgraph of available edges in each round must span all nodes; in other words the evolving graph is constantly connected. The agents have global visibility allowing them to see the location of other agents in the graph and move accordingly. Depending on the topology of the underlying graph, we determine how many agents are necessary and sufficient to solve the broadcast problem in dynamic networks. While two agents plus the source are sufficient for ring networks, much larger teams of agents are necessary for denser graphs such as grid graphs and hypercubes, and finally for complete graphs of n nodes at least n-2 agents plus the source are necessary and sufficient. We show lower bounds on the number of agents and provide some algorithms for solving broadcast using the minimum number of agents, for various topologies.

We consider the problem of collectively delivering some package from a specified source to a designated target location in a graph, using multiple mobile agents. Each agent has limited energy which constrains the distance it can move. Hence multiple agents need to collaborate to move the package, each agent handing over the package to the next agent to carry it forward. Given the positions of the agents in the graph and their respective budgets, the problem of finding a feasible movement schedule for the agents can be challenging. We consider two variants of the problem: in non-returning delivery, the agents can stop anywhere; whereas in returning delivery, each agent needs to return to its starting location, a variant which has not been studied before. We first provide a polynomial-time algorithm for returning delivery on trees, which is in contrast to the known (weak) NP-hardness of the non-returning version. In addition, we give resource-augmented algorithms for returning delivery in general graphs. Finally, we give tight lower bounds on the required resource augmentation for both variants of the problem. In this sense, our results close the gap left by previous research.

International audience

International audience

We consider the exploration of a simple polygon P by a robot that moves from vertex to vertex along edges of the visibility graph of P . The visibility graph has a vertex for every vertex of P and an edge between two vertices if they see each other—that is, if the line segment connecting them lies inside P entirely. While located at a vertex, the robot is capable of ordering the vertices it sees in counterclockwise order as they appear on the boundary, and for every two such vertices, it can distinguish whether the angle between them is convex (⩽ π) or reflex ( > π). Other than that, distant vertices are indistinguishable to the robot. We assume that an upper bound on the number of vertices is known. We obtain the general result that a robot exploring any locally oriented, arc-labeled graph G can always determine the base graph of G . Roughly speaking, this is the smallest graph that cannot be distinguished by a robot from G by its observations alone, no matter how it moves. Combining this result with various other techniques allows the ability to show that a robot exploring a polygon P with the preceding capabilities is always capable of reconstructing the visibility graph of P . We also show that multiple identical, indistinguishable, and deterministic robots of this kind can always solve the weak rendezvous problem in which they need to position themselves such that they mutually see each other—for instance, such that they form a clique in the visibility graph.

We study distributed coordination among autonomous mobile robots, focussing on the problem of gathering the robots at a single location. The gathering problem has been solved previously using deterministic algorithms even for robots that are anonymous, oblivious, disoriented, and operate in the semi-synchronous ATOM model. However these solutions require all robots to be fault-free. The recent results of Agmon and Peleg [1] show how to gather all correct robots when one of the robots may crash permanently. We study gathering in n-robot systems with f crashes for any f <; n. In such a scenario, no robot can wait for another robot, i.e., the algorithm must be wait-free. We provide such a wait-free algorithm to gather all correct robots assuming the capabilities of strong multiplicity detection and chirality. Unlike previous solutions, our algorithm does not impose the requirement of initially distinct locations, and works for any arbitrary initial configuration of robots (except the bivalent configuration where deterministic gathering is not possible).

In this paper we study the power of using lights, i.e. visible external memory, for distributed computation by autonomous robots moving in Look-Compute-Move (LCM) cycles. With respect to the LCM cycles, the most common models studied in the literature are the fully-synchronous (FSYNC), the semi-synchronous (SSYNC), and the asynchronous (ASYNC). In this paper we introduce in the ASYNC model, the weakest of the three, the availability of visible external memory: each robot is equipped with a light bulb that is visible to all other robots, and that can display a constant numbers of different colors, the colors are persistent, that is they are not automatically reset at the end of each cycle. We first study the relationship between ASYNC with visible bits and SSYNC. We prove hat asynchronous robots, when equipped with a constant number of colors, are strictly more powerful than traditional semi-synchronous robots. We also show that, when enhanced with visible lights, the difference between asynchrony and semi-synchrony disappears, this result must be contrasted with the strict dominance ASYNC

We study the computational power of a distributed system consisting of simple autonomous robots moving on the plane. The robots are endowed with visual perception but do not have any means of explicit communication with each other, and have no memory of the past. In the extensive literature it has been shown how such simple robots can form a single geometric pattern (e.g., a line, a circle, etc), however arbitrary, in spite of their obliviousness. This brings to the front the natural research question: what are the real computational limits imposed by the robots being oblivious? In particular, since obliviousness limits what can be remembered, under what conditions can oblivious robots form a series of geometric patterns? Notice that a series of patterns would create some form of memory in an otherwise memory-less system. In this paper we examine and answer this question showing that, under particular conditions, oblivious robot systems can indeed form series of geometric patterns starting from any arbitrary configuration. More precisely, we study the series of patterns that can be formed by robot systems under various restrictions such as anonymity, asynchrony and lack of common orientation. These results are the first strong indication that oblivious solutions may be obtained also for tasks that intuitively seem to require memory.

We assume that sensors are aware of the positions of neighbors within a specific knowledge range, which is smaller than their maximum transmission range. We propose the GRoVar protocol (Geographic Routing with Variable transmission range) that extends the well-known GFG protocol [2], a combination of greedy forwarding and recovery, by applying variable transmission range and beaconless routing techniques. In our protocol, each node locally selects the best forwarding neighbor within its knowledge range, using power or other metric. If no neighbor is closer to the destination, the current node may incrementally increase its transmission range to find suitable candidates for the next hop, with the help of request messages. Face routing is applied when no forwarding neighbor is found after sending requests with the maximum transmission range. It also applies range increases until recovery is possible. We investigated different possibilities: a linear increase, doubling the range in each iteration or directly jumping to the maximum range possible. The comparison of energy usage for data transfer from source to sink shows that a significant saving in energy consumption can be achieved using the proposed method.

The problem of self-diagnosis of multiprocessor and multicomputer systems under the generalized comparison model (GCM) is considered. GCM assumes that a set of jobs is assigned to pairs of units and that the outcomes are compared by the units themselves (self-diagnosis). Based on the set of comparison outcomes (agreements and disagreements among the units), the set of up to t faulty nodes is identified (t-diagnosable systems). This paper proposes an artificial-immune-based algorithm to solve the fault identification problem. The immune diagnosis algorithm correctly identifies the set of faulty units, and it has been evaluated using randomly generated t-diagnosable systems. Simulation results indicate that the proposed approach is a viable alternative to solve the GCM-based diagnosis problem.