arXiv subjects

Avery Miller

Publications and source records attributed to Avery Miller.

At least 19 recordsLinked to original sources

arXiv2026

Don't Be Afraid to Die: Black Hole Search in Dynamic Graphs with Fewer Agents

We consider a team of synchronous mobile agents operating in a port-labeled network. There is one node in the network, called a black hole, that permanently destroys any agent that visits the node. The team of agents must safely locate the black hole, i.e., at least one agent must survive, terminate its algorithm at a node adjacent to the black hole, and output the port number that leads to the black hole from its current position. In the setting where the network is a 1-bounded 1-interval connected dynamic graph, Kaur et al. (SSS 2025) showed that a team consisting of $2\delta_{BH}+17$ agents is sufficient to solve the task from a scattered configuration, where $\delta_{BH}$ denotes the degree of the black hole node. We show that $2\delta_{BH}+3$ agents are sufficient, nearly matching the $2\delta_{BH}+1$ lower bound provided in Kaur et al. (ICDCN 2025).

cs.DC↗

arXiv2024

Reconfiguration of Multisets with Applications to Bin Packing

We use the reconfiguration framework to analyze problems that involve the rearrangement of items among groups. In various applications, a group of items could correspond to the files or jobs assigned to a particular machine, and the goal of rearrangement could be improving efficiency or increasing locality. To cover problems arising in a wide range of application areas, we define the general Repacking problem as the rearrangement of multisets of multisets. We present hardness results for the general case and algorithms for various classes of instances that arise in real-life scenarios. By limiting the total size of items in each multiset, our results can be viewed as an offline approach to Bin Packing, in which each bin is represented as a multiset. In addition to providing the first results on reconfiguration of multisets, our contributions open up several research avenues: the interplay between reconfiguration and online algorithms and parallel algorithms; the use of the tools of linear programming in reconfiguration; and, in the longer term, a focus on extra resources in reconfiguration.

cs.DS↗

arXiv2023

Fast Deterministic Rendezvous in Labeled Lines

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.

cs.DS↗

arXiv2023

Cops and Robbers on 1-Planar Graphs

Cops and Robbers is a well-studied pursuit-evasion game in which a set of cops seeks to catch a robber in a graph G, where cops and robber move along edges of G. The cop number of G is the minimum number of cops that is sufficient to catch the robber. Every planar graph has cop number at most three, and there are planar graphs for which three cops are necessary [Aigner and Fromme, DAM 1984]. We study the problem for beyond-planar graphs, that is, graphs that can be drawn in the plane with few crossings. In particular, we focus on 1-planar graphs, that is, graphs that can be drawn in the plane with at most one crossing per edge. In contrast to planar graphs, we show that some 1-planar graphs have unbounded cop number. Meanwhile, for maximal 1-planar graphs, we prove that three cops are always sufficient and sometimes necessary. In addition, we characterize outer 1-planar graphs with respect to their cop number.

math.CO↗

arXiv2021

Labeling Schemes for Deterministic Radio Multi-Broadcast

We consider the multi-broadcast problem in arbitrary connected radio networks consisting of $n$ nodes. There are $k$ designated source nodes for some fixed $k \in \{1,\ldots,n\}$, and each source node has a distinct piece of information that it wants to share with all nodes in the network. We set out to determine the shortest possible labels so that multi-broadcast can be solved deterministically in the labeled radio network by some universal deterministic distributed algorithm.

cs.DC↗

arXiv2020

Four Shades of Deterministic Leader Election in Anonymous Networks

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.

cs.DC↗

arXiv2020

Fast Byzantine Gathering with Visibility in Graphs

We consider the gathering task by a team of $m$ synchronous mobile robots in a graph of $n$ nodes. Each robot has an identifier (ID) and runs its own deterministic algorithm, i.e., there is no centralized coordinator. We consider a particularly challenging scenario: there are $f$ Byzantine robots in the team that can behave arbitrarily, and even have the ability to change their IDs to any value at any time. There is no way to distinguish these robots from non-faulty robots, other than perhaps observing strange or unexpected behaviour. The goal of the gathering task is to eventually have all non-faulty robots located at the same node in the same round. It is known that no algorithm can solve this task unless there at least $f+1$ non-faulty robots in the team. In this paper, we design an algorithm that runs in polynomial time with respect to $n$ and $m$ that matches this bound, i.e., it works in a team that has exactly $f+1$ non-faulty robots. In our model, we have equipped the robots with sensors that enable each robot to see the subgraph (including robots) within some distance $H$ of its current node. We prove that the gathering task is solvable if this visibility range $H$ is at least the radius of the graph, and not solvable if $H$ is any fixed constant.

cs.DC↗

arXiv2020

Deterministic Leader Election in Anonymous Radio Networks

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σ)$, where $n$ is the number of nodes and $σ$ 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.

cs.DC↗

arXiv2019

Burning Two Worlds: Algorithms for Burning Dense and Tree-like Graphs

Graph burning is a simple model for the spread of social influence in networks. The objective is to measure how quickly a fire (e.g., a piece of fake news) can be spread in a network. The burning process takes place in discrete rounds. In each round, a new fire breaks out at a selected vertex and burns it. Meanwhile, the old fires extend to their neighbours and burn them. A burning schedule selects where the new fire breaks out in each round, and the burning problem asks for a schedule that burns all vertices in a minimum number of rounds, termed the burning number of the graph. The burning problem is known to be NP-hard even when the graph is a tree or a disjoint set of paths. For connected graphs, it has been conjectured that burning takes at most $\lceil \sqrt{n} \rceil$ rounds. We approach the algorithmic study of graph burning from two directions. First, we consider graphs with minimum degree $δ$. We present an algorithm that burns any graph of size $n$ in at most $\sqrt{\frac{24n}{δ+1}}$ rounds. In particular, for dense graphs with $δ\in Θ(n)$, all vertices are burned in a constant number of rounds. More interestingly, even when $δ$ is a constant that is independent of the graph size, our algorithm answers the graph-burning conjecture in the affirmative by burning the graph in at most $\lceil \sqrt{n} \rceil$ rounds. Next, we consider burning graphs with bounded path-length or tree-length. These include many graph families including connected interval graphs and connected chordal graphs. We show that any graph with path-length $pl$ and diameter $d$ can be burned in $\lceil \sqrt{d-1} \rceil + pl$ rounds. Our algorithm ensures an approximation ratio of $1+o(1)$ for graphs of bounded path-length. We introduce another algorithm that achieves an approximation ratio of $2+o(1)$ for burning graphs of bounded tree-length.

math.CO↗

arXiv2019

Constant-Length Labeling Schemes for Deterministic Radio Broadcast

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 Δ)$-bit labels, where $Δ$ 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.

cs.DC↗

arXiv2019

With Great Speed Come Small Buffers: Space-Bandwidth Tradeoffs for Routing

We consider the Adversarial Queuing Theory (AQT) model, where packet arrivals are subject to a maximum average rate $0\leρ\le1$ and burstiness $σ\ge0$. In this model, we analyze the size of buffers required to avoid overflows in the basic case of a path. Our main results characterize the space required by the average rate and the number of distinct destinations: we show that $O(k d^{1/k})$ space suffice, where $d$ is the number of distinct destinations and $k=\lfloor 1/ρ\rfloor$; and we show that $Ω(\frac 1 k d^{1/k})$ space is necessary. For directed trees, we describe an algorithm whose buffer space requirement is at most $1 + d' + σ$ where $d'$ is the maximum number of destinations on any root-leaf path.

cs.DS↗

arXiv2017

Buffer Size for Routing Limited-Rate Adversarial Traffic

We consider the slight variation of the adversarial queuing theory model, in which an adversary injects packets with routes into the network subject to the following constraint: For any link $e$, the total number of packets injected in any time window $[t,t')$ and whose route contains $e$, is at most $ρ(t'-t)+σ$, where $ρ$ and $σ$ are non-negative parameters. Informally, $ρ$ bounds the long-term rate of injections and $σ$ bounds the "burstiness" of injection: $σ=0$ means that the injection is as smooth as it can be. It is known that greedy scheduling of the packets (under which a link is not idle if there is any packet ready to be sent over it) may result in $Ω(n)$ buffer size even on an $n$-line network and very smooth injections ($σ=0$). In this paper we propose a simple non-greedy scheduling policy and show that, in a tree where all packets are destined at the root, no buffer needs to be larger than $σ+2ρ$ to ensure that no overflows occur, which is optimal in our model. The rule of our algorithm is to forward a packet only if its next buffer is completely empty. The policy is centralized: in a single step, a long "train" of packets may progress together. We show that in some sense central coordination is required, by presenting an injection pattern with $σ=0$ for the $n$-node line that results in $Ω(n)$ packets in a buffer if local control is used, even for the more sophisticated "downhill" algorithm, which forwards a packet only if its next buffer is less occupied than its current one.

cs.DC↗

arXiv2017

Deterministic Distributed Construction of $T$-Dominating Sets in Time $T$

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 Θ(\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=γ\log^* n$ with large constant $γ$, 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=α\log^* n $ for small constant $α$, 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- Θ(T)$ on all graphs.

cs.DC↗

arXiv2015

Global Synchronization and Consensus Using Beeps in a Fault-Prone MAC

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 $0 0$, is called $ε$-$\mathit{safe}$. Our main result is the design and analysis, for any constant $ε>0$, of a deterministic $ε$-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.

cs.DC↗

arXiv2015

Time Versus Cost Tradeoffs for Deterministic Rendezvous in Networks

Two mobile agents, starting from different nodes of a network at possibly different times, have to meet at the same node. This problem is known as $\mathit{rendezvous}$. Agents move in synchronous rounds. Each agent has a distinct integer label from the set $\{1,\dots,L\}$. Two main efficiency measures of rendezvous are its $\mathit{time}$ (the number of rounds until the meeting) and its $\mathit{cost}$ (the total number of edge traversals). We investigate tradeoffs between these two measures. A natural benchmark for both time and cost of rendezvous in a network is the number of edge traversals needed for visiting all nodes of the network, called the exploration time. Hence we express the time and cost of rendezvous as functions of an upper bound $E$ on the time of exploration (where $E$ and a corresponding exploration procedure are known to both agents) and of the size $L$ of the label space. We present two natural rendezvous algorithms. Algorithm $\mathtt{Cheap}$ has cost $O(E)$ (and, in fact, a version of this algorithm for the model where the agents start simultaneously has cost exactly $E$) and time $O(EL)$. Algorithm $\mathtt{Fast}$ has both time and cost $O(E\log L)$. Our main contributions are lower bounds showing that, perhaps surprisingly, these two algorithms capture the tradeoffs between time and cost of rendezvous almost tightly. We show that any deterministic rendezvous algorithm of cost asymptotically $E$ (i.e., of cost $E+o(E)$) must have time $Ω(EL)$. On the other hand, we show that any deterministic rendezvous algorithm with time complexity $O(E\log L)$ must have cost $Ω(E\log L)$.

cs.DC↗

arXiv2015

Time vs. Information Tradeoffs for Leader Election in Anonymous Trees

The leader election task calls for all nodes of a network to agree on a single node. If the nodes of the network are anonymous, the task of leader election is formulated as follows: every node $v$ of the network must output a simple path, 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 aim is to establish tradeoffs between the allocated time $τ$ and the amount of information that has to be given $\textit{a priori}$ to the nodes to enable leader election in time $τ$ in all trees for which leader election in this time is at all possible. Following the framework of $\textit{algorithms with advice}$, this information (a single binary string) is provided to all nodes at the start by an oracle knowing the entire tree. The length of this string is called the $\textit{size of advice}$. For an allocated time $τ$, we give upper and lower bounds on the minimum size of advice sufficient to perform leader election in time $τ$. We consider $n$-node trees of diameter $diam \leq D$. While leader election in time $diam$ can be performed without any advice, for time $diam-1$ we give tight upper and lower bounds of $Θ(\log D)$. For time $diam-2$ we give tight upper and lower bounds of $Θ(\log D)$ for even values of $diam$, and tight upper and lower bounds of $Θ(\log n)$ for odd values of $diam$. For the time interval $[β\cdot diam, diam-3]$ for constant $β>1/2$, we prove an upper bound of $O(\frac{n\log n}{D})$ and a lower bound of $Ω(\frac{n}{D})$, the latter being valid whenever $diam$ is odd or when the time is at most $diam-4$. Finally, for time $α\cdot diam$ for any constant $α<1/2$ (except for the case of very small diameters), we give tight upper and lower bounds of $Θ(n)$.

cs.DC↗

arXiv2015

Tradeoffs Between Cost and Information for Rendezvous and Treasure Hunt

In rendezvous, two agents traverse network edges in synchronous rounds and have to meet at some node. In treasure hunt, a single agent has to find a stationary target situated at an unknown node of the network. We study tradeoffs between the amount of information ($\mathit{advice}$) available $\mathit{a\ priori}$ to the agents and the cost (number of edge traversals) of rendezvous and treasure hunt. Our goal is to find the smallest size of advice which enables the agents to solve these tasks at some cost $C$ in a network with $e$ edges. This size turns out to depend on the initial distance $D$ and on the ratio $\frac{e}{C}$, which is the $\mathit{relative\ cost\ gain}$ due to advice. For arbitrary graphs, we give upper and lower bounds of $O(D\log(D\cdot \frac{e}{C}) +\log\log e)$ and $Ω(D\log \frac{e}{C})$, respectively, on the optimal size of advice. For the class of trees, we give nearly tight upper and lower bounds of $O(D\log \frac{e}{C} + \log\log e)$ and $Ω(D\log \frac{e}{C})$, respectively.

cs.DC↗

arXiv2014

Election vs. Selection: Two Ways of Finding the Largest Node in a Graph

Finding the node with the largest label in a network, modeled as an undirected connected graph, is one of the fundamental problems in distributed computing. This is the way in which $\textit{leader election}$ is usually solved. We consider two distinct tasks in which the largest-labeled node is found deterministically. In $\textit{selection}$, this node must output 1 and all other nodes must output 0. In $\textit{election}$, the other nodes must additionally learn the largest label. Our aim is to compare the difficulty of these two tasks executed under stringent running time constraints. The measure of difficulty is the amount of information that nodes of the network must initially possess in order to solve the given task in an imposed amount of time. Following the standard framework of $\textit{algorithms with advice}$, this information (a single binary string) is provided to all nodes at the start by an oracle knowing the entire graph. The length of this string is called the $\textit{size of advice}$. Consider the class of $n$-node graphs with any diameter $diam \leq D$. If time is larger than $diam$, then both tasks can be solved without advice. For the task of $\textit{election}$, we show that if time is smaller than $diam$, then the optimal size of advice is $Θ(\log n)$, and if time is exactly $diam$, then the optimal size of advice is $Θ(\log D)$. For the task of $\textit{selection}$, the situation changes dramatically, even within the class of rings. Indeed, for the class of rings, we show that, if time is $O(diam^ε)$, for any $ε<1$, then the optimal size of advice is $Θ(\log D)$, and, if time is $Θ(diam)$ (and at most $diam$) then this optimal size is $Θ(\log \log D)$.

cs.DC↗