Self-stabilizing Graph Exploration by a Single Agent

TL;DR

This work addresses self-stabilizing graph exploration by a single mobile agent in port-labeled, anonymous graphs. It introduces two algorithms: a randomized method ${\mathcal R}_{c}$ that uses color-based repeated depth-first traversals to adapt from any initial configuration, achieving a cover time of $O\left(m \cdot \min\left(D, \frac{n}{c}+1, \frac{D}{c}+\log n\right)\right)$ in expectation with $O(\log c)$ agent memory and $O\big(\log (\delta_v+c)\big)$ per node, and a deterministic method ${\mathcal D}_{k}$ that builds a distributed BFS-like tree to guarantee exploration in $O(m+nD)$ steps with $O(\log k)$ memory for both agent and whiteboards, given $k \ge \max(D,\delta_{\max})$. A lower bound $\Omega(m)$ is established, and the paper highlights open questions, including whether a deterministic $O(m)$-time self-stabilizing exploration is achievable and how multiple agents might reduce the cover time. The results advance understanding of time-space trade-offs in self-stabilizing, single-agent graph exploration and provide practical strategies for robust exploration under transient faults.

Abstract

In this paper, we present two self-stabilizing algorithms that enable a single (mobile) agent to explore graphs. Starting from any initial configuration, \ie regardless of the initial states of the agent and all nodes, as well as the initial location of the agent, the algorithms ensure the agent visits all nodes. We evaluate the algorithms based on two metrics: the \emph{cover time}, defined as the number of moves required to visit all nodes, and \emph{memory usage}, defined as the storage needed for maintaining the states of the agent and each node. The first algorithm is randomized. Given an integer $c = Ω(n)$, its cover time is optimal, \ie $O(m)$ in expectation, and its memory requirements are $O(\log c)$ bits for the agent and $O(\log (c+δ_v))$ bits for each node $v$, where $n$ and $m$ are the numbers of nodes and edges, respectively, and $δ_v$ is the degree of node $v$. For general $c \ge 2$, its cover time is $O( m \cdot \min(D, \frac{n}{c}+1, \frac{D}{c} + \log n))$, where $D$ is the diameter of a graph. The second algorithm is deterministic. It requires an input integer $k \ge \max(D, \dmax)$, where $\dmax$ is the maximum degree of the graph. The cover time of this algorithm is $O(m + nD)$, and it uses $O(\log k)$ bits of memory for both the agent and each node.

Figures (5)

• Figure 1: An example of the trajectory of one DFT
• Figure 2: A (6,6)-lollipop graph
• Figure 3: A valid node $v$ with $N(v)=\{u_0,u_1,\dots,u_8\}$. The index $i$ of each $u_i$ represents the corresponding number in $v$, i.e., $u_i=N(v,i)$. The number in each rectangle represents the value of $u_i.\mathtt{nextChild}$. In addition, $v = N(u_i,u_i.\mathtt{parent})$ and $u_i.\mathtt{level} = v.\mathtt{level} = 1$ must hold for all $i\in\{2,4,5,7\}$. Then, $u_2$, $u_4$, $u_5$, and $u_7$ are the children of $v$.
• Figure 4: How to expand tree $T(r)$ in phase $3$. A number in a circle represents the level of the corresponding node. An arrow from node $u$ to $v$ indicates that $u$ is a child of $v$. The orange region represents which nodes join $T(r)$.
• Figure 5: A consistent but undesirable tree

Theorems & Definitions (19)

• Lemma 1
• proof
• Lemma 2
• proof
• Lemma 3
• proof
• Corollary 1
• Theorem 1
• proof
• Lemma 4