Search

We consider two fundamental communication tasks in arbitrary radio networks: broadcasting (information from one source has to reach all nodes) and gossiping (every node has a message and all messages have to reach all nodes). Nodes are assigned labels that are (not necessarily different) binary strings. Each node knows its own label and can use it as a parameter in the same deterministic algorithm. The length of a labeling scheme is the largest length of a label. The goal is to find labeling schemes of asymptotically optimal length for the above tasks, and to design fast deterministic distributed algorithms for each of them, using labels of optimal length. Our main result concerns broadcasting. We show the existence of a labeling scheme of constant length that supports broadcasting in time $O(D+\log^2 n)$, where $D$ is the diameter of the network and $n$ is the number of nodes. This broadcasting time is an improvement over the best currently known $O(D\log n + \log^2 n)$ time of broadcasting with constant-length labels, due to Ellen and Gilbert (SPAA 2020). It also matches the optimal broadcasting time in radio networks of known topology. Hence, we show that appropriately chosen node labels of constant length permit to achieve, in a distributed way, the optimal centralized broadcasting time. This is, perhaps, the most surprising finding of this paper. We are able to obtain our result thanks to a novel methodological tool of propagating information in radio networks, that we call a 2-height respecting tree. Next, we apply our broadcasting algorithm to solve the gossiping problem. We get a gossiping algorithm working in time $O(D + \Delta\log n + \log^2 n)$, using a labeling scheme of optimal length $O(\log \Delta)$, where $\Delta$ is the maximum degree. Our time is the same as the best known gossiping time in radio networks of known topology.

Two identical anonymous mobile agents have to meet at a node of the infinite oriented grid whose nodes are unlabeled. This problem is known as rendezvous. The agents execute the same deterministic algorithm. Time is divided into rounds, and in each round each agent can either stay idle at the current node or move to an adjacent node. An adversary places the agents at two nodes of the grid at a distance at most $D$, and wakes them up in possibly different rounds. Each agent starts executing the algorithm in its wakeup round. If agents cannot leave any marks on visited nodes then they can never meet, even if they start simultaneously at adjacent nodes and know it. Hence, we assume that each agent marks any unmarked node it visits, and that an agent can distinguish if a node it visits has been previously marked or not. The time of a rendezvous algorithm is the number of rounds between the wakeup of the later agent and rendezvous. We ask the question whether the capability of marking nodes enables the agents to meet, and if so, what is the fastest rendezvous algorithm. We consider this problem under three scenarios. First, agents know $D$ but may start with arbitrary delay. Second, they start simultaneously but do not have any {\em a priori} knowledge. Third, most difficult scenario, we do not make any of the above facilitating assumptions. Agents start with arbitrary delay and they do not have any a priori knowledge. We prove that in the first two scenarios rendezvous can be accomplished in time $O(D)$. This is clearly optimal. For the third scenario, we prove that there does not exist any rendezvous algorithm working in time $o(D^{\sqrt{2}})$, and we show an algorithm working in time $O(D^2)$. The above negative result shows a separation between the optimal complexity in the two easier scenarios and the optimal complexity in the most difficult scenario.

We consider the fundamental task of network exploration. A network is modeled as a simple connected undirected n-node graph with unlabeled nodes, and all ports at any node of degree d are arbitrarily numbered 0,.....,d-1. Each of two identical mobile agents, initially situated at distinct nodes, has to visit all nodes and stop. Agents execute the same deterministic algorithm and move in synchronous rounds: in each round, an agent can either remain at the same node or move to an adjacent node. Exploration must be collision-free: in every round at most one agent can be at any node. We assume that agents have vision of radius 2: an awake agent situated at a node v can see the subgraph induced by all nodes at a distance at most 2 from v, sees all port numbers in this subgraph, and the agents located at these nodes. Agents do not know the entire graph but they know an upper bound n on its size. The time of an exploration is the number of rounds since the wakeup of the later agent to the termination by both agents. We show a collision-free exploration algorithm working in time polynomial in n, for arbitrary graphs of size larger than 2. Moreover, we show that if agents have only vision of radius 1, then collision-free exploration is impossible, e.g., in any tree of diameter 2.

Two mobile agents, starting from different nodes of a network modeled as a graph, and woken up at possibly different times, have to meet at the same node. This problem is known as rendezvous. We consider deterministic distributed rendezvous in the infinite path. Each node has a distinct label which is a positive integer. The time of rendezvous is the number of rounds until meeting, counted from the starting round of the earlier agent. We consider three scenarios. In the first scenario, each agent knows its position in the line, i.e., each of them knows its initial distance from the smallest-labeled node, on which side of this node it is located, and the direction towards it. For this scenario, we give a rendezvous algorithm working in time $O(D)$, where $D$ is the initial distance between the agents. This complexity is clearly optimal. In the second scenario, each agent initially knows only the label of its starting node and the initial distance $D$ between the agents. In this scenario, we give a rendezvous algorithm working in time $O(D\log^*\ell)$, where $\ell$ is the larger label of the starting nodes. We prove a matching lower bound $\Omega(D\log^*\ell)$. Finally, in the most general scenario, where each agent initially knows only the label of its starting node, we give a rendezvous algorithm working in time $O(D^2(\log^*\ell)^3)$, which is at most cubic in the lower bound. All our results remain valid (with small changes) for arbitrary finite paths and for cycles. Our algorithms are drastically better than approaches that use graph exploration, whose running times depend on the graph's size or diameter. Our main methodological tool, and the main novelty of the paper, is a two way reduction: from fast colouring of the infinite labeled path using a constant number of colours in the LOCAL model to fast rendezvous in this path, and vice-versa., Comment: A preliminary version of this paper appeared in the Proceedings of the 37th International Symposium on Distributed Computing (DISC 2023)

We consider the task of computing functions $f: \mathbb{N}^k\to \mathbb{N}$, where $ \mathbb{N}$ is the set of natural numbers, by finite teams of agents modelled as deterministic finite automata. The computation is carried out in a distributed way, using the {\em discrete half-line}, which is the infinite graph with one node of degree 1 (called the root) and infinitely many nodes of degree 2. The node at distance $j$ from the root represents the integer $j$. We say that a team $\mathcal{A}^f$ of automata computes a function $f$, if in the beginning of the computation all automata from $\mathcal{A}^f$ are located at the arguments $x_1,\dots,x_k$ of the function $f$, in groups $\mathcal{A}^f _j$ at $x_j$, and at the end, all automata of the team gather at $f(x_1,\dots,x_k)$ and transit to a special state $STOP$. At each step of the computation, an automaton $a$ can ``see'' states of all automata colocated at the same node: the set of these states forms an input of $a$. Our main result shows that, for every primitive recursive function, there exists a finite team of automata that computes this function. We prove this by showing that basic primitive recursive functions can be computed by teams of automata, and that functions resulting from the operations of composition and of primitive recursion can be computed by teams of automata, provided that the ingredient functions of these operations can be computed by teams of automata. We also observe that cooperation between automata is necessary: even some very simple functions $f: \mathbb{N}\to \mathbb{N}$ cannot be computed by a single automaton.

Treasure hunt and rendezvous are fundamental tasks performed by mobile agents in graphs. In treasure hunt, an agent has to find an inert target (called treasure) situated at an unknown node of the graph. In rendezvous, two agents, initially located at distinct nodes of the graph, traverse its edges in synchronous rounds and have to meet at some node. We assume that the graph is connected (otherwise none of these tasks is feasible) and consider deterministic treasure hunt and rendezvous algorithms. The time of a treasure hunt algorithm is the worst-case number of edge traversals performed by the agent until the treasure is found. The time of a rendezvous algorithm is the worst-case number of rounds since the wakeup of the earlier agent until the meeting. To the best of our knowledge, all known treasure hunt and rendezvous algorithms rely on the assumption that degrees of all nodes are finite, even when the graph itself may be infinite. In the present paper we remove this assumption for the first time, and consider both above tasks in arbitrary connected graphs whose nodes can have either finite or countably infinite degrees. Our main result is the first universal treasure hunt algorithm working for arbitrary connected graphs. We prove that the time of this algorithm has optimal order of magnitude among all possible treasure hunt algorithms working for arbitrary connected graphs. As a consequence of this result we obtain the first universal rendezvous algorithm working for arbitrary connected graphs. The time of this algorithm is polynomial in a lower bound holding in many graphs, in particular in the tree all of whose degrees are infinite.

Graph exploration is one of the fundamental tasks performed by a mobile agent in a graph. An $n$-node graph has unlabeled nodes, and all ports at any node of degree $d$ are arbitrarily numbered $0,\dots, d-1$. A mobile agent, initially situated at some starting node $v$, has to visit all nodes of the graph and stop. In the absence of any initial knowledge of the graph the task of deterministic exploration is often impossible. On the other hand, for some families of graphs it is possible to design deterministic exploration algorithms working for any graph of the family. We call such families of graphs {\em explorable}. Examples of explorable families are all finite families of graphs, as well as the family of all trees. In this paper we study the problem of which families of graphs are explorable. We characterize all such families, and then ask the question whether there exists a universal deterministic algorithm that, given an explorable family of graphs, explores any graph of this family, without knowing which graph of the family is being explored. The answer to this question turns out to depend on how the explorable family is given to the hypothetical universal algorithm. If the algorithm can get the answer to any yes/no question about the family, then such a universal algorithm can be constructed. If, on the other hand, the algorithm can be only given an algorithmic description of the input explorable family, then such a universal deterministic algorithm does not exist.

The task of rendezvous (also called {\em gathering}) calls for a meeting of two or more mobile entities, starting from different positions in some environment. Those entities are called mobile agents or robots, and the environment can be a network modeled as a graph or a terrain in the plane, possibly with obstacles. The rendezvous problem has been studied in many different scenarios. Two among many adopted assumptions particularly influence the methodology to be used to accomplish rendezvous. One of the assumptions specifies whether the agents in their navigation can see something apart from parts of the environment itself, for example other agents or marks left by them. The other assumption concerns the way in which the entities move: it can be either deterministic or randomized. In this paper we survey results on deterministic rendezvous of agents that cannot see the other agents prior to meeting them, and cannot leave any marks.

A mobile agent, modeled as a deterministic finite automaton, navigates in the infinite anonymous oriented grid $\mathbb{Z} \times \mathbb{Z}$. It has to explore a given infinite subgraph of the grid by visiting all of its nodes. We focus on the simplest subgraphs, called {\em wedges}, spanned by all nodes of the grid located between two half-lines in the plane, with a common origin. Many wedges turn out to be impossible to explore by an automaton that cannot mark nodes of the grid. Hence, we study the following question: Given a wedge $W$, what is the smallest number $p$ of (movable) pebbles for which there exists an automaton that can explore $W$ using $p$ pebbles? Our main contribution is a complete solution of this problem. For each wedge $W$ we determine this minimum number $p$, show an automaton that explores it using $p$ pebbles and show that fewer pebbles are not enough. We show that this smallest number of pebbles can vary from 0 to 3, depending on the angle between half-lines limiting the wedge and depending on whether the automaton can cross these half-lines or not.

The rendezvous task calls for two mobile agents, starting from different nodes of a network modeled as a graph to meet at the same node. Agents have different labels which are integers from a set $\{1,\dots,L\}$. They wake up at possibly different times and move in synchronous rounds. In each round, an agent can either stay idle or move to an adjacent node. We consider deterministic rendezvous algorithms. The time of such an algorithm is the number of rounds since the wakeup of the earlier agent till the meeting. In this paper we consider rendezvous in infinite trees. Our main goal is to study the impact of orientation of a tree on the time of rendezvous. We first design a rendezvous algorithm working for unoriented regular trees, whose time is in $O(z(D) \log L)$, where $z(D)$ is the size of the ball of radius $D$, i.e, the number of nodes at distance at most $D$ from a given node. The algorithm works for arbitrary delay between waking times of agents and does not require any initial information about parameters $L$ or $D$. Its disadvantage is its complexity: $z(D)$ is exponential in $D$ for any degree $d>2$ of the tree. We prove that this high complexity is inevitable: $\Omega(z(D))$ turns out to be a lower bound on rendezvous time in unoriented regular trees, even for simultaneous start and even when agents know $L$ and $D$. Then we turn attention to oriented trees. While for arbitrary delay between waking times of agents the lower bound $\Omega(z(D))$ still holds, for simultaneous start the time of rendezvous can be dramatically shortened. We show that if agents know either a polynomial upper bound on $L$ or a linear upper bound on $D$, then rendezvous can be accomplished in oriented trees in time $O(D\log L)$, which is optimal. When no such extra knowledge is available, we design an algorithm working in time $O(D^2+\log ^2L)$.

We consider the fundamental problems of size discovery and topology recognition in radio networks modeled by simple undirected connected graphs. Size discovery calls for all nodes to output the number of nodes in the graph, called its size, and in the task of topology recognition each node has to learn the topology of the graph and its position in it. In radio networks, nodes communicate in synchronous rounds and start in the same round. In each round a node can either transmit the same message to all its neighbors, or stay silent and listen. At the receiving end, a node $v$ hears a message from a neighbor $w$ in a given round, if $v$ listens in this round, and if $w$ is its only neighbor that transmits in this round. If more than one neighbor of a node $v$ transmits in a given round, there is a collision at $v$. We do not assume collision detection: in case of a collision, node $v$ does not hear anything. The time of a deterministic algorithm for each of the above problems is the worst-case number of rounds it takes to solve it. Our goal is to construct short labeling schemes for size discovery and topology recognition in arbitrary radio networks, and to design efficient deterministic algorithms using these schemes. For size discovery, we construct a labeling scheme of length $O(\log\log\Delta)$ and we design an algorithm for this problem using this scheme and working in time $O(\log^2 n)$, where $n$ is the size of the graph. We also show that time complexity $O(\log^2 n)$ is optimal for the problem of size discovery, whenever the labeling scheme is of optimal length. For topology recognition, we construct a labeling scheme of length $O(\log\Delta)$, and we design an algorithm for this problem using this scheme working in time $O\left(D\Delta+\min(\Delta^2,n)\right)$. We also show that the length of our labeling scheme is asymptotically optimal.

A mobile agent navigating along edges of a simple connected graph, either finite or countably infinite, has to find an inert target (treasure) hidden in one of the nodes. This task is known as treasure hunt. The agent has no a priori knowledge of the graph, of the location of the treasure or of the initial distance to it. The cost of a treasure hunt algorithm is the worst-case number of edge traversals performed by the agent until finding the treasure. Awerbuch, Betke, Rivest and Singh [3] considered graph exploration and treasure hunt for finite graphs in a restricted model where the agent has a fuel tank that can be replenished only at the starting node $s$. The size of the tank is $B=2(1+\alpha)r$, for some positive real constant $\alpha$, where $r$, called the radius of the graph, is the maximum distance from $s$ to any other node. The tank of size $B$ allows the agent to make at most $\lfloor B\rfloor$ edge traversals between two consecutive visits at node $s$. Let $e(d)$ be the number of edges whose at least one extremity is at distance less than $d$ from $s$. Awerbuch, Betke, Rivest and Singh [3] conjectured that it is impossible to find a treasure hidden in a node at distance at most $d$ at cost nearly linear in $e(d)$. We first design a deterministic treasure hunt algorithm working in the model without any restrictions on the moves of the agent at cost $\mathcal{O}(e(d) \log d)$, and then show how to modify this algorithm to work in the model from [3] with the same complexity. Thus we refute the above twenty-year-old conjecture. We observe that no treasure hunt algorithm can beat cost $\Theta(e(d))$ for all graphs and thus our algorithms are also almost optimal.

Leader election is one of the fundamental problems in distributed computing: a single node, called the leader, must be specified. This task can be formulated either in a weak way, where one node outputs 'leader' and all other nodes output 'non-leader', or in a strong way, where all nodes must also learn which node is the leader. If the nodes of the network have distinct identifiers, then such an agreement means that all nodes have to output the identifier of the elected leader. For anonymous networks, the strong version of leader election requires that all nodes must be able to find a path to the leader, as this is the only way to identify it. For any network in which leader election (weak or strong) is possible knowing the map of the network, there is a minimum time in which this can be done. We consider four formulations of leader election discussed in the literature in the context of anonymous networks : one is the weak formulation, and the three others specify three different ways of finding the path to the leader in the strong formulation. Our aim is to compare the amount of initial information needed to accomplish each of these "four shades" of leader election in minimum time. We show that the amount of information required to accomplish leader election in the weak formulation in minimum time is exponentially smaller than that needed for any of the strong formulations. Thus, if the required amount of advice is used as a measure of the difficulty of the task, the weakest version of leader election in minimum time is drastically easier than any version of the strong formulation in minimum time.

Two mobile agents represented by points freely moving in the plane and starting at two distinct positions, have to meet. The meeting, called rendezvous, occurs when agents are at distance at most $r$ of each other and never move after this time, where $r$ is a positive real unknown to them, called the visibility radius. Agents are anonymous and execute the same deterministic algorithm. Each agent has a set of private attributes, some or all of which can differ between agents. These attributes are: the initial position of the agent, its system of coordinates (orientation and chirality), the rate of its clock, its speed when it moves, and the time of its wake-up. If all attributes (except the initial positions) are identical and agents start at distance larger than $r$ then they can never meet. However, differences between attributes make it sometimes possible to break the symmetry and accomplish rendezvous. Such instances of the rendezvous problem (formalized as lists of attributes), are called feasible. Our contribution is three-fold. We first give an exact characterization of feasible instances. Thus it is natural to ask whether there exists a single algorithm that guarantees rendezvous for all these instances. We give a strong negative answer to this question: we show two sets $S_1$ and $S_2$ of feasible instances such that none of them admits a single rendezvous algorithm valid for all instances of the set. On the other hand, we construct a single algorithm that guarantees rendezvous for all feasible instances outside of sets $S_1$ and $S_2$. We observe that these exception sets $S_1$ and $S_2$ are geometrically very small, compared to the set of all feasible instances: they are included in low-dimension subspaces of the latter. Thus, our rendezvous algorithm handling all feasible instances other than these small sets of exceptions can be justly called almost universal.

A mobile agent equipped with a compass and a measure of length has to find an inert treasure in the Euclidean plane. Both the agent and the treasure are modeled as points. In the beginning, the agent is at a distance at most $D>0$ from the treasure, but knows neither the distance nor any bound on it. Finding the treasure means getting at distance at most 1 from it. The agent makes a series of moves. Each of them consists in moving straight in a chosen direction at a chosen distance. In the beginning and after each move the agent gets a hint consisting of a positive angle smaller than $2\pi$ whose vertex is at the current position of the agent and within which the treasure is contained. We investigate the problem of how these hints permit the agent to lower the cost of finding the treasure, using a deterministic algorithm, where the cost is the worst-case total length of the agent's trajectory. It is well known that without any hint the optimal (worst case) cost is $\Theta(D^2)$. We show that if all angles given as hints are at most $\pi$, then the cost can be lowered to $O(D)$, which is optimal. If all angles are at most $\beta$, where $\beta<2\pi$ is a constant unknown to the agent, then the cost is at most $O(D^{2-\epsilon})$, for some $\epsilon>0$. For both these positive results we present deterministic algorithms achieving the above costs. Finally, if angles given as hints can be arbitrary, smaller than $2\pi$, then we show that cost $\Theta(D^2)$ cannot be beaten.

We consider leader election in anonymous radio networks modeled as simple undirected connected graphs. Nodes communicate in synchronous rounds. Nodes are anonymous and execute the same deterministic algorithm, so symmetry can be broken only in one way: by different wake-up times of the nodes. In which situations is it possible to break symmetry and elect a leader using time as symmetry breaker? To answer this question, we consider configurations. A configuration is the underlying graph with nodes tagged by non-negative integers with the following meaning. A node can either wake up spontaneously in the round shown on its tag, according to some global clock, or can be woken up hearing a message sent by one of its already awoken neighbours. The local clock of a node starts at its wakeup and nodes do not have access to the global clock determining their tags. A configuration is feasible if there exists a distributed algorithm that elects a leader for this configuration. Our main result is a complete algorithmic characterization of feasible configurations: we design a centralized decision algorithm, working in polynomial time, whose input is a configuration and which decides if the configuration is feasible. We also provide a dedicated deterministic distributed leader election algorithm for each feasible configuration that elects a leader for this configuration in time $O(n^2\sigma)$, where $n$ is the number of nodes and $\sigma$ is the difference between the largest and smallest tag of the configuration. We then prove that there cannot exist a universal deterministic distributed algorithm electing a leader for all feasible configurations. In fact, we show that such a universal algorithm cannot exist even for the class of 4-node feasible configurations. We also prove that a distributed version of our decision algorithm cannot exist., Comment: 33 pages

A team of mobile agents, starting from different nodes of an unknown network, possibly at different times, have to meet at the same node and declare that they have all met. Agents have different labels and move in synchronous rounds along links of the network. The above task is known as gathering and was traditionally considered under the assumption that when some agents are at the same node then they can talk. In this paper we ask the question of whether this ability of talking is needed for gathering. The answer turns out to be no. Our main contribution are two deterministic algorithms that always accomplish gathering in a much weaker model. We only assume that at any time an agent knows how many agents are at the node that it currently occupies but agents do not see the labels of other co-located agents and cannot exchange any information with them. They also do not see other nodes than the current one. Our first algorithm works under the assumption that agents know a priori some upper bound N on the network size, and it works in time polynomial in N and in the length l of the smallest label. Our second algorithm does not assume any a priori knowledge about the network but its complexity is exponential in the network size and in the labels of agents. Its purpose is to show feasibility of gathering under this harsher scenario. As a by-product of our techniques we obtain, in the same weak model, the solution of the fundamental problem of leader election among agents. As an application of our result we also solve, in the same model, the well-known gossiping problem: if each agent has a message at the beginning, we show how to make all messages known to all agents, even without any a priori knowledge about the network. If agents know an upper bound N on the network size then our gossiping algorithm works in time polynomial in N, in l and in the length of the largest message.

A robot modeled as a deterministic finite automaton has to build a structure from material available to it. The robot navigates in the infinite oriented grid $\mathbb{Z} \times \mathbb{Z}$. Some cells of the grid are full (contain a brick) and others are empty. The subgraph of the grid induced by full cells, called the field, is initially connected. The (Manhattan) distance between the farthest cells of the field is called its span. The robot starts at a full cell. It can carry at most one brick at a time. At each step it can pick a brick from a full cell, move to an adjacent cell and drop a brick at an empty cell. The aim of the robot is to construct the most compact possible structure composed of all bricks, i.e., a nest. That is, the robot has to move all bricks in such a way that the span of the resulting field be the smallest. Our main result is the design of a deterministic finite automaton that accomplishes this task and subsequently stops, for every initially connected field, in time $O(sz)$, where $s$ is the span of the initial field and $z$ is the number of bricks. We show that this complexity is optimal.

A mobile agent has to find an inert treasure hidden in the plane. Both the agent and the treasure are modeled as points. This is a variant of the task known as treasure hunt. The treasure is at a distance at most $D$ from the initial position of the agent, and the agent finds the treasure when it gets at distance $r$ from it, called the {\em vision radius}. However, the agent does not know the location of the treasure and does not know the parameters $D$ and $r$. The cost of finding the treasure is the length of the trajectory of the agent. We investigate the tradeoffs between the amount of information held {\em a priori} by the agent and the cost of treasure hunt. Following the well-established paradigm of {\em algorithms with advice}, this information is given to the agent in advance as a binary string, by an oracle cooperating with the agent and knowing the location of the treasure and the initial position of the agent. The size of advice given to the agent is the length of this binary string. For any size $z$ of advice and any $D$ and $r$, let $OPT(z,D,r)$ be the optimal cost of finding the treasure for parameters $z$, $D$ and $r$, if the agent has only an advice string of length $z$ as input. We design treasure hunt algorithms working with advice of size $z$ at cost $O(OPT(z,D,r))$ whenever $r\leq 1$ or $r\geq 0.9D$. For intermediate values of $r$, i.e., $10$, the treasure can be found at cost $O(OPT(z,D,r)^{1+\alpha})$.

Treasure hunt is the task of finding an inert target by a mobile agent in an unknown environment. We consider treasure hunt in geometric terrains with obstacles. Both the terrain and the obstacles are modeled as polygons and both the agent and the treasure are modeled as points. The agent navigates in the terrain, avoiding obstacles, and finds the treasure when there is a segment of length at most 1 between them, unobstructed by the boundary of the terrain or by the obstacles. The cost of finding the treasure is the length of the trajectory of the agent. We investigate the amount of information that the agent needs a priori in order to find the treasure at cost $O(L)$, where $L$ is the length of the shortest path in the terrain from the initial position of the agent to the treasure, avoiding obstacles. Following the paradigm of algorithms with advice, this information is given to the agent in advance as a binary string, by an oracle cooperating with the agent and knowing the whole environment: the terrain, the position of the treasure and the initial position of the agent. Advice complexity of treasure hunt is the minimum length of the advice string (up to multiplicative constants) that enables the agent to find the treasure at cost $O(L)$. We first consider treasure hunt in regular terrains which are defined as convex polygons with convex $c$-fat obstacles, for some constant $c>1$. A polygon is $c$-fat if the ratio of the radius of the smallest disc containing it to the radius of the largest disc contained in it is at most $c$. For the class of regular terrains, we establish the exact advice complexity of treasure hunt. We then show that advice complexity of treasure hunt for the class of arbitrary terrains (even for non-convex polygons without obstacles, and even for those with only horizontal or vertical sides) is exponentially larger than for regular terrains.

A team of anonymous mobile agents represented by points freely moving in the plane have to gather at a single point and stop. Agents start at different points of the plane and at possibly different times chosen by the adversary. They are equipped with compasses, a common unit of distance and clocks. They execute the same deterministic algorithm and travel at speed 1. When agents are at distance at most $\epsilon$, for some positive constant $\epsilon$ unknown to them, they can exchange all information. Due to the anonymity of the agents and the symmetry of the plane, gathering is impossible, e.g., if agents start simultaneously at distances larger than $\epsilon$. However, if some agents start with a delay with respect to others, gathering may become possible. In which situations such latecomers can enable gathering? To answer this question we consider initial configurations formalized as sets of pairs $\{(p_1,t_1), (p_2,t_2),\dots , (p_n,t_n)\}$, for $n\geq 2$ where $p_i$ is the starting point of the $i$-th agent and $t_i$ is its starting time. An initial configuration is gatherable if agents starting at it can be gathered by some algorithm, even dedicated to this particular configuration. We characterize all gatherable initial configurations. Is there a universal deterministic algorithm that can gather all gatherable configurations of a given size. It turns out that the answer is no. We show that all gatherable configurations can be partitioned into two sets: bad and good configurations. We show that bad gatherable configurations (even of size 2) cannot be gathered by a common gathering algorithm, and we prove that there is a universal algorithm that gathers all good configurations of a given size.

Two anonymous mobile agents navigate synchronously in an anonymous graph and have to meet at a node, using a deterministic algorithm. This is a symmetry breaking task called rendezvous, equivalent to the fundamental task of leader election between the agents. When is this feasible in a completely anonymous environment? It is known that agents can always meet if their initial positions are nonsymmetric, and that if they are symmetric and agents start simultaneously then rendezvous is impossible. What happens for symmetric initial positions with non-simultaneous start? Can symmetry between the agents be broken by the delay between their starting times? In order to answer these questions, we consider {\em space-time initial configurations} (abbreviated by STIC). A STIC is formalized as $[(u,v),\delta]$, where $u$ and $v$ are initial nodes of the agents in some graph and $\delta$ is a non-negative integer that represents the difference between their starting times. A STIC is {\em feasible} if there exists a deterministic algorithm, even dedicated to this particular STIC, which accomplishes rendezvous for it. Our main result is a characterization of all feasible STICs and the design of a universal deterministic algorithm that accomplishes rendezvous for all of them without {\em any } a priori knowledge of the agents. Thus, as far as feasibility is concerned, we completely solve the problem of symmetry breaking between two anonymous agents in anonymous graphs. Moreover, we show that such a universal algorithm cannot work for all feasible STICs in time polynomial in the initial distance between the agents.

We consider Parallel Random Access Machine (PRAM) which has some processors and memory cells faulty. The faults considered are static, i.e., once the machine starts to operate, the operational/faulty status of PRAM components does not change. We develop a deterministic simulation of a fully operational PRAM on a similar faulty machine which has constant fractions of faults among processors and memory cells. The simulating PRAM has $n$ processors and $m$ memory cells, and simulates a PRAM with $n$ processors and a constant fraction of $m$ memory cells. The simulation is in two phases: it starts with preprocessing, which is followed by the simulation proper performed in a step-by-step fashion. Preprocessing is performed in time $O((\frac{m}{n}+ \log n)\log n)$. The slowdown of a step-by-step part of the simulation is $O(\log m)$.

We consider the task of rendezvous in networks modeled as undirected graphs. Two mobile agents with different labels, starting at different nodes of an anonymous graph, have to meet. This task has been considered in the literature under two alternative scenarios: weak and strong. Under the weak scenario, agents may meet either at a node or inside an edge. Under the strong scenario, they have to meet at a node, and they do not even notice meetings inside an edge. Rendezvous algorithms under the strong scenario are known for synchronous agents. For asynchronous agents, rendezvous under the strong scenario is impossible even in the two-node graph, and hence only algorithms under the weak scenario were constructed. In this paper we show that rendezvous under the strong scenario is possible for agents with restricted asynchrony: agents have the same measure of time but the adversary can arbitrarily impose the speed of traversing each edge by each of the agents. We construct a deterministic rendezvous algorithm for such agents, working in time polynomial in the size of the graph, in the length of the smaller label, and in the largest edge traversal time., Comment: arXiv admin note: text overlap with arXiv:1704.08880

A mobile agent has to reach a target in the Euclidean plane. Both the agent and the target are modeled as points. In the beginning, the agent is at distance at most $D>0$ from the target. Reaching the target means that the agent gets at a {\em sensing distance} at most $r>0$ from it. The agent has a measure of length and a compass. We consider two scenarios: in the {\em static} scenario the target is inert, and in the {\em dynamic} scenario it may move arbitrarily at any (possibly varying) speed bounded by $v$. The agent has no information about the parameters of the problem, in particular it does not know $D$, $r$ or $v$. The goal is to reach the target at lowest possible cost, measured by the total length of the trajectory of the agent. Our main result is establishing the minimum cost (up to multiplicative constants) of reaching the target under both scenarios, and providing the optimal algorithm for the agent. For the static scenario the minimum cost is $\Theta((\log D + \log \frac{1}{r}) D^2/r)$, and for the dynamic scenario it is $\Theta((\log M + \log \frac{1}{r}) M^2/r)$, where $M=\max(D,v)$. Under the latter scenario, the speed of the agent in our algorithm grows exponentially with time, and we prove that for an agent whose speed grows only polynomially with time, this cost is impossible to achieve.

Broadcast is one of the fundamental network communication primitives. One node of a network, called the $\mathit{source}$, has a message that has to be learned by all other nodes. We consider the feasibility of deterministic broadcast in radio networks. If nodes of the network do not have any labels, deterministic broadcast is impossible even in the four-cycle. On the other hand, if all nodes have distinct labels, then broadcast can be carried out, e.g., in a round-robin fashion, and hence $O(\log n)$-bit labels are sufficient for this task in $n$-node networks. In fact, $O(\log \Delta)$-bit labels, where $\Delta$ is the maximum degree, are enough to broadcast successfully. Hence, it is natural to ask if very short labels are sufficient for broadcast. Our main result is a positive answer to this question. We show that every radio network can be labeled using 2 bits in such a way that broadcast can be accomplished by some universal deterministic algorithm that does not know the network topology nor any bound on its size. Moreover, at the expense of an extra bit in the labels, we get the additional strong property that there exists a common round in which all nodes know that broadcast has been completed. Finally, we show that 3-bit labels are also sufficient to solve both versions of broadcast in the case where the labeling scheme does not know which node is the source., Comment: updated version of the paper that appeared in SPAA 2019: now contains a solution for the case where the source node is not designated when the labeling scheme is applied

Two mobile agents, starting at arbitrary, possibly different times from arbitrary locations in the plane, have to meet. Agents are modeled as discs of diameter 1, and meeting occurs when these discs touch. Agents have different labels which are integers from the set of 0 to L-1. Each agent knows L and knows its own label, but not the label of the other agent. Agents are equipped with compasses and have synchronized clocks. They make a series of moves. Each move specifies the direction and the duration of moving. This includes a null move which consists in staying inert for some time, or forever. In a non-null move agents travel at the same constant speed, normalized to 1. We assume that agents have sensors enabling them to estimate the distance from the other agent (defined as the distance between centers of discs), but not the direction towards it. We consider two models of estimation. In both models an agent reads its sensor at the moment of its appearance in the plane and then at the end of each move. This reading (together with the previous ones) determines the decision concerning the next move. In both models the reading of the sensor tells the agent if the other agent is already present. Moreover, in the monotone model, each agent can find out, for any two readings in moments t1 and t2, whether the distance from the other agent at time t1 was smaller, equal or larger than at time t2. In the weaker binary model, each agent can find out, at any reading, whether it is at distance less than \r{ho} or at distance at least \r{ho} from the other agent, for some real \r{ho} > 1 unknown to them. Such distance estimation mechanism can be implemented, e.g., using chemical sensors. Each agent emits some chemical substance (scent), and the sensor of the other agent detects it, i.e., sniffs. The intensity of the scent decreases with the distance., Comment: A preliminary version of this paper appeared in the Proc. 23rd International Colloquium on Structural Information and Communication Complexity (SIROCCO 2016), LNCS 9988

Two mobile agents, starting at arbitrary, possibly different times from arbitrary nodes of an unknown network, have to meet at some node. Agents move in synchronous rounds: in each round an agent can either stay at the current node or move to one of its neighbors. Agents have different labels which are positive integers. Each agent knows its own label, but not the label of the other agent. In traditional formulations of the rendezvous problem, meeting is accomplished when the agents get to the same node in the same round. We want to achieve a more demanding goal, called rendezvous with detection: agents must become aware that the meeting is accomplished, simultaneously declare this and stop. This awareness depends on how an agent can communicate to the other agent its presence at a node. We use two variations of the arguably weakest model of communication, called the beeping model, introduced in [8]. In each round an agent can either listen or beep. In the local beeping model, an agent hears a beep in a round if it listens in this round and if the other agent is at the same node and beeps. In the global beeping model, an agent hears a loud beep in a round if it listens in this round and if the other agent is at the same node and beeps, and it hears a soft beep in a round if it listens in this round and if the other agent is at some other node and beeps. We first present a deterministic algorithm of rendezvous with detection working, even for the local beeping model, in an arbitrary unknown network in time polynomial in the size of the network and in the length of the smaller label (i.e., in the logarithm of this label). However, in this algorithm, agents spend a lot of energy: the number of moves that an agent must make, is proportional to the time of rendezvous. It is thus natural to ask if bounded-energy agents can always achieve rendezvous with detection as well..., Comment: A preliminary version of this paper appeared in Proc. 11th International Symposium on Algorithms and Experiments for Wireless Sensor Networks (ALGOSENSORS 2015), LNCS 9536, 85-97

We investigate initial information, unbounded memory and randomization in gathering mobile agents on a grid. We construct a state machine, such that it is possible to gather, with probability 1, all configurations of its copies. This machine has initial input, unbounded memory, and is randomized. We show that no machine having any two of these capabilities but not the third, can be used to gather, with high probability, all configurations. We construct deterministic Turing Machines that are used to gather all connected configurations, and we construct deterministic finite automata that are used to gather all contractible connected configurations.

A $k$-dominating set is a set $D$ of nodes of a graph such that, for each node $v$, there exists a node $w \in D$ at distance at most $k$ from $v$. Our aim is the deterministic distributed construction of small $T$-dominating sets in time $T$ in networks modeled as undirected $n$-node graphs and under the $\cal{LOCAL}$ communication model. For any positive integer $T$, if $b$ is the size of a pairwise disjoint collection of balls of radii at least $T$ in a graph, then $b$ is an obvious lower bound on the size of a $T$-dominating set. Our first result shows that, even on rings, it is impossible to construct a $T$-dominating set of size $s$ asymptotically $b$ (i.e., such that $s/b \rightarrow 1$) in time $T$. In the range of time $T \in \Theta (\log^* n)$, the size of a $T$-dominating set turns out to be very sensitive to multiplicative constants in running time. Indeed, it follows from \cite{KP}, that for time $T=\gamma \log^* n$ with large constant $\gamma$, it is possible to construct a $T$-dominating set whose size is a small fraction of $n$. By contrast, we show that, for time $T=\alpha \log^* n $ for small constant $\alpha$, the size of a $T$-dominating set must be a large fraction of $n$. Finally, when $T \in o (\log^* n)$, the above lower bound implies that, for any constant $x<1$, it is impossible to construct a $T$-dominating set of size smaller than $xn$, even on rings. On the positive side, we provide an algorithm that constructs a $T$-dominating set of size $n- \Theta(T)$ on all graphs., Comment: 13 pages

A team consisting of an unknown number of mobile agents, starting from different nodes of an unknown network, have to meet at the same node and terminate. This problem is known as {\em gathering}. We study deterministic gathering algorithms under the assumption that agents are subject to {\em crash faults} which can occur at any time. Two fault scenarios are considered. A {\em motion fault} immobilizes the agent at a node or inside an edge but leaves intact its memory at the time when the fault occurred. A more severe {\em total fault} immobilizes the agent as well, but also erases its entire memory. Of course, we cannot require faulty agents to gather. Thus the gathering problem for fault prone agents calls for all fault-free agents to gather at a single node, and terminate. When agents move completely asynchronously, gathering with crash faults of any type is impossible. Hence we consider a restricted version of asynchrony, where each agent is assigned by the adversary a fixed speed, possibly different for each agent. Agents have clocks ticking at the same rate. Each agent can wait for a time of its choice at any node, or decide to traverse an edge but then it moves at constant speed assigned to it. Moreover, agents have different labels. Each agent knows its label and speed but not those of other agents. We construct a gathering algorithm working for any team of at least two agents in the scenario of motion faults, and a gathering algorithm working in the presence of total faults, provided that at least two agents are fault free all the time. If only one agent is fault free, the task of gathering with total faults is sometimes impossible. Both our algorithms work in time polynomial in the size of the graph, in the logarithm of the largest label, in the inverse of the smallest speed, and in the ratio between the largest and the smallest speed.

The number of nodes of a network, called its size, and the largest distance between nodes of a network, called its diameter, are among the most important network parameters. Knowing the size and/or diameter is a prerequisite of many distributed network algorithms. A radio network is a collection of nodes, with wireless transmission and receiving capabilities. It is modeled as a simple undirected graph whose nodes communicate in synchronous rounds. In each round, a node can either transmit a message to all its neighbors, or stay silent and listen. At the receiving end, a node $v$ hears a message from a neighbor $w$ in a round $i$, if $v$ listens in round $i$, and if $w$ is its only neighbor that transmits in round $i$. If $v$ listens in a round, and multiple neighbors of $v$ transmit in this round, a collision occurs at $v$. If $v$ transmits in a round, it does not hear anything. If listening nodes can distinguish collision from silence, we say that the network has collision detection capability, otherwise there is no collision detection. We consider the tasks of size discovery and diameter discovery: finding the size (resp. the diameter) of an unknown radio network with collision detection. All nodes have to output the size (resp. the diameter) of the network, using a deterministic algorithm. Nodes have labels which are binary strings. The length of a labeling scheme is the largest length of a label. We concentrate on the following problems: 1. What is the shortest labeling scheme that permits size discovery in all radio networks of maximum degree $\Delta$? 2. What is the shortest labeling scheme that permits diameter discovery in all radio networks? We show that the minimum length of a labeling scheme that permits size discovery is $\Theta(\log\log \Delta)$. By contrast, we show that diameter discovery can be done using a labeling scheme of constant length.

We consider the problem of topology recognition in wireless (radio) networks modeled as undirected graphs. Topology recognition is a fundamental task in which every node of the network has to output a map of the underlying graph i.e., an isomorphic copy of it, and situate itself in this map. In wireless networks, nodes communicate in synchronous rounds. In each round a node can either transmit a message to all its neighbors, or stay silent and listen. At the receiving end, a node $v$ hears a message from a neighbor $w$ in a given round, if $v$ listens in this round, and if $w$ is its only neighbor that transmits in this round. Nodes have labels which are (not necessarily different) binary strings. The length of a labeling scheme is the largest length of a label. We concentrate on wireless networks modeled by trees, and we investigate two problems. \begin{itemize} \item What is the shortest labeling scheme that permits topology recognition in all wireless tree networks of diameter $D$ and maximum degree $\Delta$? \item What is the fastest topology recognition algorithm working for all wireless tree networks of diameter $D$ and maximum degree $\Delta$, using such a short labeling scheme? \end{itemize} We are interested in deterministic topology recognition algorithms. For the first problem, we show that the minimum length of a labeling scheme allowing topology recognition in all trees of maximum degree $\Delta \geq 3$ is $\Theta(\log\log \Delta)$. For such short schemes, used by an algorithm working for the class of trees of diameter $D\geq 4$ and maximum degree $\Delta \geq 3$, we show almost matching bounds on the time of topology recognition: an upper bound $O(D\Delta)$, and a lower bound $\Omega(D\Delta^{\epsilon})$, for any constant $\epsilon<1$.

Leader election is a basic symmetry breaking problem in distributed computing. All nodes of a network have to agree on a single node, called the leader. If the nodes of the network have distinct labels, then agreeing on a single node means that all nodes have to output the label of the elected leader. If the nodes are anonymous, the task of leader election is formulated as follows: every node of the network must output a simple path starting at it, which is coded as a sequence of port numbers, such that all these paths end at a common node, the leader. In this paper, we study deterministic leader election in anonymous trees. Our goal is to establish tradeoffs between the allocated time $\tau$ and the amount of information that has to be given {\em a priori} to the nodes of a network to enable leader election in time $\tau$. Following the framework of {\em algorithms with advice}, this information is provided to all nodes at the start by an oracle knowing the entire tree, in form of binary strings assigned to all nodes. There are two possible variants of formulating this advice assignment. Either the strings provided to all nodes are identical, or strings assigned to different nodes may be potentially different, i.e., advice can be {\em customized}. As opposed to previous papers on leader election with advice, in this paper we consider the latter option. The maximum length of all assigned binary strings is called the {\em size of advice}. For a given time $\tau$ allocated to leader election, we give upper and lower bounds on the minimum size of advice sufficient to perform leader election in time $\tau$. All our bounds except one pair are tight up to multiplicative constants, and in this one exceptional case, the gap between the upper and the lower bound is very small.

In broadcasting, one node of a network has a message that must be learned by all other nodes. We study deterministic algorithms for this fundamental communication task in a very weak model of wireless communication. The only signals sent by nodes are beeps. Moreover, they are delivered to neighbors of the beeping node in an asynchronous way: the time between sending and reception is finite but unpredictable. We first observe that under this scenario, no communication is possible, if beeps are all of the same strength. Hence we study broadcasting in the bivalent beeping model, where every beep can be either soft or loud. At the receiving end, if exactly one soft beep is received by a node in a round, it is heard as soft. Any other combination of beeps received in a round is heard as a loud beep. The cost of a broadcasting algorithm is the total number of beeps sent by all nodes. We consider four levels of knowledge that nodes may have about the network: anonymity (no knowledge whatsoever), ad-hoc (all nodes have distinct labels and every node knows only its own label), neighborhood awareness (every node knows its label and labels of all neighbors), and full knowledge (every node knows the entire labeled map of the network and the identity of the source). We first show that in the anonymous case, broadcasting is impossible even for very simple networks. For each of the other three knowledge levels we provide upper and lower bounds on the minimum cost of a broadcasting algorithm. Our results show separations between all these scenarios. Perhaps surprisingly, the jump in broadcasting cost between the ad-hoc and neighborhood awareness levels is much larger than between the neighborhood awareness and full knowledge levels, although in the two former levels knowledge of nodes is local, and in the latter it is global.

We consider the task of graph exploration. An $n$-node graph has unlabeled nodes, and all ports at any node of degree $d$ are arbitrarily numbered $0,\dots, d-1$. A mobile agent has to visit all nodes and stop. The exploration time is the number of edge traversals. We consider the problem of how much knowledge the agent has to have a priori, in order to explore the graph in a given time, using a deterministic algorithm. This a priori information (advice) is provided to the agent by an oracle, in the form of a binary string, whose length is called the size of advice. We consider two types of oracles. The instance oracle knows the entire instance of the exploration problem, i.e., the port-numbered map of the graph and the starting node of the agent in this map. The map oracle knows the port-numbered map of the graph but does not know the starting node of the agent. We first consider exploration in polynomial time, and determine the exact minimum size of advice to achieve it. This size is $\log\log\log n -\Theta(1)$, for both types of oracles. When advice is large, there are two natural time thresholds: $\Theta(n^2)$ for a map oracle, and $\Theta(n)$ for an instance oracle, that can be achieved with sufficiently large advice. We show that, with a map oracle, time $\Theta(n^2)$ cannot be improved in general, regardless of the size of advice. We also show that the smallest size of advice to achieve this time is larger than $n^\delta$, for any $\delta <1/3$. For an instance oracle, advice of size $O(n\log n)$ is enough to achieve time $O(n)$. We show that, with any advice of size $o(n\log n)$, the time of exploration must be at least $n^\epsilon$, for any $\epsilon <2$, and with any advice of size $O(n)$, the time must be $\Omega(n^2)$. We also investigate minimum advice sufficient for fast exploration of hamiltonian graphs.

Leader election is one of the basic problems in distributed computing. For anonymous networks, the task of leader election is formulated as follows: every node v of the network must output a simple path, which is coded as a sequence of port numbers, such that all these paths end at a common node, the leader. In this paper, we study deterministic leader election in arbitrary anonymous networks. It is well known that leader election is impossible in some networks, regardless of the allocated amount of time, even if nodes know the map of the network. However, even in networks in which it is possible to elect a leader knowing the map, the task may be still impossible without any knowledge, regardless of the allocated time. On the other hand, for any network in which leader election is possible knowing the map, there is a minimum time, called the election index, in which this can be done. Informally, the election index of a network is the minimum depth at which views of all nodes are distinct. Our aim is to establish tradeoffs between the allocated time $\tau$ and the amount of information that has to be given a priori to the nodes to enable leader election in time $\tau$ in all networks for which leader election in this time is at all possible. Following the framework of algorithms with advice, this information is provided to all nodes at the start by an oracle knowing the entire network. The length of this string (its number of bits) is called the size of advice. For a given time $\tau$ allocated to leader election, we give upper and lower bounds on the minimum size of advice sufficient to perform leader election in time $\tau$. We focus on the two sides of the time spectrum and give tight (or almost tight) bounds on the minimum size of advice for these extremes. We also show that constant advice is not sufficient for leader election in all graphs, regardless of the allocated time.

A set of identical, mobile agents is deployed in a weighted network. Each agent has a battery -- a power source allowing it to move along network edges. An agent uses its battery proportionally to the distance traveled. We consider two tasks : convergecast, in which at the beginning, each agent has some initial piece of information, and information of all agents has to be collected by some agent; and broadcast in which information of one specified agent has to be made available to all other agents. In both tasks, the agents exchange the currently possessed information when they meet. The objective of this paper is to investigate what is the minimal value of power, initially available to all agents, so that convergecast or broadcast can be achieved. We study this question in the centralized and the distributed settings. In the centralized setting, there is a central monitor that schedules the moves of all agents. In the distributed setting every agent has to perform an algorithm being unaware of the network. In the centralized setting, we give a linear-time algorithm to compute the optimal battery power and the strategy using it, both for convergecast and for broadcast, when agents are on the line. We also show that finding the optimal battery power for convergecast or for broadcast is NP-hard for the class of trees. On the other hand, we give a polynomial algorithm that finds a 2-approximation for convergecast and a 4-approximation for broadcast, for arbitrary graphs. In the distributed setting, we give a 2-competitive algorithm for convergecast in trees and a 4-competitive algorithm for broadcast in trees. The competitive ratio of 2 is proved to be the best for the problem of convergecast, even if we only consider line networks. Indeed, we show that there is no (2 -- $\epsilon$)-competitive algorithm for convergecast or for broadcast in the class of lines, for any $\epsilon$ \textgreater{} 0.

We consider the problem of exploration of networks, some of whose edges are faulty. A mobile agent, situated at a starting node and unaware of which edges are faulty, has to explore the connected fault-free component of this node by visiting all of its nodes. The cost of the exploration is the number of edge traversals. For a given network and given starting node, the overhead of an exploration algorithm is the worst-case ratio (taken over all fault configurations) of its cost to the cost of an optimal algorithm which knows where faults are situated. An exploration algorithm, for a given network and given starting node, is called perfectly competitive if its overhead is the smallest among all exploration algorithms not knowing the location of faults. We design a perfectly competitive exploration algorithm for any ring, and show that, for networks modeled by hamiltonian graphs, the overhead of any DFS exploration is at most 10/9 times larger than that of a perfectly competitive algorithm. Moreover, for hamiltonian graphs of size at least 24, this overhead is less than 6% larger than that of a perfectly competitive algorithm., Comment: 17 pages, 1 figure

Topology recognition and leader election are fundamental tasks in distributed computing in networks. The first of them requires each node to find a labeled isomorphic copy of the network, while the result of the second one consists in a single node adopting the label 1 (leader), with all other nodes adopting the label 0 and learning a path to the leader. We consider both these problems in networks whose nodes are equipped with not necessarily distinct labels called colors, and ports at each node of degree $d$ are arbitrarily numbered $0,1,\dots, d-1$. Colored networks are generalizations both of labeled networks and anonymous networks. In colored networks, topology recognition and leader election are not always feasible. Hence we study two more general problems. The aim of the problem TOP (resp. LE), for a colored network and for input $I$ given to its nodes, is to solve topology recognition (resp. leader election) in this network, if this is possible under input $I$, and to have all nodes answer "unsolvable" otherwise. We show that nodes of a network can solve problems TOP and LE, if they are given, as input $I$, an upper bound $k$ on the number of nodes of a given color, called the size of this color. On the other hand we show that, if the nodes are given an input that does not bound the size of any color, then the answer to TOP and LE must be "unsolvable", even for the class of rings. Under the assumption that nodes are given an upper bound $k$ on the size of a given color, we study the time of solving problems TOP and LE in the $LOCAL$. We give an algorithm to solve each of these problems in arbitrary $n$-node networks of diameter $D$ in time $O(kD+D\log(n/D))$. We also show that this time is optimal, by exhibiting classes of networks in which every algorithm solving problems TOP or LE must use time $\Omega(kD+D\log(n/D))$.

In topology recognition, each node of an anonymous network has to deterministically produce an isomorphic copy of the underlying graph, with all ports correctly marked. This task is usually unfeasible without any a priori information. Such information can be provided to nodes as advice. An oracle knowing the network can give a (possibly different) string of bits to each node, and all nodes must reconstruct the network using this advice, after a given number of rounds of communication. During each round each node can exchange arbitrary messages with all its neighbors and perform arbitrary local computations. The time of completing topology recognition is the number of rounds it takes, and the size of advice is the maximum length of a string given to nodes. We investigate tradeoffs between the time in which topology recognition is accomplished and the minimum size of advice that has to be given to nodes. We provide upper and lower bounds on the minimum size of advice that is sufficient to perform topology recognition in a given time, in the class of all graphs of size $n$ and diameter $D\le \alpha n$, for any constant $\alpha< 1$. In most cases, our bounds are asymptotically tight.

Consensus is one of the fundamental tasks studied in distributed computing. Processors have input values from some set $V$ and they have to decide the same value from this set. If all processors have the same input value, then they must all decide this value. We study the task of consensus in a Multiple Access Channel (MAC) prone to faults, under a very weak communication model called the $\mathit{beeping\ model}$. Communication proceeds in synchronous rounds. Some processors wake up spontaneously, in possibly different rounds decided by an adversary. In each round, an awake processor can either listen, i.e., stay silent, or beep, i.e., emit a signal. In each round, a fault can occur in the channel independently with constant probability $00$, is called $\epsilon$-$\mathit{safe}$. Our main result is the design and analysis, for any constant $\epsilon>0$, of a deterministic $\epsilon$-safe consensus algorithm that works in time $O(\log w)$ in a fault-prone MAC, where $w$ is the smallest input value of all participating processors. We show that this time cannot be improved, even when the MAC is fault-free. The main algorithmic tool that we develop to achieve our goal, and that might be of independent interest, is a deterministic algorithm that, with arbitrarily small constant error probability, establishes a global clock in a fault-prone MAC in constant time.

Broadcasting and gossiping are fundamental communication tasks in networks. In broadcasting,one node of a network has a message that must be learned by all other nodes. In gossiping, every node has a (possibly different) message, and all messages must be learned by all nodes. We study these well-researched tasks in a very weak communication model, called the {\em beeping model}. Communication proceeds in synchronous rounds. In each round, a node can either listen, i.e., stay silent, or beep, i.e., emit a signal. A node hears a beep in a round, if it listens in this round and if one or more adjacent nodes beep in this round. All nodes have different labels from the set $\{0,\dots , L-1\}$. Our aim is to provide fast deterministic algorithms for broadcasting and gossiping in the beeping model. Let $N$ be an upper bound on the size of the network and $D$ its diameter. Let $m$ be the size of the message in broadcasting, and $M$ an upper bound on the size of all input messages in gossiping. For the task of broadcasting we give an algorithm working in time $O(D+m)$ for arbitrary networks, which is optimal. For the task of gossiping we give an algorithm working in time $O(N(M+D\log L))$ for arbitrary networks. At the time of writing this paper we were unaware of the paper: A. Czumaj, P. Davis, Communicating with Beeps, arxiv:1505.06107 [cs.DC] which contains the same results for broadcasting and a stronger upper bound for gossiping in a slightly different model.