Given a graph G=(V,E), let S (⊆ V) be a set of vertices. Two vertices are mutually visible if there exists a shortest path in G between them that does not contain any other vertex of S. A set S is a Mutual Visibility Set () if every pair of vertices in S is mutually visible. The concept of s in graphs has attracted significant attention since its introduction, as it provides an important structural property of graphs. However, determining a maximum in general graphs is computationally intractable; the decision problem of whether a graph admits an of size at least k has been shown to be NP-complete. Thus, prior work has focused on finding maximal s or restricting attention to specific graph classes. Cactus graphs form a fundamental low-treewidth class, yet the maximum problem for this class remains open. In this paper, we first determine the size of maximum in cactus graphs, and introduce two self-stabilizing algorithms that construct such sets. The first algorithm uses a single BFS tree and stabilizes in O(D) rounds with O(log n) bits per process on average; the second one uses parallel BFS trees and stabilizes in O(|C_max|+|T_max|) rounds, which we show to be asymptotically tight as a function of these two parameters, even on graphs where |C_max|+|T_max| = o(D).

We study the self-stabilizing leader election (SS-LE) problem in the population protocol model, assuming exact knowledge of the population size n. Burman, Chen, Chen, Doty, Nowak, Severson, and Xu [BCC+21] (PODC) showed that this problem can be solved in O(n) expected time with O(n) states. Recently, Gąsieniec, Grodzicki, and Stachowiak [GGS25] (PODC) proved that n+O(log n) states suffice to achieve O(n log n) time both in expectation and with high probability (w.h.p.). If substantially more states are available, sublinear time can be achieved. The authors of [BCC+21] presented a 2^O(n^ρlog n)-state SS-LE protocol with a parameter ρ: setting ρ= Θ(log n) yields an optimal O(log n) time both in expectation and w.h.p., while ρ= Θ(1) results in O(ρ n^1/(ρ+1)) expected time. Recently, Austin, Berenbrink, Friedetzky, Götte, and Hintze [ABF+25] (PODC) presented a novel SS-LE protocol parameterized by a positive integer ρ with 1 ≤ ρ< n/2 that solves SS-LE in O(n/ρ·log n) time w.h.p. using 2^O(ρ^2log n) states. This paper independently presents yet another time–space tradeoff of SS-LE: for any positive integer ρ with 2 ≤ ρ≤√(n), SS-LE can be achieved within O(n/ρ·) expected time using 2^2ρ^2ρ+ O(log n) states. The proposed protocol uses significantly fewer states than [ABF+25] for any expected stabilization time above Θ(√(n)log n). When ρ= Θ(log n/log^2 log n), the proposed protocol is the first to achieve sublinear time while using only polynomially many states. A limitation of our protocol is that the constraint ρ≤√(n) prevents achieving o(√(n)log n) time, whereas the protocol of [ABF+25] can surpass this bound.

We study deterministic exploration by a single agent in T-interval-connected graphs, a standard model of dynamic networks in which, for every time window of length T, the intersection of the graphs within the window is connected. The agent does not know the window size T, nor the number of nodes n or edges m, and must visit all nodes of the graph. We consider two visibility models, KT_0 and KT_1, depending on whether the agent can observe the identifiers of neighboring nodes. We investigate two fundamental questions: the minimum window size that guarantees exploration, and the optimal exploration time under sufficiently large window size. For both models, we show that a window size T = Ω(m) is necessary. We also present deterministic algorithms whose required window size is O(ε(n,m)· m + n log^2 n), where ε(n,m) = ln n/1 + ln m - ln n. These bounds are tight for a wide range of m, in particular when m = n^1+Θ(1). The same algorithms also yield optimal or near-optimal exploration time: we prove lower bounds of Ω((m - n + 1)n) in the KT_0 model and Ω(m) in the KT_1 model, and show that our algorithms match these bounds up to a polylogarithmic factor, while being fully time-optimal when m = n^1+Θ(1). This yields tight bounds when parameterized solely by n: Θ(n^3) for KT_0 and Θ(n^2) for KT_1.

Recently, Bockenhauer, Frei, Unger, and Wehner (SIROCCO 2023) introduced a novel variant of the graph exploration problem in which a single memoryless agent must visit all nodes of an unknown, undirected, and connected graph before returning to its starting node. Unlike the standard model for mobile agents, edges are not labeled with port numbers. Instead, the agent can color its current node and observe the color of each neighboring node. To move, it specifies a target color and then moves to an adversarially chosen neighbor of that color. They analyzed the minimum number of colors required for successful exploration and proposed an elegant algorithm that enables the agent to explore an arbitrary graph using only eight colors. In this paper, we present a novel graph exploration algorithm that requires only six colors. Furthermore, we prove that five colors are sufficient if we consider only a restricted class of graphs, which we call the f-free graphs, a class that includes every graph with maximum degree at most three and every cactus.

An autonomous mobile robot system consisting of many mobile computational entities (called \emph{robots}) attracts much attention of researchers, and clarifying the relationship between robot capabilities and problem solvability is an emerging issue over the past two decades. Previous work assumes that robots can observe all other robots regardless of their number or distance, as long as there are no visibility restrictions or obstacles. In contrast, we introduce a new perspective in which a robot cannot necessarily observe all other robots. We introduce this concept as a new computational model, named the \emph{defected view model}, where each of $N$ robots observes (or misses) at least $k$ (or at most $m$) robots, and present six variants of the model based on the three rules: (1) selection rule; distance-based or adversarial, (2) inclusion rule; local-exclusive or local-inclusive, and (3) observation type; $k$-observable or $m$-missing.In this paper, we consider the \emph{gathering} problem where all robots gather at a common (non-predetermined) point and investigate solvability of the gathering problem under various defected view models. On the negative side, We present several impossibility results: there is no (deterministic) gathering algorithm in any defected view model when $k \leq \lfloor \frac{N}{3} \rfloor$, any local-inclusive defected view model when $k \leq \lfloor \frac{N}{2} \rfloor-1$, and the adversarial local-inclusive defected view model for any $k$ or $m$. These impossibility results support the assumptions underlying our various models and clarify the fundamental difficulties of the gathering problem in the defected view model. On the positive side, we propose two algorithms to solve the gathering problem in the adversarial local-exclusive defected view model for $N \geq 5$ and $k = N-2$ (which is presented as ($N$-$2$)$^+\AEx$ model in this paper), and the distance-based local-exclusive defected view model for $N=4$ and $k=2$ (\ie $2^+\DEx$ model), respectively.

Consider that there are $k\le n$ agents in a simple, connected, and undirected graph $G=(V,E)$ with $n$ nodes and $m$ edges. The goal of the dispersion problem is to move these $k$ agents to mutually distinct nodes. Agents can communicate only when they are at the same node, and no other communication means, such as whiteboards, are available. We assume that the agents operate synchronously. We consider two scenarios: when all agents are initially located at a single node (rooted setting) and when they are initially distributed over one or more nodes (general setting). Kshemkalyani and Sharma presented a dispersion algorithm for the general setting, which uses $O(m_k)$ time and $\log(k + \Delta)$ bits of memory per agent [OPODIS 2021], where $m_k$ is the maximum number of edges in any induced subgraph of $G$ with $k$ nodes, and $\Delta$ is the maximum degree of $G$. This algorithm is currently the fastest in the literature, as no $o(m_k)$-time algorithm has been discovered, even for the rooted setting. In this paper, we present significantly faster algorithms for both the rooted and the general settings. First, we present an algorithm for the rooted setting that solves the dispersion problem in $O(k\log \min(k,\Delta))=O(k\log k)$ time using $O(\log (k+\Delta))$ bits of memory per agent. Next, we propose an algorithm for the general setting that achieves dispersion in $O(k \log k \cdot \log \min(k,\Delta))=O(k \log^2 k)$ time using $O(\log (k+\Delta))$ bits. Finally, for the rooted setting, we give a time-optimal (i.e.,~$O(k)$-time) algorithm with $O(\Delta+\log k)$ bits of space per agent. All algorithms presented in this paper work only in the synchronous setting, while several algorithms in the literature, including the one given by Kshemkalyani and Sharma at OPODIS 2021, work in the asynchronous setting.

In this paper, we address the problem of uniformly deploying mobile robots in complete bipartite graphs. Specifically, when n robots are positioned arbitrarily at distinct nodes in a complete bipartite graph K-n,K- n, which consists of two n-node sets V-L and V-R, the uniform deployment problem requires the robots to achieve one of the following configurations: (a) each node in V-L is occupied by exactly one robot, with no robots in V-R, or (b) each node in VR is occupied by exactly one robot, with no robots in V-L. In either configuration, the distance between any two robots is 2, ensuring that the robots are uniformly deployed. In this paper, we explore the relationship between the visibility range of robots and the solvability of the uniform deployment problem. First, we characterize solvable and unsolvable initial configurations under the assumption that robots have an infinite visibility range. Next, we demonstrate that visibility range 1 (meaning robots can only observe nodes at a distance of 1 and the robots positioned on them) is insufficient, proving the impossibility of solving the problem under this constraint. Conversely, we show that visibility range Theta(log n) is sufficient by presenting an algorithm that solves the uniform deployment problem in O(1) rounds, starting from any solvable initial configuration. Finally, we briefly introduce an example showing that robots with a constant visibility range (which is 3 in this example) cannot solve the problem in a native way.

This paper addresses the collision detection problem in population protocols. The network consists of state machines called agents. At each time step, exactly one pair of agents is chosen uniformly at random to interact, updating their states. The collision detection problem assumes that each agent starts with an input integer between 1 and n, where n is the number of agents, and requires the agents to determine whether there are any duplicate input values among them. Specifically, the goal is for all agents to output false if all input values are distinct, and true otherwise. This paper presents an algorithm that solves this problem in sublinear parallel time, both with high probability and in expectation, using only a polynomial number of states, thereby answering one of the open questions raised by Burman, Chen, Chen, Doty, Nowak, Severson, and Xu [PODC 2021].

This paper addresses the collision detection problem in population protocols. The network consists of state machines called agents. At each time step, exactly one pair of agents is chosen uniformly at random to have an interaction, changing the states of the two agents. The collision detection problem involves each agent starting with an input integer between 1 and n, where n is the number of agents, and requires those agents to determine whether there are any duplicate input values among all agents. Specifically, the goal is for all agents to output false if all input values are distinct, and true otherwise. In this paper, we present an algorithm that requires a polynomial number of states per agent and solves the collision detection problem with probability one in sub-linear parallel time, both with high probability and in expectation. To the best of our knowledge, this algorithm is the first to solve the collision detection problem using a polynomial number of states within sublinear parallel time, affirmatively answering the question raised by Burman, Chen, Chen, Doty, Nowak, Severson, and Xu [PODC 2021] for the first time.

We investigate crash-tolerant perpetual exploration algorithms by myopic luminous robots on ring networks. Myopic robots mean that they can observe nodes only within a certain fixed distance phi, and luminous robots mean that they have light devices that can emit a color from a set of colors. The goal of perpetual exploration is to ensure that robots, starting from specific initial positions and colors, move in such a way that every node is visited by at least one robot infinitely often. As a main contribution, we clarify the tight necessary and sufficient number of robots to realize perpetual exploration when at most f robots crash. In the fully synchronous model, we prove that f + 2 robots are necessary and sufficient for any phi >= 1. In the semi-synchronous and asynchronous models, we prove that 3f + 3 (resp., 2f + 2) robots are necessary and sufficient if phi = 1 (resp., phi = 2).

We study the Byzantine gathering problem involving k mobile agents with unique identifiers (IDs), f of which are Byzantine. These agents start the execution of a common algorithm from (possibly different) nodes in an n-node network, potentially starting at different times. Once started, the agents operate in synchronous rounds. We focus on weakly Byzantine environments, where Byzantine agents can behave arbitrarily but cannot falsify their IDs. The goal is for all non-Byzantine agents to eventually terminate at a single node simultaneously. In this paper, we first prove two impossibility results: (1) for any number of non-Byzantine agents, no algorithm can solve this problem without global knowledge of the network size or the number of agents, and (2) no self-stabilizing algorithm exists if k <= 2f even with n, k, f, and the length Lambda(g) of the largest ID among IDs of non-Byzantine agents, where the self-stabilizing algorithm enables agents to gather starting from arbitrary (inconsistent) initial states. Next, based on these results, we introduce a perpetual gathering problem and propose a self-stabilizing algorithm for this problem. This problem requires that all non-Byzantine agents always be co-located from a certain time onwards. If the agents know Lambda(g) and upper bounds N, K, F on n, k, f, the proposed algorithm works in O(K . F . Lambda(g) . X(N)) rounds, where X(n) is the time required to visit all nodes in a n-nodes network. Our results indicate that while no algorithm can solve the original self-stabilizing gathering problem for any k and f even with exact global knowledge of the network size and the number of agents, the self-stabilizing perpetual gathering problem can always be solved with just upper bounds on this knowledge.

The computational power of autonomous mobile robots under the Look-Compute-Move (LCM) model has been widely studied through an extensive hierarchy of robot models defined by the presence of memory, communication, and synchrony assumptions. While the general n-robot landscape has been largely established, the exact structure for two robots has remained unresolved. This paper presents the first complete characterization of the computational power of two autonomous robots across all major models, namely OBLOT, FSTA, FCOM, and LUMI, under the full spectrum of schedulers (FSYNCH, SSYNCH, ASYNCH, and their atomic variants). Our results reveal a landscape that fundamentally differs from the general case. Most notably, we prove that FSTA^F and LUMI^F coincide under full synchrony, a surprising collapse indicating that perfect synchrony can substitute both memory and communication when only two robots exist. We also show that FSTA and FCOM are orthogonal: there exists a problem solvable in the weakest communication model but impossible even in the strongest finite-state model, completing the bidirectional incomparability. All equivalence and separation results are derived through a novel simulation-free method, providing a unified and constructive view of the two-robot hierarchy. This yields the first complete and exact computational landscape for two robots, highlighting the intrinsic challenges of coordination at the minimal scale.

In this paper, we give two self-stabilizing algorithms that solve graph exploration by a single (mobile) agent. The proposed algorithms are self-stabilizing: the agent running each of the algorithms visits all nodes starting from any initial configuration where the state of the agent and the states of all nodes are arbitrary and the agent is located at an arbitrary node. We evaluate algorithms with two metrics, the cover time, that is the number of moves required to visit all nodes, and the amount of space to store the state of the agent and the states of the nodes. The first algorithm is a randomized one. The cover time of this algorithm is optimal (\ie $O(m)$) in expectation and it uses $O(\log n)$ bits for both the agent and each node, where $n$ and $m$ are the number of agents and the number of edges in a given graph, respectively. The second algorithm is deterministic. The cover time is $O(m + nD)$, where $D$ is the diameter of the graph. It uses $O(\log n)$ bits for the agent-memory and $O(\delta + \log n)$ bits for the memory of each node with degree $\delta$. We require the knowledge of an upper bound on $n$ (resp. $D$) for the first (resp.~the second) algorithm. However, this is a weak assumption from a practical point of view because the knowledge of any value $\ge n$ (resp.~$\ge D$) in $O(poly(n))$ is sufficient to obtain the above time and space complexity.

Given a graph G=(V,E), a 2-minimal dominating set (2-MDS) of G is a minimal dominating set D⊆V such that D∖{pi,pj}∪{pz} is not a dominating set for any nodes pi,pj∈D (pi≠pj) and pz∉D. We propose two silent self-stabilizing asynchronous distributed algorithms to find a 2-MDS. In both algorithms, we assume the weakly fair distributed daemon and that the processes have unique identifiers. The first one is for the general networks. The time complexity is O(nH) rounds, and the space complexity is O(Δlog⁡n) bits per process, where n is the number of processes, H is the diameter of the network, and Δ is the maximum degree. The second one is for the networks of girth at least 7. The girth is the length of the shortest cycles in the network. The time complexity is O(nH) rounds, and the space complexity is O(log⁡n) bits per process.

We consider the population protocol model where indistinguishable state machines, referred to as agents, communicate in pairs. The communication graph specifies potential interactions (i.e., communication) between agent pairs. This paper addresses the complete graph identification problem, requiring agents to determine if their communication graph is a clique or not. We evaluate various settings based on: (i) the fairness preserved by the adversarial scheduler-either global fairness or weak fairness, and (ii) the knowledge provided to agents beforehand-either the exact population size n, a common upper bound P on n, or no prior information. Positively, we show that O(n(2)) states per agent suffice to solve the complete graph identification problem under global fairness without prior knowledge. With prior knowledge of n, agents can solve the problem using only O(n) states under weak fairness.

In this paper, we present two self-stabilizing algorithms that enable a single (mobile) agent to explore graphs. The agent visits all nodes starting from any configuration, i.e., regardless of the initial state of the agent, the initial states of all nodes, and the initial location of the agent. We evaluate the algorithms using two metrics: cover time, which is the number of moves required to visit all nodes, and memory usage, which includes the storage needed for the state of the agent and the state of each node. The first algorithm is randomized. Given an integer c = Omega(n), the cover time of this algorithm is optimal, i.e., O(m) in expectation, and the memory requirements for the agent and each node v are O(log c) and O(log(c + delta(v))) bits, respectively, where n and m are the numbers of nodes and edges, respectively, and delta(v) is the degree of v. The second algorithm is deterministic. It requires an input integer k >= max( D, delta(max)), where D and delta(max) are the diameter and the maximum degree of the graph, respectively. The cover time of this algorithm is O( m + nD), and it uses O(log k) bits both for agent memory and each node.

Research on distributed computing by a team of identical mobile computational entities, called robots, operating in a Euclidean space in $\mathit{Look}$-$\mathit{Compute}$-$\mathit{Move}$ ($\mathit{LCM}$) cycles, has recently focused on better understanding how the computational power of robots depends on the interplay between their internal capabilities (i.e., persistent memory, communication), captured by the four standard computational models (OBLOT, LUMI, FSTA, and FCOM) and the conditions imposed by the external environment, controlling the activation of the robots and their synchronization of their activities, perceived and modeled as an adversarial scheduler. We consider a set of adversarial asynchronous schedulers ranging from the classical semi-synchronous (SSYNCH) and fully asynchronous (ASYNCH) settings, including schedulers (emerging when studying the atomicity of the combination of operations in the $\mathit{LCM}$ cycles) whose adversarial power is in between those two. We ask the question: what is the computational relationship between a model $M_1$ under adversarial scheduler $K_1$ ($M_1(K_1)$) and a model $M_2$ under scheduler $K_2$ ($M_2(K_2)$)? For example, are the robots in $M_1(K_1)$ more powerful (i.e., they can solve more problems) than those in $M_2(K_2)$? We answer all these questions by providing, through cross-model analysis, a complete characterization of the computational relationship between the power of the four models of robots under the considered asynchronous schedulers. In this process, we also provide qualified answers to several open questions, including the outstanding one on the proper dominance of SSYNCH over ASYNCH in the case of unrestricted visibility.

The maximal independent set (MIS) problem is one of the most fundamental problems in the field of distributed computing. This paper focuses on the MIS problem with unreliable communication between processes in the system. We propose a relaxed notion of MIS, named almost MIS (ALMIS), and show that the loosely-stabilizing algorithm proposed in our previous work can achieve exponentially long holding time with logarithmic convergence time and space complexity regarding ALMIS, which cannot be achieved at the same time regarding MIS in our previous work.

We propose a self-stabilizing leader election (SS-LE) protocol on ring networks in the population protocol model. Given a rough knowledge ψ = ⌈log n⌉ + O(1) on the population size n, the proposed protocol lets the population reach a safe configuration within O(n2 log n) steps with high probability starting from any configuration. Thereafter, the population keeps the unique leader forever. Since no protocol solves SS-LE in o(n2) steps with high probability, the convergence time is near-optimal: the gap is only an O(log n) multiplicative factor. This protocol uses only polylog(n) states. There exist two state-of-the-art algorithms in current literature that solve SS-LE on ring networks. The first algorithm uses a polynomial number of states and solves SS-LE in O(n2) steps, whereas the second algorithm requires exponential time but it uses only a constant number of states. Our proposed algorithm provides an excellent middle ground between these two.

A self-stabilizing distributed algorithm is guaranteed eventually to reach and stay at a legitimate configuration regardless of the initial configuration of a distributed system. In this paper, we propose the generalized dominating set problem, which is a generalization of the dominating set and k-redundant dominating set problems. In the generalized dominating set we propose in this paper, each node P-i is given its set of domination wish sets, and a generalized dominating set is a set of nodes such that each node is contained in the set or has a wish set in which all its members are in the set. We propose a self-stabilizing distributed algorithm for finding a minimal generalized dominating set in an arbitrary network under the unfair distributed daemon. The proposed algorithm converges in O(n(3)m) steps and O(n) rounds, where n (resp., m) is the number of nodes (resp., edges). Furthermore, it has the safe convergence property with safe convergence time in O(1) rounds. The space complexity of the proposed algorithm is O(Delta log n) bits per node, where Delta is the maximum degree of nodes.