A Self-Stabilizing Minimal k-Grouping Algorithm

TL;DR

This paper presents a self-stabilizing distributed algorithm for minimal k-grouping in graphs, ensuring efficient partitioning with bounded diameter and a novel composition technique for algorithm concatenation.

Contribution

It introduces a silent, self-stabilizing asynchronous algorithm for minimal k-grouping with proven time and space complexity, and a new loop composition method for algorithms.

Findings

Algorithm converges in O(nD/k) rounds.

Number of groups is at most 2n/k+1 after convergence.

Space complexity per process is O((n + n_false) log n).

Abstract

We consider the minimal k-grouping problem: given a graph G=(V,E) and a constant k, partition G into subgraphs of diameter no greater than k, such that the union of any two subgraphs has diameter greater than k. We give a silent self-stabilizing asynchronous distributed algorithm for this problem in the composite atomicity model of computation, assuming the network has unique process identifiers. Our algorithm works under the weakly-fair daemon. The time complexity (i.e., the number of rounds to reach a legitimate configuration) of our algorithm is O(nD/k) where n is the number of processes in the network and \diam is the diameter of the network. The space complexity of each process is O((n +n_{false})log n) where n_{false} is the number of false identifiers, i.e., identifiers that do not match the identifier of any process, but which are stored in the local memory of at least one process at the initial configuration. Our algorithm guarantees that the number of groups is at most $2n/k+1$ after convergence. We also give a novel composition technique to concatenate a silent algorithm repeatedly, which we call loop composition.

Tables

Table 3.2: $\mathrm{Loop}(𝒜,E,𝒫)$
[Notations]
$\mathrm{𝐼𝑙𝑙𝑒𝑔𝑎𝑙}\_\mathrm{𝑃𝑎𝑖𝑟}=\{(1,3),(1,4),(2,0),(2,1),(2,3),(2,4),(3,0),(3,1),(4,1),(4,2)\}$
$\mathrm{𝐷𝑜𝑤𝑛}\_\mathrm{𝑂𝐾}\left(v\right)\equiv (\forall u\in \mathrm{𝑃𝑎𝑟}\left(v\right):u.\mathrm{𝚌𝚕}=v.\mathrm{𝚌𝚕}+1)\wedge (\forall u\in \mathrm{𝐶ℎ𝑖}\left(v\right):u.\mathrm{𝚌𝚕}=v.\mathrm{𝚌𝚕})$
$\mathrm{𝑈𝑝}\_\mathrm{𝑂𝐾}\left(v\right)\equiv (\forall u\in \mathrm{𝑃𝑎𝑟}\left(v\right):u.\mathrm{𝚌𝚕}=v.\mathrm{𝚌𝚕})\wedge (\forall u\in \mathrm{𝐶ℎ𝑖}\left(v\right):u.\mathrm{𝚌𝚕}\equiv v.\mathrm{𝚌𝚕}+1\left(mod5\right))$
[Actions of process $v$]
$L_{\text{<a><span>3.2</span></a>}}$	$\mathrm{BFS}\text{–Enabled}\left(v\right)$	$⟶$	execute BFS
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}\notin \{0,3,4\})\wedge (v.\mathrm{𝚛𝚜𝚝}=1)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 0$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}\in \{1,2\})\wedge (\exists u\in \mathrm{𝑃𝑎𝑟}\left(v\right):u.\mathrm{𝚌𝚕}=0)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 0$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}\in \{3,4\})\wedge (\exists u\in \mathrm{𝑃𝑎𝑟}\left(v\right):u.\mathrm{𝚌𝚕}=0)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 0$, $v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚖𝚘𝚍𝚎}=A)\wedge E\left(v\right)\wedge (\forall u\in N_v^1:u.\mathrm{𝚌𝚕}\ne 4)$	$⟶$	$v.\mathrm{𝚖𝚘𝚍𝚎}\leftarrow P$, $v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚖𝚘𝚍𝚎}=A)\wedge (v.\mathrm{𝚌𝚕}\ne 4)\wedge (\exists u\in N_v:u.\mathrm{𝚖𝚘𝚍𝚎}=P)$	$⟶$	$v.\mathrm{𝚖𝚘𝚍𝚎}\leftarrow P$, $v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$𝒜\text{–Enabled}\left(v\right)\wedge (\forall u\in N_v^1:u.\mathrm{𝚖𝚘𝚍𝚎}=A\wedge u.\mathrm{𝚌𝚕}\ne 4)$	$⟶$	execute $𝒜$, $v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$𝒫\text{–Enabled}\left(v\right)\wedge (\forall u\in N_v^1:u.\mathrm{𝚖𝚘𝚍𝚎}=P\wedge u.\mathrm{𝚌𝚕}\ne 4)$	$⟶$	execute $𝒫$, $v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$\exists u\in \mathrm{𝐶ℎ𝑖}\left(v\right):(v.\mathrm{𝚌𝚕},u.\mathrm{𝚌𝚕})\in \mathrm{𝐼𝑙𝑙𝑒𝑔𝑎𝑙}\_\mathrm{𝑃𝑎𝑖𝑟}$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 0$, $v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚛𝚜𝚝}=0)\wedge (\exists u\in \mathrm{𝐶ℎ𝑖}\left(v\right):u.\mathrm{𝚛𝚜𝚝}=1)$	$⟶$	$v.\mathrm{𝚛𝚜𝚝}\leftarrow 1$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚛𝚜𝚝}=1)\wedge (\forall u\in \mathrm{𝑃𝑎𝑟}\left(v\right):u.\mathrm{𝚛𝚜𝚝}=1)$	$⟶$	$v.\mathrm{𝚛𝚜𝚝}\leftarrow 0$
	$\wedge (\forall u\in \mathrm{𝐶ℎ𝑖}\left(v\right):u.\mathrm{𝚛𝚜𝚝}=0)$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}\in \{0,2\})\wedge \mathrm{𝐷𝑜𝑤𝑛}\_\mathrm{𝑂𝐾}\left(v\right)\wedge (v.\mathrm{𝚛𝚜𝚝}=0)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow v.\mathrm{𝚌𝚕}+1$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}=1)\wedge \mathrm{𝑈𝑝}\_\mathrm{𝑂𝐾}\left(v\right)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 2$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}=3)\wedge (v.\mathrm{𝚖𝚘𝚍𝚎}=A)\wedge (\forall u\in \mathrm{𝐶ℎ𝑖}\left(v\right):u.\mathrm{𝚌𝚕}\ne 2)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 4$, $v.\overline{x}\leftarrow v.x$
	$\wedge (\exists x\in O_{𝒜}:v.\overline{x}\ne v.x\vee \exists u\in N_v:u.\mathrm{𝚌𝚕}=4)$		for all $x\in O_{𝒜}$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}=3)\wedge (v.\mathrm{𝚖𝚘𝚍𝚎}=P)\wedge (\forall u\in \mathrm{𝐶ℎ𝑖}\left(v\right):u.\mathrm{𝚌𝚕}\ne 2)$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 4$, $v.\mathrm{𝚖𝚘𝚍𝚎}\leftarrow A$
$L_{\text{<a><span>3.2</span></a>}}$	$(v.\mathrm{𝚌𝚕}=4)\wedge \mathrm{𝑈𝑝}\_\mathrm{𝑂𝐾}\left(v\right)\wedge (\forall u\in N_v:u.\mathrm{𝚌𝚕}\in \{0,4\})$	$⟶$	$v.\mathrm{𝚌𝚕}\leftarrow 0$

Table 3.3: Non-copy Variables used in $\mathrm{𝐼𝑛𝑖𝑡}$ and $\mathrm{𝑀𝑒𝑟𝑔𝑒}$

[Non-array variables]

$\begin{array}{c}v.\mathrm{𝚍𝚘𝚖𝚊𝚒𝚗}\in 2^{\mathrm{𝐼𝐷}},\\ v.0pt\in [0,\lfloor k/2\rfloor ],v.\mathrm{𝚒𝚗𝚒𝚝𝙶𝚛𝚘𝚞𝚙},v.\mathrm{𝚐𝚛𝚘𝚞𝚙}\in \mathrm{𝐼𝐷}\end{array}$

[Array variables ($u\in v.\mathrm{𝚍𝚘𝚖𝚊𝚒𝚗}$)]

$\begin{array}{c}v.\mathrm{𝚍𝚒𝚜𝚝}\left[u\right],v.\mathrm{𝚐𝚛𝚘𝚞𝚙𝙳}\left[u\right],v.\mathrm{𝚖𝚎𝚛𝚐𝚎𝙳}\left[u\right],v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝙳}\left[u\right]\in [0,2k]\cup \{\perp \},\\ v.\mathrm{𝚋𝚘𝚛𝚍𝚎𝚛}\left[u\right],v.\mathrm{𝚏𝚊𝚛}\left[u\right],v.\mathrm{𝚝𝚊𝚛𝚐𝚎𝚝}\left[u\right],v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝟷}\left[u\right],v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝟸}\left[u\right],v.\mathrm{𝚐𝚛𝚘𝚞𝚙𝚜}\left[u\right]\in \mathrm{𝐼𝐷}\cup \{\perp \},\\ v.\mathrm{𝚖𝚎𝚛𝚐𝚒𝚗𝚐}\left[u\right],v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝙾𝙽}\left[u\right],v.\mathrm{𝚙𝚛𝚒𝚘𝚛}\left[u\right]\in \{\mathrm{𝐟𝐚𝐥𝐬𝐞},\mathrm{𝐭𝐫𝐮𝐞}\}\end{array}$

Table 4: $\mathrm{𝐼𝑛𝑖𝑡}$
[Actions of process $v$]
$I_{\text{<a><span>4</span></a>}}$ $v.\mathrm{𝚍𝚘𝚖𝚊𝚒𝚗}$ $⟵$ $\mathrm{𝐷𝑜𝑚𝑎𝑖𝑛}\left(v\right)$ $I_{\text{<a><span>4</span></a>}}$ $v.\mathrm{𝚍𝚒𝚜𝚝}\left[u\right]$ $⟵$ $\mathrm{𝐷𝑖𝑠𝑡}(v,u)$ $I_{\text{<a><span>4</span></a>}}$ $v.0pt$ $⟵$ $\mathrm{𝐻𝑒𝑖𝑔ℎ𝑡}\left(v\right)$ $I_{\text{<a><span>4</span></a>}}$ $v.\mathrm{𝚒𝚗𝚒𝚝𝙶𝚛𝚘𝚞𝚙}$ $⟵$ $\mathrm{𝐼𝑛𝑖𝑡𝐺𝑟𝑜𝑢𝑝}\left(v\right)$ $I_{\text{<a><span>4</span></a>}}$ $v.\overline{\mathrm{𝚐𝚛𝚘𝚞𝚙}}$ $⟵$ $\mathrm{𝐼𝑛𝑖𝑡𝐺𝑟𝑜𝑢𝑝}\left(v\right)$	$I_{\text{<a><span>4</span></a>}}$ $v.\overline{\mathrm{𝚐𝚛𝚘𝚞𝚙𝚜}}\left[u\right]$ $⟵$ $\mathrm{𝐒𝐡𝐚𝐫𝐞}(v,u,\overline{\mathrm{𝚐𝚛𝚘𝚞𝚙𝚜}},v.\overline{\mathrm{𝚐𝚛𝚘𝚞𝚙}})$ $I_{\text{<a><span>4</span></a>}}$ $v.\overline{\mathrm{𝚐𝚛𝚘𝚞𝚙𝙳}}\left[u\right]$ $⟵$ $\mathrm{𝐃𝐢𝐬𝐭𝐚𝐧𝐜𝐞}(v,u,\overline{\mathrm{𝚐𝚛𝚘𝚞𝚙𝙳}},S_v)$ $I_{\text{<a><span>4</span></a>}}$ $v.\overline{\mathrm{𝚜𝚝𝚊𝚖𝚙𝙾𝙽}}\left[u\right]$ $⟵$ $\mathrm{𝐟𝐚𝐥𝐬𝐞}$ $I_{\text{<a><span>4</span></a>}}$ $v.\overline{\mathrm{𝚙𝚛𝚒𝚘𝚛}}\left[u\right]$ $⟵$ $\mathrm{𝐟𝐚𝐥𝐬𝐞}$

Table 4: Functions used to describe $\mathrm{𝐼𝑛𝑖𝑡}$

Table 4: Error-detecting variable $E\left(v\right)$
where $(s_1,s_2,s_D)=(v.\overline{\mathrm{𝚜𝚝𝚊𝚖𝚙𝟸}}\left[u\right],v.\overline{\mathrm{𝚜𝚝𝚊𝚖𝚙𝟸}}\left[u\right],v.\overline{\mathrm{𝚜𝚝𝚊𝚖𝚙𝙳}}\left[u\right])$.

Table 4.4: $\mathrm{𝑀𝑒𝑟𝑔𝑒}$
[Actions of process $v$]
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚋𝚘𝚛𝚍𝚎𝚛}\left[u\right]$	$⟵$	$\mathrm{𝐌𝐢𝐧}\left(v,\mathrm{𝚋𝚘𝚛𝚍𝚎𝚛}\left[u\right],N_v\left(u\right)\ne \varnothing \right)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚏𝚊𝚛}\left[u\right]$	$⟵$	$\mathrm{𝐌𝐢𝐧}(v,\mathrm{𝚏𝚊𝚛}\left[u\right],\exists w\in g_v\left(u\right):v.\mathrm{𝚍𝚒𝚜𝚝}\left[w\right]=k+1)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚝𝚊𝚛𝚐𝚎𝚝}\left[u\right]$	$⟵$	$\mathrm{𝐒𝐡𝐚𝐫𝐞}(v,u,\mathrm{𝚝𝚊𝚛𝚐𝚎𝚝},\mathrm{𝑇𝑎𝑟𝑔𝑒𝑡}\left(v\right))$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚖𝚎𝚛𝚐𝚎𝙳}\left[u\right]$	$⟵$	$\mathrm{𝑀𝑒𝑟𝑔𝑒𝐷𝑖𝑠𝑡}(v,u)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝟷}\left[u\right]$	$⟵$	${\mathrm{𝑆𝑡𝑎𝑚𝑝}}_1(v,u)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝙳}\left[u\right]$	$⟵$	${\mathrm{𝑆𝑡𝑎𝑚𝑝}}_D(v,u)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝟸}\left[u\right]$	$⟵$	$\mathrm{𝐌𝐢𝐧}\left(v,\mathrm{𝚜𝚝𝚊𝚖𝚙𝟸}\left[u\right],{\mathrm{𝑆𝑡𝑎𝑚𝑝}}_D(v,u)=k+1\right)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚐𝚛𝚘𝚞𝚙}$	$⟵$	$\mathrm{𝐺𝑟𝑜𝑢𝑝}\left(v\right)$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚐𝚛𝚘𝚞𝚙𝚜}\left[u\right]$	$⟵$	$\mathrm{𝐒𝐡𝐚𝐫𝐞}(v,u,\mathrm{𝚐𝚛𝚘𝚞𝚙𝚜},v.\mathrm{𝚐𝚛𝚘𝚞𝚙})$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚐𝚛𝚘𝚞𝚙𝙳}\left[u\right]$	$⟵$	$\mathrm{𝐃𝐢𝐬𝐭𝐚𝐧𝐜𝐞}(v,u,\mathrm{𝚐𝚛𝚘𝚞𝚙𝙳},\{w\in N_v\mid w.\mathrm{𝚐𝚛𝚘𝚞𝚙}=v.\mathrm{𝚐𝚛𝚘𝚞𝚙}\})$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚖𝚎𝚛𝚐𝚒𝚗𝚐}\left[u\right]$	$⟵$	$\mathrm{𝐒𝐡𝐚𝐫𝐞}(v,u,\mathrm{𝚖𝚎𝚛𝚐𝚒𝚗𝚐},\mathrm{𝑀𝑒𝑟𝑔𝑖𝑛𝑔}\left(v\right))$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝙾𝙽}\left[u\right]$	$⟵$	$v.\mathrm{𝚜𝚝𝚊𝚖𝚙𝙳}\left[u\right]\ne \perp \wedge \neg \mathrm{𝑀𝑒𝑟𝑔𝑖𝑛𝑔}\left(v\right)\wedge \neg v.\mathrm{𝚖𝚎𝚛𝚐𝚒𝚗𝚐}\left[u\right]$
$M_{\text{<a><span>4.4</span></a>}}$	$v.\mathrm{𝚙𝚛𝚒𝚘𝚛}\left[u\right]$	$⟵$	$\mathrm{𝐒𝐡𝐚𝐫𝐞}(v,u,\mathrm{𝚙𝚛𝚒𝚘𝚛},\mathrm{𝑃𝑟𝑖𝑜𝑟}\left(v\right))$

Table 4.4: Functions used to describe $\mathrm{𝑀𝑒𝑟𝑔𝑒}$

Equations

$$(v.\mathtt{cl},u.\mathtt{cl})\in Illegal\_Pair=$$

$$(2,4),(3,0),(3,1),(4,1),(4,2)\}.$$

Full text

1 Introduction

Modern networks or distributed systems generally consist of numerous computers (or processes). Therefore, it is important, in some applications, to partition such a system into a set of groups, among each of which processes communicate with each other without much delay. This problem has been formalized as $k$-clustering. In the literature, the following similar but different two definitions exist for $k$-clustering: given a graph $G(V,E)$ and a constant integer $k$, one is to find a partition of $V$ into $\{V_{1},\dots,V_{s}\}$ such that every subgraph $G(V_{i})$ induced by $V_{i}$ has radius no greater than $k$, and the other one is to find a partition of $V$ into $\{V_{1},\dots,V_{s}\}$ such that every subgraph $G(V_{i})$ has diameter no greater than $k$. In the former case, it is also required to designate one process of each subgraph $G(V_{i})$ as a cluster-head such that all processes of $G(V_{i})$ are located within $k$ hops from the cluster head. In this paper, we call the former asymmetric $k$-clustering and call the latter $k$-grouping.

Our Contributions

This paper considers $k$-grouping. We aim to construct a minimal $k$-grouping, since finding the minimum $k$-grouping is known to be NP-hard for $k>0$ [7]. Specifically, a partition of $V$ into $V_{1},\dots,V_{s}$ is said to be a minimal $k$-grouping if every two distinct subgraphs $G(V_{i})$ and $G(V_{j})$ are unmergeable, that is, $G(V_{i}\cup V_{j})$ has diameter greater than $k$. We give a self-stabilizing minimal $k$-grouping algorithm for any undirected graph with unique process-identifiers. The time complexity of our algorithm is $O(nD/k)$ rounds, where $n=|V|$ and $D$ is the diameter of the network, while the space complexity is $O((n+n_{\mathit{false}})\log n)$ bits per process, where $n_{\mathit{false}}$ is the number of false identifiers, i.e., identifiers stored in the memory of processes in the initial configuration which do not match the identifier of any process. Our algorithm also guarantees that the number of groups is at most $2n/k+1$.

We introduce a novel composition technique, loop composition, to define our algorithm. To the best of our knowledge, this is the first composition technique that enables the same algorithm (called the base algorithm) to be executed arbitrarily many times repeatedly. Specifically, every time an execution of the base algorithm terminates, a new execution of the base algorithm starts after the values of all output variables are copied to the corresponding input variables, unless a specific condition holds. This composition technique reuses the same variables of the base algorithm repeatedly. It helps us design an algorithm with small space complexity. Moreover, it also helps us eliminate certain assumptions. For example, our algorithm repeats at most $n/k$ executions of its base algorithm, but it does not need to know even an upper bound of $n$.

Related Work

Distributed $k$-grouping algorithms are given in [12, 11]. Fernandess and Malkhi [12] give a non self-stabilizing $k$-grouping algorithm in a unit disk graph. Their algorithm does not guarantee minimality, but does guarantee an $O(k)$-approxi-mation, meaning that the number of groups it produces is within an $O(k)$ factor of the optimum number of groups. Its time complexity is $O(n)$, and its space complexity is $O(k\log n)$ bits per process. Ducourthial and Khalfallah [11] give a self-stabilizing $k$-grouping algorithm in a unit disk graph. Their algorithm guarantees minimality of groups. However, no upper bound on the number of groups is given. The upper bound of the time complexity is also not given.

Finding the minimum asymmetric $k$-clustering is also $NP$-hard [1]. Two self-stabilizing asymmetric $k$-clustering algorithms exist in the literature [3, 4]; The algorithm of [3] is $O(k)$-competitive while that of [4] guarantees that clusters it produces are minimal and the number of the clusters is at most $(k+1)/n$.

There are a variety of techniques to compose two or more self-stabilizing algorithms in the literature [9, 10, 2, 13, 4, 14, 15], such as fair-composition [10] and parallel composition [9], but none of them enables an unbounded number of repetitions of the same algorithm, such as ours.

2 Preliminaries

A connected undirected network $G=(V,E)$ of $n=|V|$ processes is given where $n\geq 2$. Each process $v$ has a unique identifier $v.\mathit{id}$ chosen from a set $\mathit{ID}$ of non-negative integers. We assume that $|\mathit{ID}|\leq O(n^{c})$ holds for some constant $c$, thus, a process can store an identifier in $O(\log n)$ space. By an abuse of notation, we will identify each process with its identifier, and vice versa, whenever convenient. We call a member of $\mathit{ID}$ a false identifier if it does not match the identifier of any process in $V$.

We use the locally shared memory model [8]. A process is modeled by a state machine and its state is defined by the values of its variables. A process can read the values of its own and its neighbors’ variables simultaneously, but can update only its own variables. An algorithm of each process $v$ is defined to be a finite set of actions of the following form: $<label><guard>\ \longrightarrow\ <statement>$. The label of each action is used for reference. The guard is a predicate on the variables and identifiers of $v$ and its neighbors. The statement is an assignment which updates the state of $v$. An action can be executed only if it is enabled, *i.e. *its guard evaluates to true, and a process is enabled if at least one of its actions is enabled. The evaluation of a guard and the execution of the corresponding statement are presumed to take place in one atomic step, according to the composite atomicity model [9].

A configuration of the network is a vector consisting of a state for each process. We denote by $\gamma(v).x$ the value of variable $x$ of process $v$ in configuration $\gamma$. Each transition from a configuration to another, called a step of the algorithm, is driven by a daemon. We assume the distributed daemon in this paper; at each step, the distributed daemon selects one or more enabled processes to execute an action. If a selected process has two or more enabled actions, it executes the action with the smallest label number. We write $\gamma\mapsto_{{\cal A}}\gamma^{\prime}$ if configuration $\gamma$ can change to $\gamma^{\prime}$ by one step of algorithm ${\cal A}$. We define an execution of algorithm ${\cal A}$ to be a sequence of configurations $\gamma_{0},\gamma_{1},\cdots$ such that $\gamma_{i}\mapsto_{{\cal A}}\gamma_{i+1}$ for all $i\geq 0$. We assume the daemon to be weakly-fair, meaning that a continuously enabled process must be selected eventually.

An execution is maximal if it is infinite, or it terminates at a final configuration, *i.e. *a configuration at which no process is enabled. Let ${\cal L}$ be a predicate on configurations. We say that a configuration $\gamma$ of ${\cal A}$ is safe for ${\cal L}$ if every execution $\gamma_{0},\gamma_{1},\dots$ of ${\cal A}$ starting from $\gamma$ (i.e. $\gamma_{0}=\gamma$) always satisfies ${\cal L}$, that is, ${\cal L}(\gamma_{i})$ holds for all $i\geq 0$. Algorithm ${\cal A}$ is said to be self-stabilizing for ${\cal L}$ if there exists a set ${\cal C}$ of configurations of ${\cal A}$ such that every configuration in ${\cal C}$ is safe and every maximal execution $\gamma_{0},\gamma_{1},\dots$ of ${\cal A}$ reaches a configuration in ${\cal C}$, i.e. $\gamma_{i}\in{\cal C}$ holds for some $i\geq 0$. We also say that ${\cal A}$ is silent if every execution of ${\cal A}$ is finite. Thus, a silent algorithm ${\cal A}$ is self-stabilizing for predicate ${\cal L}$ if and only if every final configuration satisfies ${\cal L}$. In the remainder of this paper, we say “$\gamma\in{\cal L}$” or “configuration $\gamma$ in ${\cal L}$” to mean that ${\cal L}(\gamma)=\mathbf{true}$.

We measure time complexity of an execution in rounds [9]. We say that process $v$ is neutralized at step $\gamma_{i}\mapsto\gamma_{i+1}$ if $v$ is enabled at $\gamma_{i}$ and not at $\gamma_{i+1}$. We define the first round of an execution $\varrho=\gamma_{0},\gamma_{1},\dots$ to be the minimum prefix $\gamma_{0}\ldots\gamma_{s}$ during which every process enabled at $\gamma_{0}$ executes an action or is neutralized. The second round of $\varrho$ is defined to be the first round of the execution $\gamma_{s},\gamma_{s+1},\ldots$, and so forth. We evaluate the number of rounds of $\rho$, denoted by $R(\varrho)$, as the time of $\varrho$.

Let $N_{v}$ denote the neighbors of a process $v$, i.e. $N_{v}=\{u\mid\{u,v\}\in E\}$. The distance $d(u,v)$ between processes $u$ and $v$ is defined to be the smallest length of any path between them, where length is defined to be the number of edges. Define $N_{v}^{i}=\{u\in V\mid d(u,v)\leq i\}$, the $i$-neighborhood of $v$. Note that $N_{v}^{1}=N_{v}\cup\{v\}$. Graph $G(V^{\prime})$ denotes the subgraph of $G=(V,E)$ induced by the set of processes $V^{\prime}\subseteq V$. Define $d_{V^{\prime}}$, or $d_{G(V^{\prime})}$, to be the distance in $G(V^{\prime})$. If there is no path in $G(V^{\prime})$ between $u$ and $v$, we say $d_{V^{\prime}}(u,v)=\infty$. We denote the diameter of $G(V^{\prime})$ by $D(G(V^{\prime}))$, defined to be $\max\{d_{V^{\prime}}(u,v)\mid u,v\in V^{\prime}\}$. We write $D=D(G)$. (Note that $D(G^{\prime})=\infty$ if $G^{\prime}$ is not connected.)

By an abuse of notation, we sometimes regard a predicate on configurations as the set of configurations throughout the paper. For example, we write $\gamma\in{\cal L}_{1}\cap{\cal L}_{2}$ when a configuration $\gamma$ satisfies both predicates ${\cal L}_{1}$ and ${\cal L}_{2}$.

Problem Specification

Given an integer $k$, our goal is to find a minimal partition111 This definition of minimality, which is the same as [11], does not allow any pair of groups to be mergeable, but it allows some three or more groups to be mergeable. Intuitively, it seems quite costly (perhaps requires exponential time), even in centralized computing, to find a “strict minimal” solution where no set of groups is mergeable.

$\{V_{1},\dots,V_{s}\}$ with diameter-bound $k$, which means (i) $V=\bigcup_{i=1}^{s}V_{i}$, (ii) $V_{i}\cap V_{j}=\emptyset$ for any $i\neq j$, (iii) $D(G(V_{i}))\leq k$ for any $i$, and $D(G(V_{i}\cup V_{j}))>k$ holds for $i\neq j$. We assume that each process $v$ has variable $v.\mathtt{group}\in\mathit{ID}$. We define predicate ${\cal L}_{k}(\gamma)$ as follows: ${\cal L}_{k}(\gamma)=\mathbf{true}$ if and only if, in configuration $\gamma$, $\{V(i)\neq\emptyset\mid i\in V\}$ is a minimal partition with diameter-bound $k$ where $V(i)=\{u\in V\mid u.\mathtt{group}=i\}$. Our goal is to develop a silent self-stabilizing algorithm for ${\cal L}_{k}$.

3 Loop composition

In this section, we give a novel composition technique to develop a new algorithm. Given two algorithms ${\cal A}$ and ${\cal P}$ and a predicate $E$, this technique generates a silent self-stabilizing algorithm $\mathrm{Loop}({\cal A},E,{\cal P})$ for predicate ${\cal L}$, whose time complexity is $O(n+T_{{\cal P}}+R_{{\cal A}}+L_{{\cal A}}D)$ rounds. As we shall see later, $T_{{\cal P}}$ is an upper bound on the number of rounds of any maximal execution of ${\cal P}$, $L_{{\cal A}}$ is an upper bound on the number of iterations of ${\cal A}$’s executions, $R_{{\cal A}}$ is an upper bound on the total number of rounds of those (iterated) executions in ${\cal A}$.

3.1 Preliminaries

Algorithm ${\cal A}$ is the base algorithm of $\mathrm{Loop}({\cal A},E,{\cal P})$, and is executed repeatedly during one execution of $\mathrm{Loop}({\cal A},E,{\cal P})$. Algorithm ${\cal A}$ assumes that the network always stays at a configuration satisfying a specific condition. Predicate $E$ is used to detect that the network deviates from that condition, and algorithm ${\cal P}$ is invoked to initialize the network when such a deviation is detected. We define $O_{\cal A}$ (resp. $O_{\cal P}$) as the set of variables whose values can be updated by an action of ${\cal A}$ (resp. ${\cal P}$), and $I_{\cal A}$ (resp. $I_{\cal P}$) as the set of variables whose value is never updated and only read by an action of ${\cal A}$ (resp. ${\cal P}$). We assume $O_{\cal A}\cap O_{\cal P}=\emptyset$ and $I_{\cal P}=\emptyset$. The error detecting predicate $E(v)$ is evaluated by process $v\in V$, and its value depends only on variables of $I_{\cal A}\cup O_{\cal P}$ of the processes of $N_{v}^{1}$. Let ${\cal E}$ be a predicate on configurations such that ${\cal E}(\gamma)$ holds if and only if $\bigvee_{v\in V}E(v)$ holds in configuration $\gamma$. We assume that algorithm ${\cal A}$ has a copying variable $\overline{x}\in I_{\cal A}$ for every variable $x\in O_{\cal A}$. We define $\gamma^{\mathrm{copy}}$ as the configuration obtained by replacing the value of $v.\overline{x}$ with the value of $v.x$ for every process $v$ and every variable $x\in O_{\cal A}$ in configuration $\gamma$. We define predicate ${\cal C}_{\mathrm{goal}}({\cal A},E)$ as follows: configuration $\gamma$ satisfies ${\cal C}_{\mathrm{goal}}({\cal A},E)$ if and only if $\gamma\in\lnot{\cal E}$, $\gamma^{\mathrm{copy}}=\gamma$, and no action of ${\cal A}$ is enabled in any process. In the rest of this section, we simply denote ${\cal C}_{\mathrm{goal}}({\cal A},E)$ by ${\cal C}_{\mathrm{goal}}$. We assume that ${\cal A}$ satisfies the following three requirements:

Shiftable Convergence

Every maximal execution of ${\cal A}$ that starts from a configuration in $\lnot{\cal E}$ terminates at a configuration $\gamma$ such that $\gamma^{\mathrm{copy}}\in\lnot{\cal E}$.

Loop Convergence

If $\varrho_{0},\varrho_{1}\dots$ is an infinite sequence of maximal executions of ${\cal A}$ where $\varrho_{i}=\gamma_{i,0},\gamma_{i,1},\dots,\gamma_{i,s_{i}}$, $\gamma_{0,0}\in\lnot{\cal E}$, and $\gamma_{i+1,0}=\gamma_{i,s_{i}}^{\mathrm{copy}}$ for each $i\geq 0$, then $\gamma_{j,s_{j}}\in{\cal C}_{\mathrm{goal}}$ and $R(\varrho_{0})+R(\varrho_{1})+\dots R(\varrho_{j})<R_{{\cal A}}$ hold for some $j<L_{{\cal A}}$, and

Correctness

$\gamma\in{\cal C}_{\mathrm{goal}}\Rightarrow\gamma\in{\cal L}$ holds for every configuration $\gamma$.

Algorithm ${\cal P}$ is used to initialize a network when the network stays at a configuration in ${\cal E}$. We assume that every maximal execution of ${\cal P}$ terminates at a configuration in $\lnot{\cal E}$ within $T_{{\cal P}}$ rounds.

3.2 Algorithm ${\mathrm{Loop}({\cal A},E,{\cal P})}$

In this subsection, we present an algorithm $\mathrm{Loop}({\cal A},E,{\cal P})$ given ${\cal A}$, $E$, and ${\cal P}$ satisfying the above requirements. Our algorithm is a silent self-stabilizing for ${\cal L}$ and its time complexity is $O(n+T_{{\cal P}}+R_{{\cal A}}+L_{{\cal A}}D)$ rounds.

Our strategy to implement $\mathrm{Loop}({\cal A},E,{\cal P})$ is simple: The network executes ${\cal A}$ repeatedly while it stays at configurations in $\lnot{\cal E}$. When an execution of ${\cal A}$ terminates, each process $v$ copies the value of $v.x$ to $v.\overline{x}$ for all $x\in O_{\cal A}$, and the network restarts a new execution of ${\cal A}$, unless it reaches a configuration in ${\cal C}_{\mathrm{goal}}$. The network executes ${\cal P}$ when it stays in ${\cal E}$. The assumptions of ${\cal A}$ and ${\cal P}$ guarantee that the network eventually reaches a configuration in ${\cal L}$.

We give the actions of $\mathrm{Loop}({\cal A},E,{\cal P})$ in Table 3.2. In what follows, we denote by ${\cal X}\text{--Enabled}(v)$ that some action of algorithm ${\cal X}$ is enabled at process $v$.

We use the algorithm of [5], (denoted by BFS in this paper) as a module to construct a BFS tree ($\mathrm{L}_{1}$). The tree is used as a communication backbone for $\mathrm{Loop}({\cal A},E,{\cal P})$. Algorithm BFS is silent and self-stabilizing and constructs a BFS tree: each process $v$ has variable $v.\mathtt{parent}\in N_{v}\cup\{\bot\}$ where $\bot$ means undefined or null value, and every maximal execution of BFS terminates at a configuration in ${\cal L}_{\mathrm{BFS}}$ where $r.\mathtt{parent}=\bot$ for some $r\in V$ and the set of edges $\{(v,v.\mathtt{parent})\mid v\neq r\}$ spans a BFS tree rooted at $r$. We define $\mathit{Par}(v)=\{v.\mathtt{parent}\}$ and $\mathit{Chi}(v)=\{u\in V\mid u.\mathtt{parent}=v\}$. We regard $\{\bot\}$ as the empty set, hence $\mathit{Par}(r)=\emptyset$ in a configuration satisfying ${\cal L}_{\mathrm{BFS}}$. Thus, a predicate such as “$\forall u\in\mathit{Par}(r):\dots$” always holds, and a predicate such as “$\exists u\in\mathit{Par}(r):\dots$” never holds. This algorithm terminates within $O(n)$ rounds and uses $O(\log n)$ space per process. We discuss the following part assuming that an execution of BFS already terminated and the network stays at configurations in ${\cal L}_{\mathrm{BFS}}$.

The difficulty we face is to detect termination of each execution of ${\cal A}$ and ${\cal P}$, and prevent any two processes from performing different executions at the same time (*e.g. *executions of ${\cal A}$ and ${\cal P}$ or the $i$th execution and $(i+1)$st execution of ${\cal A}$). We overcome it with a color wave mechanism. Specifically, each process $v$ has three variables $v.\mathtt{cl}\in\{0,1,2,3,4\}$, $v.\mathtt{mode}\in\{A,P\}$ and $v.\mathtt{rst}\in\{0,1\}$. Variable $v.\mathtt{cl}$ is the color of process $v$. Colors 0, 1, and 2 mean that the current execution of ${\cal A}$ or ${\cal P}$ may not have terminated yet, Color 3 means that the execution has already terminated, and Color 4 means that the network is now in transition to the next execution. Variable $v.\mathtt{mode}$ indicates which algorithm is currently executing. As we shall see later, all processes must have the same mode unless some process has color 4. Process $v$ executes ${\cal A}$ (resp. ${\cal P}$) if ${\cal A}\text{--Enabled}(v)$ (resp. ${\cal P}\text{--Enabled}(v)$) and every $u\in N_{v}^{1}$ satisfies $u.\mathtt{mode}=A$ (resp. $u.\mathtt{mode}=P$) and $u.\mathtt{cl}\neq 4$ ($\mathrm{L}_{\ref{aep:aenabled}}$-$\mathrm{L}_{\ref{aep:penabled}}$). A reset flag is used to prevent any process from having color 3 or 4 until the current execution of ${\cal A}$ or ${\cal P}$ terminates. Process $v$ raises a reset flag (i.e. $v.\mathtt{rst}\leftarrow 1$) every time it executes an action of ${\cal A}$ or ${\cal P}$ ($\mathrm{L}_{\ref{aep:aenabled}}$–$\mathrm{L}_{\ref{aep:penabled}}$). The raised flag is propagated from $v$ to the root $r$ through the BFS tree ($\mathrm{L}_{\ref{aep:propagate_reset}}$), resulting in changing $r$’s color to 0 unless it is already 3 or 4 ($\mathrm{L}_{\ref{aep:color_reset}}$). The reset flags are eventually dropped in order from $v$ to $r$ ($\mathrm{L}_{\ref{aep:del_reset}}$). Once $r$’s color is reset to 0, all other processes will also change their colors to 0 because a process changes its color to 0 when its parent has color 0 ($\mathrm{L}_{\ref{aep:color_init}}$–$\mathrm{L}_{\ref{aep:color_init34}}$).

Color waves are propagated through the BFS tree (Figure 1). Suppose that all processes have color 0 now. When $r.\mathtt{rst}=0$, the root $r$ begins a top-down color-1-wave changing all processes’ colors from [math] to $1$. Specifically, each $v\in V$ changes its color from 0 to 1 when its parent has color 1 ($r$ ignores this condition), all its children have color 0, and $v.\mathtt{rst}=0$ ($\mathrm{L}_{\ref{aep:down}}$). After the color-1-wave reaches all leaves, a bottom-up color-2-wave begins from leaves to $r$ changing all processes’ color from $1$ to $2$. Specifically, each $v\in V$ changes its color from 1 to 2 when its parent has color 1 ($r$ ignores this condition), and all its children have color 2 ($\mathrm{L}_{\ref{aep:to2}}$). As we will prove later, the current execution of ${\cal A}$ or ${\cal P}$ has already terminated when $r$ receives color-2-wave (Lemma 8). Thereafter, $r$ begins a top-down color-3-wave in the same way as a color-1-wave ($\mathrm{L}_{\ref{aep:down}}$). A process changes its color from 3 to 4 if the network should shift to the next execution of ${\cal A}$. Specifically, process $v$ with mode $A$ changes its color to 4 if some process has $\overline{x}\neq x$ for some variable $x\in O_{\cal A}$, and it performs $v.\overline{x}\leftarrow v.x$ for all variables $x\in O_{\cal A}$ for the next execution of ${\cal A}$ ($\mathrm{L}_{\ref{aep:to4_A}}$). Note that this color-4-wave is propagated by simple flooding (not through the $\mathrm{BFS}$ tree). A process with mode $P$ changes its color to 4 without this condition, and changes its mode to $A$ ($\mathrm{L}_{\ref{aep:to4_P}}$). In both cases, a process changes its color to 4 only after all its children change their colors from 2 to 3 ($\mathrm{L}_{\ref{aep:to4_A}}$, $\mathrm{L}_{\ref{aep:to4_P}}$); Otherwise, a color-3-wave may stop at the process. Finally, a bottom-up Color-0-wave moves from the leaves to $r$ changing all colors from 4 to 0. Specifically, a process changes its color from 4 to 0 if its parent has color 4 ($r$ ignores this condition), all its children have color 0, and every neighboring process has color 0 or 4 ($\mathrm{L}_{\ref{aep:to0}}$). The last condition is needed to prevent the process from executing the next execution of ${\cal A}$ before all its neighbors finish their copy procedure ($v.\overline{x}\leftarrow v.x$). All processes eventually return to color 0, and the network starts a new execution of ${\cal A}$.

The states of the processes may be incoherent in an arbitrary initial configuration, but $\mathrm{Loop}({\cal A},E,{\cal P})$ resolves the incoherence. Process $v$ changes its mode from $A$ to $P$ when $v$ finds $E(v)=\mathbf{true}$ or some neighboring process has mode $P$ ($\mathrm{L}_{\ref{aep:error}}$-$\mathrm{L}_{\ref{aep:afindsp}}$). At this time, $v$ ignores $E(v)=\mathbf{true}$ when some process $u\in N_{v}^{1}$ has color 4 ($\mathrm{L}_{\ref{aep:error}}$), and ignores a neighboring process with mode $P$ when $v.\mathtt{cl}=4$ ($\mathrm{L}_{\ref{aep:afindsp}}$). These exceptions are needed because, during a color-0-wave, $E(v)$ cannot be evaluated correctly and a process with mode $A$ can have a neighbor with mode $P$. Color-incoherence preventing color waves is removed as follows: process $v$ changes its color to 0 if some $u\in\mathit{Chi}(v)$ satisfies

[TABLE]

A reset flag is raised every time incoherence is detected and solved ($\mathrm{L}_{\ref{aep:color_init34}}$, $\mathrm{L}_{\ref{aep:error}}$, $\mathrm{L}_{\ref{aep:afindsp}}$, or $\mathrm{L}_{\ref{aep:illegal}}$) except for $\mathrm{L}_{\ref{aep:color_init}}$. This exception exists only to simplify the proof, as we shall see later.

An execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ terminates when every process $v$ satisfies $v.\mathtt{mode}=A$, $v.\mathtt{cl}=3$, $v.\mathtt{rst}=0$, $E(v)=\mathbf{false}$, ${\cal A}\text{--Enabled}(v)=\mathbf{false}$, and $v.x=v.\overline{x}$ for all $x\in O_{\cal A}$. We denote the set of such configurations by ${\cal C}_{\mathrm{fin}}$. Note that ${\cal C}_{\mathrm{fin}}\subseteq{\cal C}_{\mathrm{goal}}\subseteq{\cal L}$.

3.3 Correctness

In this subsection, we prove that every maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ terminates at a configuration in ${\cal C}_{\mathrm{fin}}$ within $O(n+T_{{\cal P}}+R_{{\cal A}}+L_{{\cal A}}D)$ rounds regardless of its initial configuration. For $i=0,1,2,3,4$, we define ${\cal R}_{i}$ as the set of configurations in ${\cal L}_{\mathrm{BFS}}$ where the root $r$ has color $i$. We define ${\cal C}_{S}$ as the set of configurations in ${\cal L}_{\mathrm{BFS}}$ where every process has a color in $S\subseteq\{0,1,2,3,4\}$.

Lemma 1**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal L}_{\mathrm{BFS}}$. Then, $\varrho$ reaches a configuration in ${\cal R}_{0}$ or ${\cal C}_{\mathrm{fin}}$ within $O(D)$ rounds.

Proof.

Obtained from the following Lemmas 2, 3, 5, 6, and 7. ∎

Lemma 2**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal R}_{1}$. Then, $\varrho$ reaches a configuration in ${\cal R}_{0}$ or ${\cal R}_{2}$ within $O(D)$ rounds.

Proof.

We assume that no process raises a reset flag until $r$’s color changes to 0 or 2. This assumption does not lose generality since $r$’s color changes to 0 within $O(D)$ rounds after some process raises a reset flag. By $\mathrm{L}_{\ref{aep:color_init34}}$ and $\mathrm{L}_{\ref{aep:illegal}}$, this assumption guarantees $\gamma_{0}\in{\cal C}_{\{0,1,2\}}$ and $\gamma_{0}(u).\mathtt{cl}=2\Rightarrow\gamma_{0}(v).\mathtt{cl}=2$ for all $u,v\in V$ such that $v\in\mathit{Chi}(u)$. Note that if a process with color 0 has a child with color 1 or 2, the child changes its color to 0 within one round by $\mathrm{L}_{\ref{aep:color_init}}$. Hence, all processes with color 0 change their colors to 1 within $O(D)$ rounds by a color-1-wave ($\mathrm{L}_{\ref{aep:down}}$), and all processes with color 1 including $r$ change their colors to 2 within the next $O(D)$ rounds by a color-2-wave ($\mathrm{L}_{\ref{aep:to2}}$). ∎

Lemma 3**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal R}_{2}$. Then, $\varrho$ reaches a configuration in ${\cal R}_{0}$ or ${\cal R}_{3}$ within $O(1)$ rounds.

Proof.

The root $r$ changes its color to 0 by $\mathrm{L}_{\ref{aep:illegal}}$ if it has a child of color 0, 1, 3, or 4. If all children of $r$ have color 2, $r$ changes its color to 3. We do not consider a reset flag above, but it just changes $r$’s color to 0. ∎

Lemma 4**.**

Let $\gamma$ be a configuration in ${\cal L}_{\mathrm{BFS}}$ where $u\in V$ has color $3$ and $v\in\mathit{Chi}(u)$ has color $2$. The color of $v$ changes to [math] or $3$ within $O(1)$ rounds in every maximal execution $\varrho$ of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma$.

Proof.

Process $u$ has color [math] or $3$ as long as $v$ has color $2$. Hence, $v$ always stays enabled unless $v$ executes some action. Therefore, $v$ is selected by the scheduler in the first round. At this time, $v$ changes its color to [math] by $\mathrm{L}_{\ref{aep:color_reset}}$, $\mathrm{L}_{\ref{aep:color_init}}$, or $\mathrm{L}_{\ref{aep:illegal}}$, changes its color to $3$ by $\mathrm{L}_{\ref{aep:down}}$, or raises a reset flag by $\mathrm{L}_{\ref{aep:error}}$, $\mathrm{L}_{\ref{aep:afindsp}}$, $\mathrm{L}_{\ref{aep:aenabled}}$, $\mathrm{L}_{\ref{aep:penabled}}$, $\mathrm{L}_{\ref{aep:propagate_reset}}$. In the last case, $v$ changes its color to [math] by $\mathrm{L}_{\ref{aep:color_reset}}$ the next time the scheduler selects $v$. ∎

Lemma 5**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal R}_{3}$. Then, $\varrho$ reaches a configuration in ${\cal R}_{0}$, ${\cal R}_{4}$, or ${\cal C}_{\mathrm{fin}}$ within $O(D)$ rounds.

Proof.

A process with color 3 changes its color to 0 by $\mathrm{L}_{\ref{aep:illegal}}$ within $O(1)$ rounds if it has a child with color 0 or 1. A process $v$ with color 3 changes its color to 0 or 4 by $\mathrm{L}_{\ref{aep:illegal}}$, $\mathrm{L}_{\ref{aep:to4_A}}$, or $\mathrm{L}_{\ref{aep:to4_P}}$ within $O(1)$ rounds if it has a child with color 4 because all its children with color 2 change their colors to 0 or 3 within $O(1)$ rounds (Lemma 4). Thus, the network reaches a configuration $\gamma_{i}$ in ${\cal R}_{0}$, ${\cal R}_{4}$, or ${\cal C}_{\{3\}}$ within $O(D)$ rounds. When $\gamma_{i}\in{\cal C}_{\{3\}}\setminus{\cal C}_{\mathrm{fin}}$, some process’s color changes to 4 within $O(1)$ rounds, which changes $r$’s color to 4 within $O(D)$ rounds. ∎

Lemma 6**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal R}_{4}$. Then, $\varrho$ reaches a configuration in ${\cal R}_{4}\cap{\cal C}_{\{0,4\}}$ or ${\cal R}_{0}$ within $O(D)$ rounds.

Proof.

Lemma 4 and $(4,2)\in\mathit{Illegal\_Pair}$ guarantee that, within $O(D)$ rounds, color $2$ disappears from all processes as long as $r.\mathtt{cl}=4$. After that, every process whose parent has color 0 or 4 also has color 0 or 4 within $O(1)$ rounds and thereafter never has color 1, 2, or 3 as long as $r.\mathtt{cl}=4$. Hence, the lemma is proven by induction on levels (*i.e. *the distance from the root $r$) of processes in the BFS tree. ∎

Lemma 7**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal R}_{4}\cap{\cal C}_{\{0,4\}}$. Then, $\varrho$ reaches a configuration in ${\cal R}_{0}$ within $O(D)$ rounds.

Proof.

No process changes its color to 1, 2, or 3 in a configuration of ${\cal R}_{4}\cap{\cal C}_{\{0,4\}}$. Hence, a color-0-wave by $\mathrm{L}_{\ref{aep:to0}}$ (or a reset flag) changes $r$’s color to 0 within $O(D)$ rounds. ∎

Lemma 8**.**

*Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ where $\gamma_{0}\in{\cal R}_{0}$. If $i>0$ is the smallest integer such that $\gamma_{i}\in{\cal R}_{2}$, then every process $v$ has the same mode ${\cal X}$ (${\cal A}$ or ${\cal P}$) and satisfies $\lnot{\cal X}\text{--Enabled}(v)$, $v.\mathtt{cl}=2$ and $v.\mathtt{rst}=0$ at configuration $\gamma_{i}$. *

Proof.

Let $j\ (0<j<i)$ be the largest integer such that $\gamma_{j-1}(r).\mathtt{cl}=0$ and $\gamma_{j}(r).\mathtt{cl}=1$. A color-1-wave beginning at $\gamma_{j}$ reaches every leaf, and thereafter a color-2-wave is initiated at leaves and reaches $r$ in $\gamma_{j},\dots,\gamma_{i}$. No process has color 3 or 4 in $\gamma_{j}$; Otherwise, such process $v$ changes its color from 3 or 4 to 0 and raises a reset flag before $v$ receives a color-1-wave, which changes $r$’s color to 0 again; This is a contradiction to $j$’s definition. Since no process changes its color to 3 during $\gamma_{j},\dots,\gamma_{i}$, every process has color 0, 1, or 2 during $\gamma_{j},\dots,\gamma_{i}$. In the same way, we can prove that all processes have the same mode ${\cal X}$ (${\cal A}$ or ${\cal P}$), and $\lnot{\cal X}\text{--Enabled}(v)$ and $v.\mathtt{rst}=0$ hold during $\gamma_{j},\dots,\gamma_{i}$, hence no process changes its color from 1 or 2 to 0 in the mean time. Thus, every process $v$ has the same mode ${\cal X}$ (${\cal A}$ or ${\cal P}$) and satisfies $\lnot{\cal X}\text{--Enabled}(v)$, $v.\mathtt{cl}=2$ and $v.\mathtt{rst}=0$ at configuration $\gamma_{i}$. ∎

We define ${\cal S}_{{\cal P}}$ to be the set of configurations in ${\cal R}_{0}\cap{\cal C}_{\{0,1,2\}}$ where every process has mode $P$, and define ${\cal S}_{{\cal A}}$ to be the set of configurations in ${\cal R}_{0}\cap{\cal C}_{\{0,1,2\}}$ and $\lnot{\cal E}$ such that every process has mode $A$.

Lemma 9**.**

Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal R}_{0}$. Then, $\varrho$ reaches a configuration in ${\cal S}_{{\cal A}}$ or ${\cal S}_{{\cal P}}$ within $O(D)$ rounds.

Proof.

Since $\gamma_{0}(r).\mathtt{cl}=0$, every process with color 3 or 4 changes its color to 0 within $O(D)$ rounds. At this time, each such process raises a reset flag by $\mathrm{L}_{\ref{aep:color_init34}}$–$\mathrm{L}_{\ref{aep:propagate_reset}}$, which will change $r$’s color to 0. Thus, the network reaches a configuration $\gamma$ in ${\cal R}_{0}\cap{\cal C}_{\{0,1,2\}}$ within $O(D)$ rounds. If two processes have different modes or some process $v$ has $(v.\mathtt{mode}=A)\wedge(E(v)=\mathbf{true})$ in $\gamma$, then all processes with mode $A$ change their modes to $P$ by $\mathrm{L}_{\ref{aep:error}}$ and $\mathrm{L}_{\ref{aep:afindsp}}$ within $O(D)$ rounds, keeping $r$’s color 0 with a reset flag, which proves the lemma. ∎

Lemma 10**.**

*Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal S}_{{\cal P}}$. Then, $\varrho$ reaches a configuration in ${\cal S}_{{\cal A}}$ within $O(T_{{\cal P}}+D)$ rounds. *

Proof.

Every ${\cal P}$–Enabled process performs ${\cal P}$’s action by $\mathrm{L}_{\ref{aep:penabled}}$ at least once with every one or two rounds until $r$’s color changes to $2$. Lemma 8 guarantees that $r$’s color never changes to [math] until an execution of ${\cal P}$ terminates. Hence, the network reaches within $O(T_{{\cal P}})$ rounds a configuration in $\lnot{\cal E}$ where no process is ${\cal P}$–Enabled. Thereafter, all reset flags are dropped within $O(D)$ rounds by $\mathrm{L}_{\ref{aep:del_reset}}$, and $r$’s color is 0 at the resulting configuration. The network reaches a configuration in ${\cal C}_{\{2\}}$ and again reaches a configuration $\gamma\in{\cal R}_{0}$ within the next $O(D)$ rounds by $\mathrm{L}_{\ref{aep:color_init}}$, $\mathrm{L}_{\ref{aep:down}}$ (a color-1-wave, a color-3-wave), $\mathrm{L}_{\ref{aep:to2}}$ (a color-2-wave), $\mathrm{L}_{\ref{aep:to4_P}}$ (a color-4-wave), and $\mathrm{L}_{\ref{aep:to0}}$ (a color-0-wave). Lemma 8 guarantees $\gamma\in{\cal S}_{{\cal A}}$. ∎

Lemma 11**.**

*Let $\varrho=\gamma_{0},\gamma_{1},\dots$ be a maximal execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ starting from $\gamma_{0}\in{\cal S}_{{\cal A}}$. Then, $\varrho$ reaches a configuration in ${\cal C}_{\mathrm{fin}}$ within $O(R_{{\cal A}}+L_{{\cal A}}D)$ rounds. *

Proof.

We can prove, in a similar way as the proof of Lemma 10, that execution $\varrho$ reaches within $O(T_{{\cal A}}+D)$ rounds a configuration in $C_{\{2\}}$ where no process is ${\cal A}$–Enabled. If $v.\overline{x}=v.x$ holds for all $v\in V$ and $x\in O_{\cal A}$, the network reaches a configuration in ${\cal C}_{\mathrm{fin}}$ by $\mathrm{L}_{\ref{aep:down}}$ within the next $O(D)$ rounds. Otherwise, all processes $v$ perform $v.\overline{x}\leftarrow v.x$ by $\mathrm{L}_{\ref{aep:to4_A}}$, and the network returns to a configuration in ${\cal S}_{{\cal A}}$ by $\mathrm{L}_{\ref{aep:to0}}$ within $O(D)$ rounds. The above execution is repeated until reaching a configuration in ${\cal C}_{\mathrm{fin}}$, and the number of iterations is bounded by $L_{{\cal A}}$. Since the total number of rounds in those iterated executions of ${\cal A}$ is at most $R_{{\cal A}}$, execution $\rho$ reaches a configuration in ${\cal C}_{\mathrm{fin}}$ within $O(R_{{\cal A}}+L_{{\cal A}}D)$ rounds. ∎

Theorem 1**.**

$\mathrm{Loop}({\cal A},E,{\cal P})$* is silent and self-stabilizing for ${\cal L}$. The execution of $\mathrm{Loop}({\cal A},E,{\cal P})$ terminates within $O(n+T_{{\cal P}}+R_{{\cal A}}+L_{{\cal A}}D)$ rounds. The space complexity per process is $O(\log n)$ bits.*

Proof.

The correctness and the time complexity is obtained from Lemmas 1, 9, 10, and 11. The variables used by all actions except for $\mathrm{L}_{1}$ require only constant space per process, however, the module BFS ($\mathrm{L}_{1}$) requires $O(\log n)$ bits of space per process. ∎

One may think that a classical self-stabilizing reset algorithm (such as the one described in [9]) can be used to simplify $\mathrm{Loop}({\cal A},E,{\cal P})$ instead of using the five-color waves. However, a self-stabilizing reset algorithm cannot be used directly to implement $\mathrm{Loop}({\cal A},E,{\cal P})$. A reset algorithm aims to reset or initialize the network to a legal initial configuration (after the illegal configuration is detected) while $\mathrm{Loop}({\cal A},E,{\cal P})$ aims to execute the base algorithm ${\cal A}$ repeatedly. Unlike reset algorithms, a reset signal in Loop is not used to initialize the network; a reset signal itself does not trigger an initialization algorithm ${\cal P}$. Instead, a reset signal is used just to change the color of the root to zero (i.e. to initiate the color waves). Five kinds of color waves described above guarantee that the $i+1$th execution of the base algorithm starts only after the $i$th execution terminates.

4 Minimal $k$-Grouping Algorithm

In this section, we give a silent self-stabilizing algorithm for minimal $k$-grouping using the loop composition method described in the previous section. In the following, we call a set of processes a group. Two distinct groups $g_{1},g_{2}\subseteq V$ are said to be mergeable if $D(G(g_{1}\cup g_{2}))\leq k$. Two distinct groups $g_{1},g_{2}\subseteq V$ are near if $\{v_{1},v_{2}\}\in E$ holds for some $v_{1}\in g_{1}$ and $v_{2}\in g_{2}$ and every $u_{1}\in g_{1}$ and $u_{2}\in g_{2}$ are within $k$ hops in $G$ (not necessarily in $G(g_{1}\cup g_{2})$). Note that two groups are mergeable only if they are near, but two groups are not necessarily mergeable even if they are near.

4.1 Overview

The proposed algorithm $\mathrm{Loop}(\mathit{Merge},E,\mathit{Init})$ consists of two algorithms $\mathit{Init}$ and $\mathit{Merge}$. Roughly speaking, $\mathit{Init}$ makes an initial partition $g_{1},\dots,g_{s}$ where $s\leq 2n/k+1$, and $\mathit{Merge}$ merges two groups as long as two mergeable groups exist. Specifically, in an execution of $\mathit{Merge}$, all processes of each group $g_{i}$ first agree on choosing one of $g_{i}$’s near groups, say $g_{j}$, as the target, and next check whether $g_{i}$ and $g_{j}$ are mergeable. If $g_{i}$ and $g_{j}$ are mergeable and $g_{j}$ also targets $g_{i}$, then they are merged; if they are not mergeable, the stamp indicating they are not mergeable is generated on the memories of all the processes of $g_{i}$ and $g_{j}$. This stamp removes $g_{j}$ from the set of target candidates of $g_{i}$ in the following executions of $\mathit{Merge}$. However, this stamp is not permanent; it is removed when $g_{i}$ and/or $g_{j}$ merges with another group. This removal is needed because the two groups stamped as unmergeable may become mergeable when one of them is merged to another group. After a finite number of executions of $\mathit{Merge}$, the network reaches a configuration in ${\cal C}_{\mathrm{goal}}(\mathit{Merge},E)$, in which all the groups have stamps for all their near groups. As we shall see later, we assign prior labels to each group so that prior groups have higher priority of becoming targets than non-prior groups. This strategy is to ensure that the number of executions of $\mathit{Merge}$ is bounded by $O(n/k)$.

4.2 Preliminaries

Actions of $\mathit{Init}$ and $\mathit{Merge}$ are given in Tables 4 and 4.4 respectively. By the definition of the composition algorithm, we can use $v.\mathtt{parent}$ (thus $\mathit{Par}(v)$ and $\mathit{Chi}(v)$) obtained from algorithm $\mathrm{BFS}$ in $\mathit{Init}$ and $\mathit{Merge}$, and assume that the network remains in ${\cal L}_{\mathrm{BFS}}$ in what follows. Except for copying variables, each process $v$ has four non-array variables and the following thirteen array variables, as shown in Table 3.3. Every copying variable $\overline{x}$ has the same range as the corresponding variable $x\in O_{Merge}$. In Tables 4 and 4.4, “$v.x\longleftarrow\chi(v)$” means “$v.x\neq\chi(v)\longrightarrow v.x\leftarrow\chi(v)$”, and “$v.x[u]\longleftarrow\chi(v,u)$” means “$\exists u\in v.\mathtt{domain}:v.x[u]\neq f(\chi(v,u))\longrightarrow v.x[u]\leftarrow f(\chi(v,u))$ for all $u\in v.\mathtt{domain}$” where $f(a)=a$ if $a$ belongs to the range of $v.x[u]$; otherwise $f(a)=\bot$ for any $a$. We define $\min\emptyset=\bot$ and $\min S\cup{\bot}=\min S$ for any set $S$.

We denote $l_{v}=v.\overline{\mathtt{group}}$, $N_{v}(u)=\{w\in N_{v}\mid l_{w}=u\}$, $S_{v}=N_{v}(l_{v})$, $g_{v}(u)=\{w\in v.\mathtt{domain}\mid v.\overline{\mathtt{groups}}[w]=u\}$, and $g(u)=\{w\in V\mid w.\overline{\mathtt{group}}=u\}$. Note that the value of these notations are based on copying variables $\overline{\mathtt{group}}$ and $\overline{\mathtt{groups}}$, and the values of $l_{v}$, $N_{v}(u)$, $S_{v}$, $g_{v}(u)$ are computable locally at process $v$ while we use $g(u)$ only in explanations and proofs.

We use three macros $\mathbf{Share}$, $\mathbf{Min}$, and $\mathbf{Distance}$. For $v,u\in V$, array variable $x$, and the function $f^{\prime}$ on the variables of a process, we define $\mathbf{Share}(v,u,x,f^{\prime}(v))=f^{\prime}(v)$ if $v=u$; otherwise $\mathbf{Share}(v,u,x,f^{\prime}(v))=\min\{w.x\mid w\in N_{v},v.\overline{\mathtt{dist}}[u]=w.\overline{\mathtt{dist}}[u]+1\}$. The action “$v.x[u]\longleftarrow\mathbf{Share}(v,u,x,f^{\prime}(v))$” lets every process $v\in V$ stores $f^{\prime}(u)$ on $v.x[u]$ for every $u\in N_{v}^{k+1}$. For example, for every $v\in V$ and $u\in N_{v}^{k+1}$, $v$ eventually has $v.\mathtt{groups}[u]=u.\mathtt{group}$ by action $\mathrm{M}_{\ref{merge:groups}}$ in Table 4.4. For $v\in V$, variable $x\in\mathit{ID}$, and predicate $Q$ on variables of a process, we define $\mathbf{Min}(v,x,Q(v))=\min\{v,w\}$ if $Q(v)$ holds; otherwise $\mathbf{Min}(v,x,Q(v))=w$, where $w=\min\{u.x\mid u\in S_{v},v.\overline{\mathtt{groupD}}[u.x]=u.\overline{\mathtt{groupD}}[u.x]\allowbreak+1\}$. The action “$v.x\longleftarrow\mathbf{Min}(v,x,Q(v))$” lets process $v$ store on $v.x$ the minimum identifier of the processes satisfying $Q$ in its group; $v$ stores $\bot$ on $v.x$ if no process of the group satisfies $Q$. For example, for every $v\in V$ and $u\in N_{v}^{k+1}$, action $\mathrm{M}_{\ref{merge:border}}$ in Table 4.4 lets $v$ store on $v.\mathtt{border}[u]$ the process with the minimum identifier in group $l_{v}$ which neighbors to a process in group $u$, if such a process exists. For $u,v\in V$, array variable $x$, and set $X\subseteq N_{v}$, we define $\mathbf{Distance}(v,u,x,X)=0$ if $u=v$; otherwise $\mathbf{Distance}(v,u,x,X)=1+\min_{w\in X}w.x[u]$. By an abuse of notation, we define $1+\bot=\bot$ throughout the paper. Hence, $\mathbf{Distance}(v,u,x,X)=\bot$ if $v\neq u$ and $X=\emptyset$. This macro is useful to compute some kind of distance between $u$ and $v$. For example, for every $v\in V$ and $u\in S_{v}$, $v$ eventually has $v.\overline{\mathtt{groupD}}[u]=d_{S_{v}}(u,v)$ by action $\mathrm{I}_{\ref{init:groupdist}}$ in Table 4.

4.3 Algorithm $\mathit{Init}$

Algorithm $\mathit{Init}$ creates an initial partition based on the BFS-tree, and computes the values of the variables used in $\mathit{Merge}$, such as $\mathtt{domain}$ and $\mathtt{dist}$. The functions used to describe $\mathit{Init}$ in Table 4 are defined in Table 4. Algorithm $\mathit{Init}$ first computes and stores $N_{v}^{k+1}$ on $v.\mathtt{domain}$ and stores $d(v,u)$ on $v.\mathtt{dist}[u]$ for each $u\in N_{v}^{k+1}$ within $O(k)$ rounds ($\mathrm{I}_{\ref{init:domain}}$ and $\mathrm{I}_{\ref{init:dist}}$). Next, $\mathit{Init}$ gives an initial partition based on heights of processes in the BFS-tree and stores the group identifier on each $v.\mathtt{initGroup}$ ($\mathrm{I}_{\ref{init:height}}$ and $\mathrm{I}_{\ref{init:initgroup}}$). After that, $\mathit{Init}$ initializes five copying variables $\overline{\mathtt{group}}$, $\overline{\mathtt{groups}}$, $\overline{\mathtt{groupD}}$ $\overline{\mathtt{stampON}}$, and $\overline{\mathtt{prior}}$ ($\mathrm{I}_{\ref{init:group}}$, $\mathrm{I}_{\ref{init:groups}}$, $\mathrm{I}_{\ref{init:groupdist}}$, $\mathrm{I}_{\ref{init:stampon}}$, and $\mathrm{I}_{\ref{init:prior}}$). The number of initial groups is at most $2n/k+1$ since every initial group has at least $k/2$ processes, except for the group including the root of the BFS-tree.

We define error-detecting variable $E(v)$ in Table 4. (Ignore $\mathit{StampOK}(v,u)$ before the middle of Section 4.4.) The following two lemmas hold trivially by the definition of ${\cal E}=\bigvee_{v\in V}E(v)$ (in spite of the definition of $\mathit{StampOK}(v,u)$).

Lemma 12**.**

Every maximal execution of $\mathit{Init}$ terminates at a configuration in $\lnot{\cal E}$ within $O(k)$ rounds.

Lemma 13**.**

The number of groups, i.e. $|\{l_{v}\mid v\in V\}|$, is no more than $2n/k+1$ at a configuration in $\lnot{\cal E}$.

4.4 Algorithm $\mathit{Merge}$

Assuming the network remains at configurations in $\lnot{\cal E}$, $\mathit{Merge}$ merges two near groups if mergeable; Otherwise, it stamps them to memorize that they are unmergeable by using three variables $\mathtt{stamp1}$, $\mathtt{stamp2}$, and $\mathtt{stampD}$. The functions used to describe $\mathit{Merge}$ in Table 4.4 are defined in Table 4.4.

A group $g(i)$ is called $g(j)$’s candidate if $g(i)$ is near to $g(j)$ and $j.\overline{\mathtt{stampON}}(i)$ does not hold, and $g(i)$ is said to be prior if $i.\overline{\mathtt{prior}}[i]$ holds; otherwise $g(i)$ is non-prior. Note that, if $g(i)$ is near to $g(j)$, all nodes $v\in g(j)$ agree on their $\overline{\mathtt{stampON}}[i]$ and $\overline{\mathtt{prior}}[i]$, and $v.\overline{\mathtt{prior}}[i]=i.\overline{\mathtt{prior}}[i]$ since we assume that the network stays in $\lnot{\cal E}$.

In actions $\mathrm{M}_{\ref{merge:border}},\dots,\mathrm{M}_{\ref{merge:stamptwo}}$, each group chooses one of its candidates and checks mergeability with it. Specifically, all processes of each group $g(i)$ agree to choose the same group $g(j)$ as their target; $g(j)$ is the prior candidate that has the minimum $j$ if such a candidate exists; otherwise $g(j)$ is the candidate that has the minimum $j$ ($\mathrm{M}_{\ref{merge:border}}$, $\mathrm{M}_{\ref{merge:far}}$, and $\mathrm{M}_{\ref{merge:target}}$). After actions $\mathrm{M}_{\ref{merge:border}},\dots,\mathrm{M}_{\ref{merge:target}}$ converge222We say that actions $A_{1},A_{2},\dots,A_{s}$ converge if none of them is enabled at any process., either $\mathit{Detector}(j,i)$ or $\mathit{Detector}(i,j)$ holds since $j=\mathit{Target}(i)$. In what follows, we assume $\mathit{Detector}(j,i)$ without loss of generality.

Then, action $\mathrm{M}_{\ref{merge:mergedist}}$ leads to $v.\mathtt{mergeD}[u]=d_{g(i)\cup g(j)}(v,u)$ for all $v\in g(j)$ and $u\in g(i)$ (Lemma 15). Let $v_{\mathit{find}}=\min\{v\in g(j)\mid\exists u\in g(i):d_{g(i)\cup g(j)}(v,u)=k+1\}$ and $v_{\mathit{found}}=\min\{u\in g(i)\mid d_{g(i)\cup g(j)}(u,v_{\mathit{find}})=k+1\}$. If $g(i)$ and $g(j)$ are unmergeable, all processes $v\in g(j)$ compute $v_{\mathit{find}}$ using $\mathtt{mergeD}$, and make the stamp such that $(v.\mathtt{stamp1}[i],v.\mathtt{stamp2}[i],v.\mathtt{stampD}[i])=(v_{\mathit{find}},\bot,d_{g(i)\cup g(j)}(v,v_{\mathit{find}}))$, and all processes $u\in g(i)$ make the stamp such that $(u.\mathtt{stamp1}[j],u.\mathtt{stamp2}[j],u.\mathtt{stampD}[j])=(\bot,v_{\mathit{found}},d_{g(i)\cup g(j)}(u,v_{\mathit{find}}))$ ($\mathrm{M}_{\ref{merge:stampone}},\dots,\mathrm{M}_{\ref{merge:stamptwo}}$). If $g(i)$ and $g(j)$ are mergeable, then $v_{\mathit{find}}=\bot$, thus all processes $v\in g(j)$ and $u\in g(i)$ store $\bot$ on $v.\mathtt{stampD}[i]$ and $u.\mathtt{stampD}[j]$ ($\mathrm{M}_{\ref{merge:stampone}}$ and $\mathrm{M}_{\ref{merge:stampdist}}$). Old stamps between two groups $g(i^{\prime})$ and $g(j^{\prime})$ remain when $\mathit{Target}(i^{\prime})\neq j^{\prime}$ and $\mathit{Target}(j^{\prime})\neq i^{\prime}$ hold ($\mathrm{M}_{\ref{merge:stampone}},\dots,\mathrm{M}_{\ref{merge:stamptwo}}$).

After actions $\mathrm{M}_{\ref{merge:border}},\dots,\mathrm{M}_{\ref{merge:stamptwo}}$ converge, two groups $g(i)$ and $g(j)$ merge by $\mathrm{M}_{\ref{merge:group}}$ (i.e. $v.\mathtt{group}=\min\{i,j\}$ for all $v\in g(i)\cup g(j)$) if and only if the two groups are mergeable and they target each other, which can be easily determined from the values of $\mathtt{target}$ and $\mathtt{stampD}$. When a group is not merged, all processes $v$ of the group remain at the same group (*i.e. *we have $v.\mathtt{group}=v.\overline{\mathtt{group}}$). Thereafter, $\mathtt{groups}$ and $\mathtt{groupD}$ are updated by $\mathrm{M}_{\ref{merge:groups}}$ and $\mathrm{M}_{\ref{merge:groupdist}}$. The variable $\mathtt{stampON}$ represents the validity of the stamp. If a group merges with its target, the stamps regarding the group should be removed. Hence, $v.\mathtt{stampON}[u]$ is set to $\mathbf{false}$ not only when $v.\mathtt{stampD}[u]=\bot$ but also when $v$ and/or $u$ merges with some group; otherwise $v.\mathtt{stampON}[u]$ is set to $\mathbf{true}$ ($\mathrm{M}_{\ref{merge:merging}}$ and $\mathrm{M}_{\ref{merge:stampon}}$). Variable $\mathtt{prior}$ is updated by the following simple policy ($\mathrm{M}_{\ref{merge:prior}}$): a non-prior group becomes a prior group when it merges with its target, and a prior group becomes a non-prior group when its $\mathtt{stampON}[i]$ holds for every near group $g(i)$. Thanks to this policy, the number of iterations of $\mathit{Merge}$ is bounded by $O(n/k)$ (Lemma 22).

Now, let us see the definition of $\mathit{StampOK}(v,u)$ in Table 4. Suppose that an execution of $\mathit{Merge}$ terminates at some configuration $\gamma$. Then, it is easily shown that $v.\overline{\mathtt{stampON}}[u]\Rightarrow\mathit{StampOK}(v,u)$ holds for all $v\in V$ and $u\in v.\mathtt{domain}$ in $\gamma^{\mathrm{copy}}$. (See Lemma 20.)

Lemma 14**.**

Consider two groups $g(i)$ and $g(j)$ are near in a configuration $\gamma\in\lnot{\cal E}$. Then, $g(i)$ and $g(j)$ are not mergeable if $v.\overline{\mathtt{stampON}}[j]$ holds for some $v\in g(i)$.

Proof.

Since $\gamma\in\lnot{\cal E}$ holds, (i) all processes $w_{1}\in g(i)$ have a common non-null $v_{\mathit{find}}=w_{1}.\overline{\mathtt{stamp1}}[j]\in g(i)$ and all processes $w_{2}\in g(j)$ have a common non-null $v_{\mathit{found}}=w_{2}.\overline{\mathtt{stamp2}}[i]\in g(j)$, or (ii) all processes $w_{1}\in g(i)$ have a common non-null $v_{\mathit{found}}=w_{1}.\overline{\mathtt{stamp2}}[j]\in g(i)$ and all processes $w_{2}\in g(j)$ have a common non-null $v_{\mathit{find}}=w_{2}.\overline{\mathtt{stamp1}}[i]\allowbreak\in g(j)$. In both cases, $\lnot{\cal E}$ guarantees $d_{g(i)\cup g(j)}(v_{\mathit{find}},v_{\mathit{found}})=k+1$, which means $D(G(g(i)\cup g(j)))\geq k+1$. ∎

Lemma 15**.**

Let $\gamma$ be a configuration in $\lnot{\cal E}$ where $\mathrm{M}_{\ref{merge:border}},\dots,\mathrm{M}_{\ref{merge:mergedist}}$ converges and $j=\mathit{Target}(i)$. In configuration $\gamma$, we have $v.\mathtt{mergeD}[u]=d_{g(i)\cup g(j)}(v,u)$ for all $v\in g(j)$ and $u\in g(i)$.

Proof.

We let $d(v)=d_{g(i)\cup g(j)}(v,u)$ for any fixed $u\in g(i)$. Clearly, $u.\mathtt{mergeD}[u]=d(u)=0$ holds in $\gamma$. Let $w$ be a process of $g(j)\cup g(i)\setminus\{u\}$. We have $w.\mathtt{mergeD}[u]\geq d(w)$ since $w.\mathtt{mergeD}[u]=1+\min\{w^{\prime}.\mathtt{mergeD}[u]\mid w^{\prime}\in N_{w}(i)\cup N_{w}(j)\}$ and $w^{\prime\prime}.\mathtt{mergeD}[u]=0$ only if $w^{\prime\prime}\neq u$. On the other hand, since there exists a path $w,w_{1},w_{2},\dots,u$ of length $d(w)$ in $G(g(i)\cup g(u))$, we have $w.\mathtt{mergeD}[u]\leq 1+w_{1}.\mathtt{mergeD}[u]\leq 2+w_{2}.\mathtt{mergeD}[u]\leq\dots\leq d(w)+u.\mathtt{mergeD}[u]=d(w)$. ∎

Let $x_{i}$ be the variable updated by action $\mathrm{M}_{i}$, and ${\cal G}_{i}(v)$ be the guard for action $\mathrm{M}_{i}$. For example, variable $x_{\ref{merge:group}}$ denotes $\mathtt{group}$ and guard ${\cal G}_{\ref{merge:prior}}(v)$ denotes $\exists u\in v.\mathtt{domain}:v.\mathtt{prior}[u]\neq\mathbf{Share}(v,u,\mathtt{prior},\mathit{Prior}(v))$.

Lemma 16** (Shiftable Convergence).**

Every maximal execution $\varrho=\gamma_{0},\gamma_{1},\dots$ of $\mathit{Merge}$ where $\gamma_{0}\in\lnot{\cal E}$ terminates at configuration $\gamma$ such that $\gamma^{\mathrm{copy}}\in\lnot{\cal E}$, within $O(k)$ rounds.

Proof.

It is guaranteed by Lemma 17, as shown below, that $\varrho$ terminates within $O(k)$ rounds. Hence, it suffices to show $\gamma^{\mathrm{copy}}\in\lnot{\cal E}$ where $\gamma$ is the configuration at which $\varrho$ terminates. Recall that ${\cal E}\equiv\bigvee_{v\in V}E(v)$, and $E(v)$ is defined as follows; Since $\gamma_{0}\in\lnot{\cal E}$ and execution $\varrho$ never updates variables $\mathtt{domain}$, $\mathtt{dist}$, $0pt$, and $\mathtt{initGroup}$, configuration $\gamma^{\mathrm{copy}}$ satisfies $(v.\mathtt{domain}=\mathit{Domain}(v))\wedge(\forall u\in v.\mathtt{domain}:v.\mathtt{dist}[u]=\mathit{Dist}(v,u))\wedge(v.0pt={\it Height\/}(v))\allowbreak\wedge(v.\mathtt{initGroup}=\mathit{InitGroup}(v))$ for any $v\in V$. Since $\varrho$ never assigns different groups to distinct processes in the same group at $\gamma_{0}$, $\gamma^{\mathrm{copy}}$ satisfies $\mathit{GrpOK}(v)$ for any $v\in V$. By Lemmas 18, 19, and 20 shown below, in configuration $\gamma^{\mathrm{copy}}$, we have $\mathit{GrpsOK}(v)$, $\mathit{GrpDistOK}(v)$, and $\forall u\in v.\mathtt{domain}:\allowbreak v.\mathtt{stampON}[u]\Rightarrow\mathit{StampOK}(v,u)$ for any $v\in V$. We also have $\forall u\in N_{v},\forall w\in v.\mathtt{domain}\cap u.\mathtt{domain}:\allowbreak v.\overline{\mathtt{prior}}[w]=u.\overline{\mathtt{prior}}[w]$ for any $v\in V$ in $\gamma^{\mathrm{copy}}$, since $\gamma$ satisfies $v.\mathtt{prior}[u]=\mathbf{Share}(v,u,\mathtt{prior},\mathit{Prior}(v))$ for all $v\in V$ and $u\in v.\mathtt{domain}$. ∎

Lemma 17**.**

Every maximal execution $\varrho=\gamma_{0},\gamma_{1},\dots$ of $\mathit{Merge}$ where $\gamma_{0}\in\lnot{\cal E}$ terminates within $O(k)$ rounds.

Proof.

Guard ${\cal G}_{i}(v)$ is independent from the value of $u.x_{j}$ for any $u\in N_{v}^{1}$ and $j>i$. Hence, in an execution of $\mathit{Merge}$, $v.x_{j}$ is never updated after actions $M_{0},\dots,M_{j}$ converged (i.e. $\forall u\in V,i\in[0,j]:G_{i}(u)=\mathbf{false}$). Therefore, by the description of $\mathit{Merge}$, any action $M_{j}$ converges within $O(k)$ rounds after actions $M_{0},\dots,M_{j-1}$. This proves the lemma. ∎

Lemma 18**.**

If a maximal execution $\varrho=\gamma_{0},\gamma_{1},\dots$ of $\mathit{Merge}$ where $\gamma_{0}\in\lnot{\cal E}$ terminates at configuration $\gamma$, then $\gamma^{\mathrm{copy}}$ satisfies $\mathit{GrpsOK}(v)$ for all $v\in V$.

Proof.

Recall the definition of $\mathit{GrpsOK}(v)$ in Table 4. By that definition, it suffices to show that, in configuration $\gamma$, we have $v.\mathtt{groups}[u]=\mathbf{Share}(v,u,\mathtt{groups},v.\mathtt{group})$ for all $u\in v.\mathtt{domain}$ and $v.\mathtt{groups}[v.\mathtt{group}]=v.\mathtt{group}$. The former condition holds since ${\cal G}_{\ref{merge:groups}}$ holds in $\gamma$. The latter condition holds if $g(l_{v})$ is not merged in execution $\varrho$, since $v.\mathtt{group}=l.\mathtt{group}=l$ holds in $\gamma$. Even if $g(l_{v})$ merges with $g(u)$ in $\varrho$, the latter condition holds since ${\cal G}_{\ref{merge:group}}$ guarantees $v.\mathtt{group}=\min\{l_{v},u\}.\mathtt{group}=\min\{l_{v},u\}$ in $\gamma$. ∎

Lemma 19**.**

If a maximal execution $\varrho=\gamma_{0},\gamma_{1},\dots$ of $\mathit{Merge}$ where $\gamma_{0}\in\lnot{\cal E}$ terminates at configuration $\gamma$, then $\gamma^{\mathrm{copy}}$ satisfies $\mathit{GrpDistOK}(v)$ for all $v\in V$.

Proof.

Recall the definition of $\mathit{GrpDistOK}(v)$ in Table 4. By that definition, it suffices to show that, in configuration $\gamma$, we have $v.\mathtt{groupD}[u]=\mathbf{Distance}(v,u,\{w.\mathtt{groupD}[u]\mid w\in N_{v},w.\mathtt{group}=v.\mathtt{group}\})$ and $v.\mathtt{groupD}[u]\neq k+1$ for all $u\in\{w\in N_{v}\mid w.\mathtt{group}=v.\mathtt{group}\}$. The former condition holds since ${\cal G}_{\ref{merge:groupdist}}$ holds in $\gamma$. The latter condition holds if $g(l_{v})$ is not merged in execution $\varrho$, since $v.\mathtt{groupD}[u]=d_{g(l_{v})}(v,u)\in[0,k]$ holds in $\gamma$. If $g(l_{v})$ merges with some group $g(w)$ in $\varrho$, then $d_{g(l_{v})\cup g(w)}(v,u)\in[0,k]$ holds; otherwise $g(l_{v})$ cannot be merged with $g(w)$. Hence, even if $g(l_{v})$ merges with $g(w)$ in $\varrho$, the latter condition holds since ${\cal G}_{\ref{merge:groupdist}}$ guarantees $v.\mathtt{groupD}[u]=d_{g(l_{v})\cup g(w)}(v,u)\in[0,k]$ in $\gamma$. ∎

Lemma 20**.**

If a maximal execution $\varrho=\gamma_{0},\gamma_{1},\dots$ of $\mathit{Merge}$ where $\gamma_{0}\in\lnot{\cal E}$ terminates at configuration $\gamma$, then $\gamma^{\mathrm{copy}}$ satisfies $v.\overline{\mathtt{stampON}}[u]\Rightarrow\mathit{StampOK}(v,u)$ for all $v\in V$ and $u\in v.\mathtt{domain}$.

Proof.

Recall the definition of $\mathit{StampOK}(v)$ in Table 4. Assuming that $v.\overline{\mathtt{stampON}}[u]$ holds in $\gamma^{\mathrm{copy}}$, we will prove that $\mathit{StampOK}(v,u)$ holds in $\gamma^{\mathrm{copy}}$. Only in this proof, we denote $w_{1}.\mathtt{stamp1}[u]$, $w_{1}.\mathtt{stamp2}[u]$, and $w_{1}.\mathtt{stampD}[u]$ by just $w_{1}.\mathtt{stamp1}$, $w_{1}.\mathtt{stamp2}$, and $w_{1}.\mathtt{stampD}$ for all $w_{1}\in g(l_{v})$, and we denote $w_{2}.\mathtt{stamp1}[l_{v}]$, $w_{2}.\mathtt{stamp2}[l_{v}]$, and $w_{2}.\mathtt{stampD}[l_{v}]$ by just $w_{2}.\mathtt{stamp1}$, $w_{2}.\mathtt{stamp2}$, and $w_{2}.\mathtt{stampD}$ for all $w_{2}\in g(u)$. Since $v.\mathtt{stampON}[u]$ holds in $\gamma$, either $g(l_{v})$ or $g(u)$ never merges in execution $\varrho$, and there exists $v_{\mathit{find}}\in g(l_{v})\cup g(u)$ such that $w.\mathtt{stampD}=d_{g(l_{v})\cup g(u)}(w,v_{\mathit{find}})$ holds for all $w\in g(l_{v})\cup g(u)$. Let $v_{\mathit{found}}=\min\{w\in g(l_{v})\cup g(u)\mid d_{g(l_{v})\cup g(u)}(w,v_{\mathit{find}})=k+1\}$. (Note that $v_{\mathit{found}}\neq\bot$.) In $\gamma$, we have $(w.\mathtt{stamp1},w.\mathtt{stamp2})=(v_{\mathit{find}},\bot)$ for all $w\in g(v_{\mathit{find}}.\overline{\mathtt{group}})$, and $(w.\mathtt{stamp1},w.\mathtt{stamp2})=(\bot,v_{\mathit{found}})$ for all $w\in g(v_{\mathit{found}}.\overline{\mathtt{group}})$. All of these prove that $\mathit{StampOK}(v,u)$ holds. ∎

In the rest of this section, we denote ${\cal C}_{\mathrm{goal}}(\mathit{Merge},E)$ simply by ${\cal C}_{\mathrm{goal}}$.

Lemma 21** (Correctness).**

Every $\gamma\in{\cal C}_{\mathrm{goal}}$ satisfies ${\cal L}_{k}$.

Proof.

Let $V(i)=\{v\in V\mid v.\mathtt{group}=i\}$. In $\gamma\in{\cal C}_{\mathrm{goal}}$, we have (i) $D(g(i))\leq k$ for all $i\in V\ \emph{s.t.}\,\ g(i)\neq\emptyset$, (ii) $\mathit{Cand}(v)=\emptyset$ for all $v\in V$, and (iii) $g(i)=V(i)$ for all $i\in V$. By Lemma 14 and (ii), every $g(i)$ is not mergeable with any other group in $\gamma$. Hence, by (i) and (iii), $\{V(i)\neq\emptyset\mid i\in V\}$ is a minimal partition of $G$ with diameter-bound $k$ in $\gamma$. ∎

Lemma 22** (Loop Convergence).**

Let $\varrho_{0},\varrho_{1}\dots$ be an infinite sequence of maximal executions of $\mathit{Merge}$ where $\varrho_{i}=\gamma_{i,0},\gamma_{i,1},\dots,\gamma_{i,s_{i}}$, $\gamma_{0,0}\in\lnot{\cal E}$, and $\gamma_{i+1,0}=\gamma_{i,s_{i}}^{\mathrm{copy}}$ for $i\geq 0$. Then, $\gamma_{j,s_{j}}\in{\cal C}_{\mathrm{goal}}$ and $R(\varrho_{0})+R(\varrho_{1})+\dots R(\varrho_{j})=O(n)$ hold for some $j=O(n/k)$.

Proof.

We say that a group $g(v)$ is black if $g(v)$ is non-prior and some non-prior group $g(u)$ exists such that $u\in\mathit{Cand}(v)$; otherwise $g(v)$ is white. Note that a black group may become white, but no white group becomes black. We denote the number of groups (i.e. $|\{l_{v}\mid v\in V\}|$), the number of black groups, and the number of prior groups in configuration $\gamma\in\lnot{\cal E}$ by $\#_{g}(\gamma)$, $\#_{b}(\gamma)$, and $\#_{p}(\gamma)$ respectively. We define $\#(\gamma)=2\#_{g}(\gamma)+\#_{p}(\gamma)+\#_{b}(\gamma)$. Note that both $2\#_{g}(\gamma)+\#_{p}(\gamma)$ and $\#_{b}(\gamma)$ are monotonically non-increasing, thus $\#(\gamma)$ is also monotonically non-increasing. The former $2\#_{g}(\gamma)+\#_{p}(\gamma)$ decreases every time any two groups merges. In what follows, we show $\#(\gamma_{i,0})>\#(\gamma_{i+2,0})$ if $\gamma_{i}\notin{\cal C}_{\mathrm{goal}}$. Consider first the case that there exists at least one prior group in $\gamma_{i,0}$. Let $g(j)$ be the group with the minimum $j$ among those prior groups. If $g(j)$ is also the minimum prior group in $\gamma_{i+1,0}$, then $g(j)$ merges with some group or becomes saturated and non-prior in $\varrho_{i}$ or $\varrho_{i+1}$, which gives $\#(\gamma_{i,0})>\#(\gamma_{i+2,0})$. If $g(j)$ is no longer the minimum prior group in $\gamma_{i+1,0}$, some group must merge and become prior in $\varrho_{i}$, hence $\#(\gamma_{i,0})>\#(\gamma_{i+2,0})$ holds. Consider next the case that there exists no prior group in $\gamma_{i,0}$. Let $g(j^{\prime})$ be the group with the minimum $j^{\prime}$ such that $\mathit{Cand}(j^{\prime})\neq\emptyset$ in $\gamma_{i,0}$. By a similar discussion, in $\varrho_{i}$ or $\varrho_{i+1}$, $g(j)$ becomes saturated and non-prior, or some pair of groups merges. In the former case, $\#_{b}(\gamma_{i,0})\leq\#_{b}(\gamma_{i+2,0})$ holds. In the latter case, $2\#_{g}(\gamma_{i,0})+\#_{p}(\gamma_{i,0})\leq 2\#_{g}(\gamma_{i+2,0})+\#_{p}(\gamma_{i+2,0})$ holds. Thus, in any case, $\#(\gamma_{i,0})>\#(\gamma_{i+2,0})$ holds if $\gamma_{i}\notin{\cal C}_{\mathrm{goal}}$. By Lemma 13, $\#(\gamma)\leq 4\#_{g}(\gamma)=O(n/k)$ holds. Hence, we have $\gamma_{j,s_{j}}\in{\cal C}_{\mathrm{goal}}$ for some $j=O(n/k)$, from which $R(\varrho_{0})+R(\varrho_{1})+\dots R(\varrho_{j})=O(n)$ follows because $R(\varrho_{i})=O(k)$ holds for each $i$ by Lemma 16. ∎

Theorem 2**.**

Algorithm $\mathrm{Loop}(\mathit{Merge},E,\mathit{Init})$ is silent self-stabilizing for ${\cal L}_{k}$. Every maximal execution of the algorithm terminates within $O(nD/k)$ rounds. The number of groups it produces, i.e. $|\{v.\mathtt{group}\mid v\in V\}|$, is at most $2n/k+1$. The space complexity per process of $\mathrm{Loop}(\mathit{Merge},E,\mathit{Init})$ is $O((n+n_{\mathit{false}})\log n)$ where $n_{\mathit{false}}$ is the number of identifiers stored in $v.\mathtt{domain}$ for some $v\in V$ in an initial configuration, and which do not match the identifier of any $u\in V$.

Proof.

The first three arguments are proven by Lemmas 1, 12, 13, 16, 21, and 22. The last argument about the space complexity is trivial. ∎

5 Conclusion

We have given a silent self-stabilizing algorithm for the minimal $k$-grouping problem. Given a network $G$ and a diameter-bound $k$, it guarantees that, regardless of an initial configuration, the network reaches a configuration where the diameter of every group is no more than $k$ and no two groups can be merged without violating the diameter-bound. Its time complexity is $O(nD/k)$ and its space complexity per process is $O((n+n_{\mathit{false}})\log n)$. The number of groups it produces is at most $2n/k+1$. A novel composition technique called loop composition is also given and used in our algorithm.