A Distance Realization problem asks, given an n× n matrix D of nonnegative integers, to find an n-vertex graph G and an integral weight function on the edges realizing D, i.e., such that dist_G(i,j) , the weighted distance from i to j, equals D_i,j for every i and j, or decide that no such realizing graph exists. This paper introduces and studies the Minimum Deviation Distance Realization optimization problem, where given a matrix D, the goal is to find a weighted graph (G, w) that realizes D as closely as possible, i.e., such that the deviation ϕ (D,G) between D and the matrix of pairwise distances in G is minimized. We focus on four different types of deviation functions ϕ : the maximum difference over all matrix entries, ϕ _max , the sum of differences of all matrix entries, ϕ _sum , the number of matrix entries exhibiting a mismatch, ϕ _num , and the multiplicative difference over all matrix entries, ϕ _mult . For each deviation function ϕ , we consider the following variants of minimum deviation distance realization problems: (i) The deviation of the realizing graph (G, w) from the matrix D is allowed to be only upwards, only downwards, or in both directions; and (ii) The entries of D may specify exact values or ranges of permissible values. For each problem in this wide spectrum of variants, we either present a polynomial-time algorithm or show hardness and give a polynomial-time approximation algorithm.
In this paper, we consider the uniform deployment problem of myopic luminous robots in rings, requiring them to spread uniformly in the ring. Robots are myopic if they have a common limited visibility range and robots are luminous if hey are equipped with a light device that can emit a color from a finite set. The past related research considered uniform deployment for myopic and oblivious robots. Here, robots are oblivious if they have no memory and cannot memorize the history of past actions. In this case, it is shown that quiescent uniform deployment, requiring that robots stop moving after they reached a uniformly deployed configuration but they are allowed to resume moving when observing some configuration changes, is impossible. In this paper, we consider the feasibility of the uniform deployment problem by introducing lights. Let n be the number of nodes and k be the number of robots. First, we show that, even if robots behave fully synchronously and have an infinite number of light colors, they cannot achieve uniform deployment when either of the followings holds: (i) they do not have a common sense of direction, (ii) the visibility range is less than ⌊ n/k⌋ , or (iii) the problem requires explicit termination detection. Next, for robots that behave semi-synchronously and have a common sense of direction and visibility range at least ⌊ n/k⌋ , we propose an algorithm to solve the quiescent uniform deployment problem, by allowing robots to be luminous and have a constant number of light colors. This is a striking difference compared to the past result for oblivious robots.
Asynchronous executions of robotic swarm algorithms are challenging to reason about because they allow robots to compute their next destination based on observations that may be outdated. To add formal guarantees in such a context where subtle mistakes lead to dramatic errors, we propose a formalization for the Rocq prover of asynchronous executions in the Look-Compute-Move model, as an extension to the Pactole formal library, and we illustrate how algorithms can be proved correct in this setting. Intuition makes it easy to overlook crucial details that formal methods would request when used, leading to published algorithms which can be, at best, seriously underspecified. This is particularly the case when problems seem easy, as with solving Gathering using Weber points. Attempts at formalization show that going blindly (or for that matter cautiously) towards the Weber point, a strategy often claimed to solve Gathering, is indeed incorrect under certain assumptions. We propose in this work an original and formally certified algorithm for Gathering in async. As this algorithm uses Weber points, we also provide a comprehensive formalization for Weber points and their properties. Interestingly, the use of our formalization for asynchronous executions does not come with an explosion of the proof size, which stays at a very reasonable level.
Self-stabilization is a versatile methodology for designing fault-tolerant distributed algorithms for transient faults. Many self-stabilizing distributed algorithms adopt the state-reading model (or locally shared memory model), in which each process can read the local variables of its direct neighbor processes, in addition to its own local variables. In this paper, we propose a new model, named the R( d_r )W( d_w ) model. In this model, each process can read the local variables of processes within a distance of d_r ( ≥ 1 ) and write the local variables of processes within a distance of d_w ( ≥ 0 ). We present several self-stabilizing distributed algorithms in the proposed model. Furthermore, we present a transformer that directly simulates the R(1)W(1) model in the synchronous message passing model.
Epistemic Logic has been shown to provide a useful abstract framework for reasoning about fault tolerant distributed algorithms. In particular, it provides a way to derive protocols that are optimal in the way that they use information. An example of this is results using notions of common knowledge to establish the optimality of consensus protocols, under a variety of failure models. Proofs in this area have, to date, been performed manually, and have consequently been error-prone. This paper addresses this weakness using formal methods. A formalization in the theorem prover Isabelle is developed of a general framework for epistemic reasoning about distributed algorithms, that can cover multiple failure models and concrete protocols. As an application of the framework, it is formally proved that for all patterns of information exchange among the agents, the implementation of a knowledge based program is optimal among protocols for simultaneous consensus that use that pattern of information exchange. Furthermore, the FloodSet protocol has been modelled in our framework and we verified knowledge properties about the protocol.
In this paper, we study the problem of exploring an unknown grid graph by multiple searchers. All searchers start from a single vertex, and each vertex in the graph must be visited by at least one searcher. The objective is to minimize the time required until every vertex has been visited and all searchers have returned to the starting vertex. We assume that the searchers can communicate with each other by reading and writing information at any vertex they visit. In prior work, Ortolf and Schindelhauer proposed an online exploration algorithm for an n × n grid graph with disjoint rectangular obstacles. They showed that its competitive ratio is 𝒪(log ^2 n) . We propose an online algorithm for arbitrary grid graphs that achieves a competitive ratio of (k / log k + min (c, k)) , where k is the number of searchers and c is the number of hole corners in the grid graph. Our result improves on that of Ortolf and Schindelhauer when c and k are relatively small compared to the graph size. In particular, when c is a constant, our algorithm achieves a constant competitive ratio that is independent of the graph size.
The problem of generating a uniformly, or almost uniformly, random proper q-coloring of a given graph in polynomial time is an interesting and challenging sampling problem that has been widely studied in the sequential setting. Recently there has been interest in distributed algorithms for the problem, where the goal is to get parallel speedup, so that the running time is polylogarithmic in n. Existing approaches converge in logarithmic time but with a small increase in the number of colors required, which, for most of the sequential results, is already more than the maximum degree of the graph. We study the problem of distributed sampling of q-colorings in the special case where the graph is a tree. Regardless of the maximum degree of the tree, which may be as large as (n) , we allow the number of available colors, q, to be as small as three. We present a distributed CONGEST algorithm that produces an almost uniform proper q-coloring of the tree. Additionally, if the tree is rooted, a modification of our algorithm produces a uniformly random proper q-coloring. Both algorithms succeed with probability 1, and have a running time that is O(log ^2 n) with high probability.
We introduce the Byzantine Approximate Agreement Cross-chain Task in the smart contract model, a recently proposed framework for capturing computation in blockchain-based systems. In this model, a set of m parties, of which up to a minority may be Byzantine, interact via n trusted smart contracts deployed on multiple independent ledgers (blockchains). We present two protocols that solve the Byzantine Approximate Agreement Cross-chain Task and prove their correctness. Both protocols are optimal with respect to Byzantine resilience - tolerating a minority of Byzantine parties - and time complexity, completing in two rounds in synchronous executions. We further analyze their bit complexity within the smart contract model. The first protocol requires 𝒪(k) bits of local memory per party, where k denotes the number of bits needed to encode the proposed values, and achieves a total message bit complexity of 𝒪(n· m· k) . The second protocol reduces the local memory usage at each party to 𝒪(1) bits, at the cost of increasing the total message bit complexity to 𝒪(n^2· m· k) .
The mutual visibility problem needs a set of N autonomous mobile robots to reach a configuration on the 2D plane where every pair of robots can see each other, i.e., no robot lies on the line segment connecting any two others. We study the fault-tolerant mutual visibility problem under the barebones luminous model (each robot has a light that can flash a color from a finite prefixed color set), where the objective is to reach a configuration in which every pair of non-faulty robots are mutually visible, despite the presence of at most f (< N) robots prone to mobility failures. Mobility fault is a fault model in the existing literature that makes a robot immobile. However, the faulty robot executes the algorithms and its light remains functional. Unlike existing studies that assume coordinate agreement or partial synchrony, we consider the asynchronous ( 𝒜𝒮𝒴𝒩𝒞 ) setting and disoriented robots (do not share a coordinate system or orientation), with both N and f unknown. We propose a deterministic O(N)-time algorithm in terms of epochs that utilises O(1) colors and ensures collision-free movements, where epoch is the smallest time interval in which every robot completes at least one full LCM cycle. In addition, our algorithm solves a useful subproblem of detecting the global innermost layer under asynchronous setting only with the help of local view of the robots. The layer structure of any robot configuration represented as a sequence of disjoint convex polygons, that offers a way to organize progress even without shared coordinate system.
We consider the classical cow-path/treasure-hunt problem on a discrete infinite line, being solved by a deterministic finite state agent with s states and k pebbles. We show asymptotically optimal solutions for small values of k, as well as an efficient algorithm for general k. For non-constant number of pebbles we show that O(loglog n) pebbles are sufficient to find the treasure located at distance n within O(nlog n) steps. Having more pebbles does not help, as we show a lower bound (nlog n) steps even with unlimited number of pebbles. Randomization can break this bound, as we show that a randomized agent can solve the problem with expected O(nloglog n) steps using O(loglog n) pebbles. Along the way, we introduce two subproblems that might be of independent interest, and use the solutions to those as building blocks for our solutions to the treasure-hunt problem. In fact, the core of the paper is a result on how to efficiently travel with a counter implemented by pebbles, so that the amortized cost of the travel is significantly smaller than the traveled distance times the counter size, despite always having the counter nearby for incrementing in each travel step.
We consider the problem of computing compact routing tables for weighted, undirected graphs. Our main contribution is a unified distributed framework for constructing compact routing schemes for graphs that admit a small collection of short paths that nearly separate the graph. The framework is fully distributed and relies only on two generic primitives: single-source approximate distance computation and minor-aggregation. Both are efficiently implementable in CONGEST and the novel HYBRID model. In particular, they require Õ(HD) rounds in the CONGEST model where HD is the graph’s hop-diameter and Õ(1) rounds in HYBRID. Specifically, we apply our framework to four different important graph families. In all four cases, we assume that the graphs are weighted, undirected and have polynomially bounded edge weights.
We consider three classification systems for distributed decision tasks: With unbounded computation and certificates, defined by Balliu, D’Angelo, Fraigniaud, and Olivetti [JCSS’18], and with (two flavors of) polynomially bounded local computation and certificates, defined in recent works by Aldema Tshuva and Oshman [OPODIS’23], and by Reiter [PODC’24]. The latter two differ in the way they evaluate the polynomial bounds: the former considers polynomials with respect to the size of the graph, while the latter refers to being polynomial in the size of each node’s local neighborhood. We start by revisiting decision without certificates. For this scenario, we show that the latter two definitions coincide: roughly, a node cannot know the graph size, and thus can only use a running time dependent on its neighborhood. We then consider decision with certificates. With existential certificates ( _1 -type classes), a larger running time defines strictly larger classes of languages: when it grows from being polynomial in each node’s view, through polynomial in the graph’s size, and to unbounded, the derived classes strictly contain each other. With universal certificates ( _1 -type classes), on the other hand, we prove a surprising incomparability result: having running time bounded by the graph size sometimes allows us to decide languages undecidable even with unbounded certificates. We complement these results with other containment and separation results, which together portray a surprisingly complex lattice of strict containment relations between the classes at the base of the three classification systems.
We study the classical Election problem in anonymous networks, where solutions can rely on the use of random bits, which may be either shared or unshared among nodes. We provide a complete characterization of the conditions under which a randomized Election algorithm exists, for arbitrary structural knowledge. Our analysis considers both Las Vegas and Monte Carlo randomized algorithms, under the assumptions of shared and unshared randomness. In our setting, random sources are considered shared if the output bits are identical across specific subsets of nodes. The algorithms and impossibility proofs are extensions of those of Chalopin et al. (2012) for the deterministic setting. Our results are a complete generalization of those from Fraigniaud et al. (2024). Moreover, as applications, we consider many specific knowledge: no knowledge, a bound on the size, a bound on the number of nodes sharing a source, the size, or the full topology of the network. For each of them, we show how the general characterizations apply, showing they actually correspond to classes of structural knowledge. We also describe also how randomized Election algorithms from the literature fits in this landscape. We therefore provide a comprehensive picture illustrating how knowledge influences the computability of the Election problem in arbitrary anonymous graphs with shared randomness.
A balanced separator of a graph G is a set of vertices whose removal disconnects the graph into connected components that are a constant factor smaller than G. Lipton and Tarjan [FOCS’77] famously proved that every planar graph admits a balanced separator of size O(√(n)) , as well as a balanced separator of size O(D) that is a simple path (where D is the graph’s diameter). In the centralized setting, these separators can both be found in linear O(n) time. In the distributed setting, since the diameter D is a trivial universal lower bound for the number of rounds required to solve many optimization problems, separators of size O(D) are preferable over those of size O(√(n)) . It was not until [Ghaffari, Parter DISC’17] that an algorithm was devised to compute such an O(D)-size separator distributively in Õ(D) (The Õ(· ) notation is used to omit polylog n factors.) rounds, by adapting the Lipton-Tarjan algorithm to the distributed model. Since then, this algorithm was used in several distributed algorithms for planar graphs, e.g., [Ghaffari, Parter DISC’17], [Li, Parter STOC’19], [Abd-Elhaleem, Dory, Parter and Weimann PODC’25]. However, the algorithm is randomized, deeming the algorithms that use it to be randomized as well. Obtaining a deterministic algorithm remained an interesting open question until very recently, when a (complex) deterministic separator algorithm was given by [Jauregui, Montealegre and Rapaport PODC’25]. In this paper, we present a much simpler deterministic separator algorithm with the same (near-optimal) Õ(D) -round complexity. While previous works devise either complicated or random ways of transferring weights from vertices of G to faces of G, we show that a straightforward way also works: Each vertex simply transfers its weight to one arbitrary face it belongs to. That’s it! We note that a deterministic separator algorithm directly derandomizes the state-of-the-art distributed algorithms for classical problems on planar graphs such as single-source shortest-paths, maximum-flow, directed global min-cut, and reachability.
The online bisection problem requires maintaining a dynamic partition of n nodes into two equal-sized clusters. Requests arrive sequentially as node pairs. If the nodes lie in different clusters, the algorithm pays unit cost. After each request, the algorithm may migrate nodes between clusters at unit cost per node. This problem models datacenter resource allocation where virtual machines must be assigned to servers, balancing communication costs against migration overhead. We study the variant where requests are restricted to edges of a ring network, an abstraction of ring-allreduce patterns in distributed machine learning. Despite this restriction, the problem remains challenging with an (n) deterministic lower bound. We present a randomized algorithm achieving O(ε ^-3·log ^2 n) competitive ratio using resource augmentation that allows clusters of size at most (3/4 + ε ) · n . Our approach formulates the problem as a metrical task system with a restricted state space. By limiting the number of cut-edges (i.e., ring edges between clusters) to at most 2k, where k = Θ (1/ε ) , we reduce the state space from exponential to polynomial (i.e., n^O(k) ). The key technical contribution is proving that this restriction increases cost by only a factor of O(k). Our algorithm follows by applying the randomized MTS solution of Bubeck et al. [SODA 2019]. The best result to date for bisection with ring demands is the O(n ·log n) -competitive deterministic online algorithm of Rajaraman and Wasim [ESA 2024] for the general setting. While prior work for ring-demands by Räcke et al. [SPAA 2023] achieved O(log ^3 n) for multiple clusters, their approach employs a resource augmentation factor of 2+ε , making it inapplicable to bisection.
We revisit the relationship between two fundamental models of distributed computation: the asynchronous message-passing model with up to f crash failures ( AMP_f ) and the Heard-Of model with up to f message omissions ( HO_f ). We show that for n > 2f , the two models are equivalent with respect to the solvability of colorless tasks, and that for colored tasks the equivalence holds only when f = 1 (and n > 2 ). The separation for larger f arises from the presence of silenced processes in HO_f , which may lead to incompatible decisions. The results are proved through bidirectional simulations between AMP_f and HO_f , using an intermediate model that captures this notion of silencing. The results extend to randomized protocols against a non-adaptive adversary, indicating that the expressive limits of canonical rounds are structural rather than probabilistic. Together, these results help to delineate where round-based abstractions capture asynchronous computation, and where they do not.
Graph colouring is a fundamental problem for networks, serving as a tool for avoiding conflicts via symmetry breaking, for example, avoiding multiple computer processes simultaneously updating the same resource. This paper considers a generalisation of this problem to temporal graphs, i.e., to graphs whose structure changes according to an ordered sequence of edge sets. In the simultaneous resource updating problem on temporal graphs, the resources which can be accessed will change, however, the necessity of symmetry breaking to avoid conflicts remains. In this paper, we focus on the problem of maintaining proper colourings on temporal graphs in general, with a particular focus on bipartite colourings. Our aim is to minimise the total number of times that the vertices change colour, or, in the form of a decision problem, whether we can maintain a proper colouring by allowing not more colour changes than some given budget. On the negative side, we show that, despite bipartite colouring being easy on static graphs, the problem of maintaining such a colouring on graphs that are bipartite in each snapshot is NP-Hard to even approximate within any constant factor unless the Unique Games Conjecture fails. On the positive side, we provide an exact algorithm for a temporal graph with n vertices, a lifetime T and at most k components in any given snapshot in O(T | E | 2^k + n T 2^2k) time, and an O(√(log(nT)))-factor approximation algorithm running in Õ((nT)^3) time. Our results contribute to the structural complexity of networks that change with time with respect to a fundamental computational problem.
We study the problem of computing a Maximal Independent Set (MIS) in distributed networks, where each node is a rational agent that receives a payoff depending on whether it is included in the MIS. In classical distributed computing, it is typically assumed that nodes follow the prescribed algorithm faithfully. However, this assumption fails when nodes are rational agents whose utilities depend on the algorithm’s output. In such cases, nodes may deviate from the algorithm if it increases their expected payoff. Classical solutions for MIS assume that nodes generate random bits honestly or rely on unique identifiers to break symmetry. However, in rational settings, nodes may manipulate randomness to gain a strategic advantage, and relying solely on unique identifiers can result in unfairness, where some nodes have zero probability of joining the MIS and thus no incentive to participate. To address these challenges, we propose two algorithms that work under a utility model, where agents are incentivized to compute locally correct solutions while also exhibiting preferences among these solutions. In these algorithms, randomness is generated through interactions between neighboring nodes, which can be viewed as simple games, where no single node can unilaterally change the outcome. This approach allows us to break symmetry while being compatible with rational behavior. For both algorithms, we show that regardless of the execution history that has occurred, no agent can improve its expected utility by deviating from that stage, provided no other agents deviate. This is a much stronger guarantee compared to Trembling Hand Perfect Equilibrium, which is typically used in such scenarios. Both algorithms guarantee that when all the nodes follow the algorithm, every node has a positive probability of joining the MIS, and that the final output is a correct Maximal Independent Set. Finally, for both algorithms, we can guarantee termination in O(log n) rounds with high probability under mild additional assumptions, where n is the number of nodes in the network.
Local certification is a mechanism for certifying to the nodes of a network that a certain property holds. In this framework, nodes are assigned labels, called certificates, which are supposed to prove that the property holds. The nodes then communicate with their neighbors to verify the correctness of these certificates. Certifying that there is a unique leader in a network is one of classical problems in this setting. It is well-known that this can be done using certificates that encode node identifiers and distances in the graph. These require O(log n) and O(log D) bits respectively, where n is the number of nodes and D is the diameter. A matching lower bound is known in cycle graphs (where n and D are equal up to multiplicative constants). A recent line of work has shown that network structure greatly influences local certification. For example, certifying that a network does not contain triangles takes (n) bits in general graphs, but only O(log n) bits in graphs of bounded treewidth. This observation raises the question: Is it possible to achieve sublogarithmic leader certification in graph classes that do not contain cycle graphs? And since in that case we cannot write identifiers in a certificate, do we actually need identifiers at all in such topologies? We prove the following results. We also discuss the types of properties to which these results apply beyond leader election, as well as the impact of the identifier range.
We consider routing in reconfigurable networks, which is also known as coflow scheduling in the literature. The algorithmic literature generally (perhaps implicitly) assumes that the amount of data to be transferred is large. Thus the standard way to model a collection of requested data transfers is by an integer demand matrix D, where the entry in row i and column j of D is an integer representing the amount of information that the application wants to send from machine/node i to machine/node j. A feasible coflow schedule is then a sequence of matchings, which represent the sequence of data transfers that covers D. In this work, we investigate coflow scheduling when the size of some of the requested data transfers may be small relative to the amount of data that can be transferred in one round. In particular, we investigate algorithms that employ fractional matchings and/or that employ indirect routing, and compare the relative utility of these options. We design algorithms that perform much better for small demands than the algorithms in the literature that were designed for large data transfers.
