Coding theory for noiseless channels realized by anonymous oblivious mobile robots

TL;DR

This paper introduces a coding scheme for noiseless communication using anonymous, oblivious mobile robots on graphs, analyzing its efficiency and providing algorithms for optimal code size and transmission delay.

Contribution

It presents novel coding algorithms for robot swarms that optimize either code size or transmission delay, with bounds and performance analysis.

Findings

Lower bound of delay depends on swarm size

Code size is exponentially bounded by swarm size

Two algorithms achieve near-optimal and optimal trade-offs

Abstract

We propose an information transmission scheme by a swarm of anonymous oblivious mobile robots on a graph. The swarm of robots travel from a sender vertex to a receiver vertex to transmit a symbol generated at the sender. The codeword for a symbol is a pair of an initial configuration at the sender and a set of terminal configurations at the receiver. The set of such codewords forms a code. We analyze the performance of the proposed scheme in terms of its code size and transmission delay. We first demonstrate that a lower bound of the transmission delay depends on the size of the swarm, and the code size is upper bounded by an exponent of the size of the swarm. We then give two algorithms for a swarm of a fixed size. The first algorithm realizes a near optimal code size with a large transmission delay. The second algorithm realizes an optimal transmission delay with a smaller code size. We then consider information transmission by swarms of different sizes and present upper bounds of the expected swarm size by the two algorithms. We also present lower bounds by Shannon's lemma and noiseless coding theorem.

Equations

$$n_k=2n_{k-1}+n_{k-2},$$

$$n_k-(1-\sqrt{2})n_{k-1}$$

$$n_k-(1+\sqrt{2})n_{k-1}$$

$$n_k=\frac{3+2\sqrt{2}}{2\sqrt{2}}(1+\sqrt{2}{)}^{k-1}-\frac{3-2\sqrt{2}}{2\sqrt{2}}(1-\sqrt{2}{)}^{k-1}.$$

$$|{\mathcal{C}}_I|$$

$$\frac{2k+(18k-252)+5}{2}=10k-\mathrm{123.5.}$$

$$K^{\ast }>\frac{1}{6}H(S)+1-\frac{1}{6}\log \lceil \log \frac{63\alpha +1}{6}\rceil .$$

$$\sum _{i=1}^{\alpha }{q}_i=\sum _{k=1}^{k_{\alpha }}\frac{2^{-6(k-1)}}{k_{\alpha }}{2}^{6(k-1)}\le 1.$$

$$H(S)=-\sum _{i=1}^{\alpha }{p}_i\log p_i$$

$$K^{\ast }$$

$$K^{\ast }>\frac{1}{6}(H(S)-\log \log \alpha ).$$

$$K^{\ast }>0.78H(S)-0.79\log \left(1+0.79\log \alpha \right).$$

$$K_{AL{G}_1}\le \sum _{i=1}^{\alpha }{p}_i({\ell }_i+14)<H(S)+15.$$

$$D_{\gamma }\ge (m+1)K_{\gamma }-2\sum _{i=1}^{\alpha }{k}_i^2{p}_i\ge (m+1-2\alpha )K_{\gamma }.$$

$$\sum _{i=1}^{\alpha }{p}_i{k}_i$$

Full text

Keyword: Mobile robots, information transmission, coding theory.

1 Introduction

Memory is indispensable to a computer system to demonstrate its computation ability. Its importance does not diminish in a distributed system. We thus tend to guess that a distributed system lacking memory can solve no problems but trivial ones. A swarm of anonymous oblivious mobile robots is a distributed system whose components called robots move on a continuous space or a graph. It is typically characterized by the lack of identifiers and common and local memories. Contrary to the quess, in spite of the absence of memory, it has been shown to have rich ability to solve a variety of problems (e.g., [2, 4, 5, 7, 8, 9, 10, 11, 14, 17, 18, 22, 23, 24, 25, 26, 27, 28]). In order to solve those problems, the robots indeed need to “remember” key information to solve a problem such as the current search direction in exploration [2, 8, 13, 14], the currently agreed common coordinate system in pattern formation [18, 24, 25, 28, 27, 26], and the current phase in forming a sequence of patterns [7]. A main idea to make up the lack of memory is to use “external memory” composed of the locations of all robots, i.e., its (global) configuration, and the information that the robots need to remember is embedded in the current configuration. However for the robots to keep external memory stable is by no means easy, and interesting tricks have been developed to realize the idea based on concepts such as the smallest enclosing circle [11, 17, 18, 22, 24, 25, 28], the rotation group [26, 27] and the Fermat point [4]. Proposing a suitable external memory is thus considered to be a key in the design of algorithm for a swarm of anonymous oblivious mobile robots.

This paper investigates an information transmission problem on a graph, which asks an algorithm to transmit information from a sender to a receiver by using a swarm of anonymous oblivious mobile robots moving on the graph, and analyzes the bounds on the amount of information that the swarm of robots can carry in its external memory and the transmission delay.

Let $G=(V,E)$ be a connected undirected (possibly infinite) graph with two distinguished vertices $u_{S}$ and $u_{R}$ called the sender and the receiver, respectively. We want to transmit a symbol $s$ in $S=\{s_{1},s_{2},\ldots,s_{\alpha}\}$ from $u_{S}$ to $u_{R}$ by using a swarm of anonymous oblivious mobile robots on $G$, where the probability that $s=s_{i}$ is $p_{i}$. Sometimes we assume that the distance between $u_{S}$ and $u_{R}$ is sufficiently larger than $\alpha$ and/or the number $k$ of the robots to reduce possible disturbance caused by boundary conditions in analyses.

Each vertex of $G$ can accommodate at most one robot of the swarm. Thus the configuration of the swarm is represented by a subset $U$ of $V$. Any configuration of the swarm must be connected; ${\cal C}=\{U\mid G[U]\text{ is connected}\}$ denotes the set of all connected configurations, where $G[U]$ is the subgraph of $G$ induced by $U$. When the current configuration is $C$, a robot $r$ at $u\in C$ can move to one of its neighbors $v\not\in C$ if the next configuration $(C\setminus\{u\})\cup\{v\}$ is also connected. At most one robot can move at one time step. The behavior of the swarm of robots is determined by a deterministic algorithm, which specifies the next configuration by choosing a robot to move and its destination. The input of the algorithm is the current configuration. Thus the behavior of the swarm is always deterministic. A configuration $C$ is said to be initial (resp. terminal) if $u_{S}\in C$ (resp. $u_{R}\in C$). The sets ${\cal C}_{I}=\{C\in{\cal C}\mid u_{S}\in C\}$ and ${\cal C}_{T}=\{C\in{\cal C}\mid u_{R}\in C\}$ denote the sets of initial and terminal configurations, respectively.

Let ${\cal A}=\{A_{k}\mid k=1,2,\ldots\}$ be a set of algorithms, where $A_{k}$ is an algorithm for the swarm of $k$ robots. For an initial configuration $C_{0}\in{\cal C}_{I}$, where $|C|=k$, the behavior $C_{0},C_{1},\ldots$ of the swarm of $k$ robots under $A_{k}$ may eventually reach $C_{d}\in{\cal C}_{T}$ for the first time. In this case we define that $\tau(C_{0})=C_{d}$ and the transmission delay is $d$. Otherwise, $\tau(C_{0})=\bot$. Suppose that there are $\alpha$ initial configurations $C_{0}^{1},C_{0}^{2},\ldots,C_{0}^{\alpha}$ such that $\tau(C_{0}^{i})\not=\bot$ for $i=1,2,\ldots,\alpha$ and $\tau(C_{0}^{i})\not=\tau(C_{0}^{j})$ for all $1\leq i<j\leq\alpha$. Assuming that both $u_{S}$ and $u_{R}$ are accessible to the list of pairs $(C_{0}^{i},\tau(C_{i}^{0}))$ for $i=1,2,\ldots,\alpha$, we can transmit a symbol $s_{i}\in S$ as follows:

The sender initializes the swarm of $k_{i}$ robots by moving the robots to the vertices in $C_{0}^{i}$ and starts algorithm $A_{k_{i}}$, where $k_{i}=|C_{0}^{i}|$. 2. 2.

The receiver recognizes $\tau(C_{0}^{i})$ when a robot reaches $u_{R}$, and knows that the sender transmitted $s_{i}$.

Here we assume that the sender has a bag of infinitely many robots and can initialize the swarm of any number of robots, and the receiver recognizes $\tau(C_{0}^{i})$ as soon as a robot reaches $u_{R}$. In this paper, we fix this information transmission scheme and analyze its performance.

Given a set of algorithms $\cal A$, the performance of the scheme mainly depends on the selection of an initial configuration $C_{0}^{i}$ for each $s_{i}$. A simple approach is to choose configurations with the same size $k$. That is, $k_{i}=k$ for all $i=1,2,\ldots,\alpha$. We first investigate this approach. Let $\mu_{A_{k}}$ be the maximum number such that there are $\mu_{A_{k}}$ initial configurations $C_{0}^{1},C_{0}^{2},\ldots,C_{0}^{\mu_{A_{k}}}$ with size $k$ satisfying $\tau(C_{0}^{i})\not=\tau(C_{0}^{j})$ for all $1\leq i<j\leq\mu_{A_{k}}$. Then we are interested in upper and lower bounds on $\mu_{A_{k}}$ and $\mu_{k}$, where $\mu_{k}=\max_{A_{k}}\mu_{A_{k}}$ denotes the maximum amount of information that the swarm of $k$ robots can carry in external memory under this information transmission scheme.

However, assigning all symbols to initial configurations with the same size is not always a good approach from the view of transmission delay, since the value of $k_{0}$ that satisfies $\mu_{k_{0}}\geq\alpha$ can be large and, as we will show later, the transmission delay is roughly greater than $dist(u_{S},u_{R})k_{0}$ where $dist(u_{S},u_{R})$ is the distance between $u_{S}$ and $u_{R}$ (i.e., the number of edges in the shortest path connecting them). Let $k_{i}$ be the size of $C_{0}^{i}$ assigned to $s_{i}$ for $i=1,2,\ldots,\alpha$. Then we are interested in upper and lower bounds on the average size $K^{*}=\sum_{i=1}^{\alpha}p_{i}k_{i}$, since there is a chance that $K^{*}<k_{0}$ holds for some $\cal A$. The reduction of $K^{*}$ contributes to the reduction of energy, as well as the reduction of transmission delay, whose lower bound is roughly estimated by $dist(u_{S},u_{R})K^{*}$. However, its upper bound still heavily depends on $\cal A$.

We mainly investigate information transmission on 8-grids $G_{8}(m,n)=({\mathbb{Z}}_{m,n}^{2},N_{8})$, where ${\mathbb{Z}}_{m,n}^{2}=\{(i,j)\in{\mathbb{Z}}\times{\mathbb{Z}}\mid 0\leq i\leq m-1,0\leq j\leq n-1\}$ and $N_{8}=\{((i,j),(i^{\prime},j^{\prime})\in{\mathbb{Z}}_{m,n}^{2}\times{\mathbb{Z}}_{m,n}^{2}:(|i-i^{\prime}|\leq 1)\wedge(|j-j^{\prime}|)\leq 1)\wedge((i,j)\not=(i^{\prime},j^{\prime}))\}$.

**Our contributions. ** Our contributions can be summarized as follows:

We present exponential upper bounds of $\mu_{k}$ on general graphs and 8-grids. 2. 2.

Focusing on “narrow” channel realized by $G_{8}(m,2)$, we present two algorithms that promises exponential code size to a fixed swarm size $k$. The first algorithm promises a near optimal code size $2^{k-14}$, but has a large transmission delay. The second algorithm promises a near optimal transmission delay, but has a smaller code size $2^{\lfloor k/2\rfloor}$. 3. 3.

We step into the second approach with these two algorithms and show upper bounds of the expected swarm size. 4. 4.

We finally analyze lower bounds of the expected swarm size based on the Shannon’s lemma and noiseless coding theory.

**Related works. ** Study of information transmission by a binary (or $q$-ary) code is a main stream in computer science known as information theory (or coding theory). It is a fully developed research area, and there are many standard textbooks (e.g., [6]). One can notice the similarity between the first approach and the equal-length coding, and the second one and the variable-length coding. Our results are also related with Shannon’s source coding theorem, which relates the optimal average code length with the entropy of the information source.

Information transmission on a graph by a swarm of anonymous oblivious mobile robots has not been investigated to the best of our knowledge although, including a swarm of mobile robots, distributed systems consisting of mobile entities have been extensively investigated in the last couple of decades. Two survey books [15, 16] include their models and algorithms to solve typical problems such as gathering and convergence [4, 23, 24], pattern formation [11, 17, 18, 24, 25, 27, 28], scattering and covering [5, 10, 20, 21], flocking and marching [1, 3, 19, 29], and searching and exploration [2, 8, 13, 14].

A main theme in these studies is to solve the problems without using memory, partly motivated by a challenge to prejudice that those systems cannot solve non-trivial problems and partly because memoryless algorithms are usually strong against transient failures [12]. For example, exploration of a finite square grid by a metamorphic robot of size 5 is proposed [13]. The metamorphic robot consists of $5$ anonymous oblivious mobile robots (called modules in the literature) and remembers the current search direction (i.e., right, left, up or down) in its configuration during the exploration. In the existing pattern formation algorithms for anonymous oblivious mobile robots, in order to control the move order among the anonymous robots, they agree on a common coordinate system and remember it in external memory [11, 17, 18, 24, 25, 27]. In each of the oblivious algorithms one can find a trick to maintain external memory.

**Organization of the paper. ** We define the swarm of anonymous oblivious robots on a graph and formalize the noiseless communication channel realized by the swarm with an algorithm in Section 2. Section 3 first presents an upper bound of $\mu_{G_{8}(m,n),k}$. Then, we present two algorithms for information transmission by a swarm of fixed size. We consider the second approach in Section 4 with the two algorithms and present lower and upper bounds of the expected swarm size. We conclude this paper with Section 5 which also includes future directions and open problems.

2 Preliminaries

2.1 Swarm of anonymous oblivious mobile robots

Let $G=(V,E)$ be a simple connected undirected graph. For $u\in V$, $N_{G}(u)$ denotes the set of neighbors of $u$ in $G$, and for a subset $U\subseteq V$, $G[U]$ denotes the subgraph of $G$ induced by $U$. For two vertices $u,v\in V$, $dist_{G}(u,v)$ denotes the distance between $u$ and $v$. We define two infinite regular graphs. Let ${\mathbb{Z}}$ be the set of integers. The $4$-grid is an infinite graph $G_{4}=({\mathbb{Z}}^{2},N_{4})$, where $N_{4}=\{((i,j),(i^{\prime},j^{\prime}))\in{\mathbb{Z}}^{2}\times{\mathbb{Z}}^{2}\mid((i=i^{\prime})\wedge(|j-j^{\prime}|=1))\vee((|i-i^{\prime}|=1)\wedge(j=j^{\prime}))\}$ and the $8$-grid is an infinite graph $G_{8}=({\mathbb{Z}}^{2},N_{8})$, where $N_{8}=\{((i,j),(i^{\prime}.j^{\prime}))\in{\mathbb{Z}}^{2}\times{\mathbb{Z}}^{2}\mid(|i-i^{\prime}|\leq 1)\wedge(|j-j^{\prime}|\leq 1)\wedge((i,j)\not=(i^{\prime},j^{\prime}))\}$.

We consider a swarm $R=\{r_{1},r_{2},\ldots,r_{k}\}$ of anonymous oblivious mobile robots on $G$. We use the indices just for description since a robot is anonymous. A robot is oblivious, which means that it does not have memory to remember information obtained in the past. A vertex of $G$ can accommodate at most one robot at each time step, and the set of vertices $C\subseteq V$ that accommodate robots is called the configuration of $R$. We say that a configuration $C$ is connected if $G[C]$ is connected. A robot $r$ at $u\in V$ can move to a vertex $v\in N_{G}(u)\setminus C$ through edge $(u,v)$ if the new configuration $C(u;v)=(C\setminus\{u\})\cup\{v\}$ obtained by this movement of $r$ is connected. In what follows, we always assume that a configuration means a connected one. By ${\cal C}$ we denote the set of (connected) configurations $C$.

Each robot $r\in R$ knows $G$ and is aware of the vertex $u$ it resides. It repeats a Look-Compute-Move cycle once initialized. In each Look-Compute-Move cycle, it first observes the positions of other robots on $G$ in Look phase. The visibility range is finite, but is large enough to observe all the robots, so that $r_{i}$ recognizes the current configuration $C$. In Compute phase, given $C$ and $u$ as inputs, a common deterministic algorithm $A$ (on $r$) computes its next position $v$ in such a way that $C(u;v)$ is connected, where $v=u$ is possible and it means to stay at $u$. In this paper, we assume that $A$ outputs $v=u$ on all robots $r$ but one.111 Since all robots know $G$ and $C$, $A$ on all robots can choose the same vertex $u\in C$ to move the robot at $u$ to a different vertex $v\in N_{G}(u)\setminus C$. Algorithm $A$ may output $v=u$ on all robots $r$. Finally, it moves to $v$ through $(u,v)$ in Move phase. Observe that an oblivious robot which does not have memory (except the input buffer of $A$ for $C$ and $u$, and the work space for $A$) can execute $A$.

We consider discrete time $0,1,2,\cdots$. Given an algorithm $A$ and an initial configuration $C_{0}\in{\cal C}_{k}$, all robots are initialized at time [math], and synchronously execute a Look-Compute-Move cycle in each time step. Then $A$ chooses a single robot $r$ at a vertex $u\in C_{0}$ and moves it to one of its neighbors $v$ to yield a configuration $C_{1}=C_{0}(u;v)$ at time 1. The swarm of robots repeats this process and yields configurations $C_{2},C_{3},\ldots$. We call the evolution of configurations, i.e., ${\mathcal{B}}=C_{0},C_{1},C_{2},\ldots$, the behavior of algorithm $A$ from an initial configuration $C_{0}$. Since $A$ is deterministic, ${\mathcal{B}}$ from $C_{0}$ under $A$ is uniquely determined.

2.2 Graph as a noiseless communication channel

We investigate information transmission from the sender $u_{S}\in V$ to the receiver $u_{R}\in V$ by a swarm of robots, i.e., we regard $G$ as a communication channel. The sender $u_{S}$ is a memoryless information source that generates a symbol in $S=\{s_{1},s_{2},\ldots,s_{\alpha}\}$, where $s_{i}$ is generated with probability $\mathrm{P}(s_{i})=p_{i}$ for each $i=1,2,\ldots,\alpha$. Thus $\sum_{i=1}^{\alpha}p_{i}=1$. Let ${\cal C}_{I}$ be the set of configurations that contain $u_{S}$ and ${\cal C}_{T}$ be the set of configurations that contains $u_{R}$. With each symbol $s_{i}$, we associate a configuration $\gamma_{I}(s_{i})\in{\cal C}_{I}$ and a set of configurations $\gamma_{T}(s_{i})\subseteq{\cal C}_{T}$, and regard the pair $(\gamma_{I}(s_{i}),\gamma_{T}(s_{i}))$ as the codeword of $s_{i}$. Here $\gamma_{I}(s_{i})\neq\gamma_{I}(s_{j})$ and $\gamma_{T}(s_{i})\cap\gamma_{T}(s_{j})=\emptyset$, for any $i\neq j$. To send $s_{i}$ from $u_{S}$, as explained in Section 1, $R$ is initialized with $\gamma_{I}(s_{i})$ at $u_{S}$. When a configuration $C_{d}$ of $R$ in $\gamma_{T}(s_{i})$ is reached, $u_{R}\in C_{d}$ receives $s_{i}$. We call the pair $\gamma=\langle\gamma_{I},\gamma_{T}\rangle$ code of $S$, and $|\gamma|$, which is the size of $\gamma$, is the size $\alpha$ of $S$.

Now we consider a coding scheme with an algorithm $A$. Let ${\mathcal{B}}=C_{0},C_{1},\ldots$ be a behavior of $R$ under $A$. We define a function $\tau_{A}:{\cal C}_{I}\to{\cal C}_{T}\cup\{\bot\}$ as follows: If ${\mathcal{B}}$ eventually reaches a configuration $C_{d}\in{\cal C}_{T}$ for the first time, then $\tau_{A}(C_{0})=C_{d}$. We call $d$ the transmission delay. Otherwise, if ${\mathcal{B}}$ does not reach a configuration in ${\mathcal{C}}_{T}$ forever, then $\tau_{A}(C_{0})=\bot$. We say algorithm $A$ realizes code $\gamma$ if $\tau_{A}(\gamma_{I}(s_{i}))\in\gamma_{T}(s_{i})$ for each $i=1,2,\ldots,|\gamma|$. Let $\mu_{A}=|\{\tau_{A}(C)\mid C\in{\mathcal{C}}_{I}\}\setminus\{\bot\}|$.

Theorem 1

Let $A$ be any algorithm.

There is a code $\gamma$ with $|\gamma|=\mu_{A}$ which is realizable by $A$. 2. 2.

There is no code $\gamma$ with $|\gamma|=\mu_{A}+1$ which is realizable by $A$.

Proof.

As for $1$, we construct a code $\gamma^{A}=\langle\gamma_{I}^{A},\gamma_{T}^{A}\rangle$ with $|\gamma^{A}|=\mu_{A}$ realizable by $A$ as follows: Let $S_{\mu_{A}}=\{s_{1},s_{2},\ldots,s_{\mu_{A}}\}$. By definition, there are $\mu_{A}$ configurations $C_{0}^{1},C_{0}^{2},\ldots,C_{0}^{\mu_{A}}$ in ${\mathcal{C}}_{I}$ such that $\tau_{A}(C_{0}^{i})\not=\bot$ for all $i=1,2,\ldots,\mu_{A}$ and $\tau_{A}(C_{0}^{i})\not=\tau_{A}(C_{0}^{j})$ for all $1\leq i<j\leq\mu_{A}$. We then define $\gamma_{I}^{A}(s_{i})=C_{0}^{i}$ and $\gamma_{T}^{A}(s_{i})=\{\tau_{A}(C_{0}^{i})\}$ for $i=1,2,\ldots,\mu_{A}$. It is easy to observe that $\gamma^{A}$ is indeed a code of size $\mu_{A}$.

As for $2$, suppose that there exists a code $\gamma=\langle\gamma_{I},\gamma_{T}\rangle$ with $|\gamma|=\mu_{A}+1$ to derive a contradiction. Since $|\gamma|=\mu_{A}+1>\mu_{A}$, there are two symbols $s_{i}$ and $s_{j}(\neq s_{i})$ such that $\tau_{A}(\gamma_{I}(s_{i}))=\tau_{A}(\gamma_{I}(s_{j}))$, a contradiction. ∎

The proof of Theorem 1 gives a construction method to construct code $\gamma^{A}$ from algorithm $A$. The transmission delay of $\gamma^{A}$ depends on the choice of $\gamma_{I}^{A}(s_{i})\in{\mathcal{C}}_{I}$ for each $s_{i}\in S_{\mu_{A}}$; any $C$ such that $\tau_{A}(C)=\tau_{A}(\gamma_{I}^{A}(s_{i}))$ can be chosen instead. Let $d_{A}(C)$ be the transmission delay of the behavior of $R$ starting from $C$ under $A$. To reduce the transmission delay of $\gamma^{A}$, it is natural to choose an initial configuration $C$ that minimizes $d_{A}(C)$, and we thus assume that such a $C$ is chosen in the construction of $\gamma^{A}$. Then the transmission delay $d_{\gamma^{A}}$ of $\gamma^{A}$ is ${\displaystyle\max_{s_{i}\in S_{\mu_{A}}}d_{A}(\gamma_{I}^{A}(s_{i}))}$. We are interested in the maximization of $\mu_{A}$ and the minimization of $d_{A}$. Let ${\displaystyle\mu_{N,k}=\max_{A}\mu_{A}}$ and ${\displaystyle d_{N,k}=\min_{A}d_{A}}$, where ${\displaystyle d_{A}=\max_{C:\tau_{A}(C)\neq\bot}d_{A}(C)}$ and $N=\langle G,u_{S},u_{R}\rangle$.

2.3 General graphs

Since $\mu_{N,1}=1$, we assume $k\geq 2$ in what follows. We also assume $dist_{G}(u_{S},u_{R})\geq k$, i.e., ${\mathcal{C}}_{I}\cap{\mathcal{C}}_{T}=\emptyset$. Indeed we are interested in the case where $dist_{G}(u_{S},u_{R})\gg k$.

Observation 2

For any $N=\langle G,u_{S},u_{R}\rangle$, $\mu_{N,k}\leq|{\mathcal{C}}_{I}|$.

Theorem 3

Let $N=\langle G,u_{S},u_{R}\rangle$ with $dist_{G}(u_{S},u_{R})\geq k$. If $G$ has a cut vertex whose removal disconnects $u_{S}$ and $u_{R}$, then $\mu_{N,k}=0$, that is, $\tau_{A}(C_{0})=\bot$ for any algorithm $A$ and any configuration $C_{0}\in{\mathcal{C}}_{I}$.

Proof.

To derive a contradiction, we assume that there is an algorithm $A$ and a configuration $C_{0}\in{\mathcal{C}}_{T}$ such that the behavior ${\mathcal{B}}=C_{0},C_{1},\ldots$ of $R$ under $A$ eventually reaches a configuration $C_{d}\in{\mathcal{C}}_{T}$. Let $v\in V$ be a cut vertex of $G$ whose removal from $G$ disconnects $u_{S}$ and $u_{R}$. Thus $G[V\setminus\{v\}]$ consists of more than one connected components. Let $G_{1}=(V_{1}\setminus\{v\},E_{1})$ be the one that contains $u_{S}$. We first assume $C_{0}\subseteq V_{1}$. Let $t$ be the smallest index such that $C_{t}\subseteq V_{1}$ and $C_{t+1}\not\subseteq V_{1}$. Then there is a vertex $w\in V\setminus V_{1}$ such that $w\in C_{t+1}$ and $(v,w)\in E$, and the robot at $v$ at $t$ moves to $w$. It is a contradiction since $v\not\in C_{t+1}$ and hence $C_{t+1}$ is not connected.

Next assume that $C_{0}\not\subseteq V_{1}$. Since $dist_{G}(u_{S},u_{R})\geq k$, there is a time instant $t$ such that the robot $r$ at $v$ moves for the first time. Then $C_{t+1}$ is not connected since $v\not\in C_{t+1}$, and a contradiction is derived. ∎

Theorem 4

Let $N=\langle G_{4},u_{S},u_{R}\rangle$ with $dist_{G_{4}}(u_{S},u_{R})\geq k$. Then $\mu_{N,k}=0$, that is, for any algorithm $A$ and for any configuration $C_{0}\in{\mathcal{C}}_{I}$, $\tau_{A}(C_{0})=\bot$.

Proof.

To derive a contradiction, we assume that there is an algorithm $A$ and a configuration $C_{0}\in{\mathcal{C}}_{I}$ such that the behavior $B=C_{0},C_{1},\ldots$ of $R$ under $A$ eventually reaches a configuration $C_{d}\in{\mathcal{C}}_{T}$. Since $dist_{G}(u_{S},u_{R})\geq k$, $d\geq 1$ and $|i_{R}-i_{S}|+|j_{R}-j_{S}|\geq k$, where $u_{S}=(i_{S},j_{S})$ and $u_{R}=(i_{R},j_{R})$. We assume without loss of generality that $i_{R}>i_{S}$ and $j_{R}\geq j_{S}$.

For configuration $C_{t}$, let $x_{\max}(t)=\max\{i\mid(i,j)\in C_{t}\}$ and $y_{\max}=\max\{j\mid(i,j)\in C_{t}\}$. If $x_{\max}(0)\geq i_{R}$, then $j_{S}\leq y_{\max}<j_{R}$. Thus either $i_{S}\leq x_{\max}(0)<i_{R}$ or $j_{S}\leq y_{\max}(0)<j_{R}$ holds. We assume without loss of generality that $i_{S}\leq x_{\max}<i_{R}$.

Let $t$ be the smallest index such that $x_{\max}(0)+1=x_{\max}(t)$ holds. That is, $x_{\max}(t-1)=x_{\max}(0)$. Suppose that the robot $r$ at vertex $u\in C_{t-1}$ moves. Then $C_{t}$ is not connected, since $r$ is the only robot with $x$-coordinate $x_{max}(0)+1$ in $C_{t}$ and $u\not\in C_{t}$. ∎

Theorem 5

Let $G$ be a finite graph and $N=\langle G,u_{S},u_{R}\rangle$. Then, $\mu_{N,k}$ and $d_{N,k}$ are computable.

Proof.

We consider the transition diagram (i.e., directed graph) $X=({\mathcal{C}}\cup\{v_{S},v_{R}\},F)$ of the swarm on $G$, where $(C,C^{\prime})\in F$ if and only if 1) there are $u\in C$ and $v\in C^{\prime}$ such that $C^{\prime}=C(u;v)$, 2) $C=v_{S}$ and $C^{\prime}\in{\mathcal{C}}_{I}$, or 3) $C\in{\mathcal{C}}_{T}$ and $C^{\prime}=v_{R}$. Then $\mu_{N,k}$ is the size of the maxflow of $X$ from $v_{S}$ to $v_{R}$.

As for $d_{N,k}$, there are only a finite number of different sets $\Pi$ of $\mu_{N,k}$ disjoint paths connecting $v_{S}$ and $v_{R}$. By comparing the length of the longest path in each $\Pi$, we can calculate $d_{N,k}$. ∎

By Theorem 5, we can design an optimal algorithm $A$ to achieve $\mu_{N,k}$ such that $A$ makes $R$ follow one of the $\mu_{N,k}$ disjoint paths connecting $v_{S}$ and $v_{R}$. Although an optimal $A$ exists, for a general $N$, it is in generally hard to explicitly describe $A$ and to estimate $\mu_{N,k}$ or $d_{N,k}$. However, we have the following rather obvious upper bound of $d_{N,k}$ when the distance between $u_{S}$ and $u_{R}$ is large.

Theorem 6

Let $G$ be a finite graph and $N=\langle G,u_{S},u_{R}\rangle$, where $dist_{G}(u_{S},u_{R})\geq 2k-1$ and $C_{0}\cap C_{d}=\emptyset$ for any $C_{0}\in{\cal C}_{I}$ and $C_{d}\in{\cal C}_{T}$. Then $d_{N,k}\geq k(dist_{G}(u_{S},u_{R})-2(k-1))$.

Proof.

For any algorithm $A$, let ${\mathcal{B}}=C_{0},C_{1},C_{2},\ldots$ be the behavior from any initial configuration $C_{0}\in{\mathcal{C}}_{I}$ under $A$. We assume that ${\mathcal{B}}$ eventually reaches a configuration $C_{d}\in{\mathcal{C}}_{T}$. For each robot $r_{i}\in R$, let $x_{i}$ and $y_{i}$ be the vertices that it resides at time 0 and $d$, respectively. Thus $x_{i}\in C_{0}$ and $y_{i}\in C_{d}$. Obviously $dist_{G}(u_{S},x_{i})\leq k-1$ and $dist_{G}(u_{R},y_{i})\leq k-1$. Hence each robot moves at least $dist_{G}(u_{S},u_{R})-2(k-1)$ until time $d$, which implies that $d_{A}(C_{0})\geq k(dist_{G}(u_{S},u_{R})-2(k-1))$. ∎

The general policy to construct a code with a small transmission delay is to use a swarm with a small number of robots.

3 Finite 8-grids

We investigate $8$-grids in the rest of this paper. Let ${\mathbb{Z}}_{m,n}^{2}=\{(i,j)\in{\mathbb{Z}}\times{\mathbb{Z}}\mid 0\leq i\leq m-1,0\leq j\leq n-1\}$ and $G_{8}(m,n)=G_{8}[{\mathbb{Z}}_{m,n}^{2}]$. Clearly, $\mu_{\langle G_{8}(m,1),u_{S},u_{R}\rangle,k}=0$ and $d_{\langle G_{8}(m,1),u_{S},u_{R}\rangle,k}=\infty$ for any $m>k\geq 2$. We illustrate a swarm in a 2D square grid instead of $G_{8}(m,n)$. Each cell of the square grid is associated with the underlying $x$-$y$ coordinate system and each vertex $(i,j)\in G_{8}(m,n)$ corresponds to cell $(i,j)$. Hence $N_{G_{8}(m,n)}((i,j))$ corresponds to the eight adjacent cells, i.e., $(i+1,j),(i+1,j+1),(i,j+1),(i-1,j+1),(i-1,j),(i-1,j-1),(i,j-1),(i+1,j-1)$. We call the cells $\{(i,j)\mid i=0,1,2,\ldots,m-1\}$ the $j$th row and the cells $\{(i,j)\mid j=0,1,2,\ldots,n-1\}$ the $i$th column. For the sake of simplicity, we assume $u_{S}=(0,0)$ and $u_{R}=(m-1,0)$.

3.1 Upper bound of $\mu_{G_{8}(m,n),k}$

We derive an upper bound of $\mu_{(G_{8}(m,n),k)}$ by estimating the size $|{\mathcal{C}}_{I}|$ of initial configurations by Observation 2. Since $u_{S}$ and $u_{R}$ are fixed when $G_{8}(m,n)$ is given, instead of $N=\langle G_{8}(m,n),u_{S},u_{R}\rangle$, we omit $u_{S}$ and $u_{R}$ to denote $\mu_{G_{8}(m,n),k}$.

Lemma 7

*For any $u_{S}$ and $u_{R}$, the number of initial configurations of $G_{8}$ is at most $2^{6(k-1)}$. *

Proof.

Let $C\in{\mathcal{C}}_{I}$ be any initial configuration. Consider the depth first traversal of an arbitrary spanning tree of $G[C]$ rooted at $u_{S}$. The track is represented by a sequence of the eight types of movements, $(+1,0)$, $(+1,+1)$, $(0,+1)$, $(-1,+1)$, $(-1,0)$, $(-1,-1)$, $(0,-1)$, and $(+1,-1)$. Thus any configuration $C\in{\mathcal{C}}_{I}$ is represented by a sequence of movements whose length is $2(k-1)$. Hence $|{\mathcal{C}}_{I}|<8^{2(k-1)}=2^{6(k-1)}$. ∎

Corollary 8

For any $m,n\geq 1$, $\mu_{G_{8}(m,n),k}\leq 2^{6(k-1)}$.

Proof.

The number of initial configurations in $G_{8}(m,n)$ is obviously not greater than that of $N=\langle G_{8},u_{S},u_{R}\rangle$. ∎

When $n=2$, we can obtain a better bound of $\mu_{G_{8}(m,2),k}$. A trivial upper bound of $\mu_{G_{8}(m,2),k}$ is $3^{k}$, since $|{\mathcal{C}}_{I}|\leq 3^{k}$ and each column of any initial configuration in ${\mathcal{C}}_{I}$ must contain at least one robot to keep the connectivity.

Lemma 9

If $m\geq k$, $\mu_{G_{8}(m,2)}<(1+\sqrt{2})^{k}$.

Proof.

Recall that $u_{S}=(0,0)$ and $u_{R}=(m-1,0)$. Let ${\mathcal{C}}_{I}$ be the set of initial configurations of the swarm of $k$ robots on $G_{8}(m,2)$. There are two types of configurations in ${\mathcal{C}}_{I}$:

The set of configurations $C\in{\mathcal{C}}_{I}$ such that $(0,1)\not\in C$. 2. 2.

The set of configurations $C\in{\mathcal{C}}_{I}$ such that $(0,1)\in C$.

Note that $(0,0)\in C$ for any $C\in{\mathcal{C}}_{I}$ by definition. Let $n_{k}$ be the number of configurations such that the [math]th column contains at least one robot. Such a configuration may not contain $(0,0)$. We have the following recurrence formula:

[TABLE]

with $n_{1}=2$ and $n_{2}=5$. We can calculate the general term $n_{k}$ using a standard method. Since the two roots of equation $x^{2}-2x-1=0$ are $1\pm\sqrt{2}$, we have two equations

[TABLE]

Thus

[TABLE]

Since $|{\mathcal{C}}_{I}|=n_{k-1}+n_{k-2}$,

[TABLE]

∎

3.2 Lower bound of $\mu_{G_{8},k}$

We present an algorithm $ALG_{1}$ on $G_{8}(m,2)$ by which we can construct a code $\gamma$ with size $|\gamma|=2^{k-14}$. Thus $2^{k-14}\leq\mu_{G_{8}(m,2),k}\leq\mu_{G_{8}(m,n),k}\leq\mu_{\langle G_{8},u_{S},u_{R}\rangle,k}$ hold for any $n\geq 2$. Referring to Lemma 9, $ALG_{1}$ produces a code with a near optimal code size $2^{k-14}$. However, the transmission delay of the code is not so good. We hence propose another algorithm $ALG_{2}$ by which we can produce a code with an optimal transmission delay, in the next subsection, although its code size is small and $2^{\lfloor k/2\rfloor}$.

Algorithm $ALG_{1}$ divides the swarm into a codeword and a controller. Roughly, the codeword is external memory to remember the codeword of the symbol transmitted, and the controller, which is placed following the codeword, is used to keep the external memory stable. The controller consists of $14$ robots, which is further divided into a buffer consisting of four robots, a temporal memory consisting of five robots, a signal consisting of one robot, and a counter consisting of four robots.

In the canonical state, the configuration $C$ contains exactly one robot at each column as illustrated in Figure 1. Algorithm $ALG_{1}$ shifts $C$ right by two (not one) columns. Suppose that the leftmost cell of $C$ is in the column $i_{s}$. Then the rightmost cell is in the column ($i_{s}+k-1$). The leftmost $(k-14)$ robots in $C$ represents the symbol it is transmitting. We can thus transmit one of $2^{k-14}$ symbols or, in other words, this part can be regarded as memory of $(k-14)$ bits, by associating the robot in row 0 (resp. row 1) with 0 (resp. 1). The configuration in Figure 1 is thus transmitting a binary sequence 011010100110.

We regard the swarm as a sequence of arrays whose element can take [math] or $1$; the codeword array $code[0..k-15]$, followed by the buffer array $bf[0..4]$, the temporal memory array $cp[0..4]$, the signal array $sign[0]$, and the counter array $cnt[0..3]$ (Figure 1).

Starting from a configuration in the canonical state, $ALG_{1}$ changes the bits in $code[0..k-1]$ one by one, and shifts the swarm right by two columns when the configuration returns to the canonical state. Here it is worth noting that a bit may be changed more than once.

First, $cp[0..4]$ copies $code[0..4]$ and two robots in $code[0..1]$ move to make a “wave”. There are at most two columns containing two robots during the shift procedure. When there are two such columns, the right one is called the head (column of the wave) and the left one the tail (column of the wave). The shift procedure shifts a bit from left to right, and the wave indicates the bits that $ALG_{1}$ is currently shifting. However, when the wave is created, the bits maintained in the head and the tail are lost. Array $cp$ is used to save these bits. When the shift of the codeword finishes,the wave is in the controller, and the two robots in the head and the tail are simply sent to the right end of the configuration to reset the controller to all zero.

The core of the shift procedure is to shift a bit in codeword right by two columns. Let $head$ (resp. $tail$) denote the $x$-coordinate of the head (resp. the tail). The shift is indeed carried out at the tail. The part of the configuration to the left of the tail always remembers a prefix $H=b_{1}b_{2}\ldots b_{h}$ of the bit sequence $B=b_{1}b_{2}\ldots b_{k-14}$ transmitting. To extend $H$ by appending $b_{h+1}$, $ALG_{1}$ moves the correct robot in the tail to right so that the correct bit $b_{h+1}$ is created in the tail. As a matter of fact, the tail has already moved to right, though. The shift procedure is a repetition of the following phases:

The controller updates $cp[0..4]$ to $b_{h+1}b_{h+2}\ldots b_{h+5}$. 2. 2.

The correct robot in the tail moves to the next column to create bit $b_{h+1}$, by referring to $cp[0]$ to decide the correct robot. This move of the robot shifts the tail right by one column.

To implement the above procedure, the update and the wave shift phases have to be synchronized. Although the second phase finishes in one step, the first phase needs a number of steps to complete, and the update phase must be finished before the shift of tail starts. Algorithm $ALG_{1}$ keeps inequality $head-tail\leq 2$ during the procedure. The end of phase 2 is indicated by $tail=head-1$, and roughly until the following phase 1 finishes, a robot in the head does not move and hence equation $tail=head-1$ holds. When the update of $cp[0..4]$ in phase 1 finishes with cooperation of $cnt$, a robot in the head moves to the next column. When it moves, equation $tail=head-2$ holds, which however is not a sign to finish phase 1 (and to start phase 2), since $cnt$ must be reset before starting phase 2. The completion of the reset is signaled by $sign$. It is set once $tail=head-1$ holds. It is reset, when $tail=head-2$ holds and $cnt$ is reset to all 0.

The update of $cp$ is carried out in the following way: Since $cp$ stores $b_{h+1}b_{h+2}\ldots b_{h+5}$, $ALG_{1}$ updates it to $b_{h+2}b_{h+3}\ldots b_{h+6}$. For $i=1,2,3$, in this order, $cp[i]$ is copied to $cp[i-1]$, and finally it stores $b_{h+6}$ to $cp[4]$, where $b_{h+6}$ is stored to the right of the head and hence it is possible. The synchronization of these five updates are done with the cooperation of $cnt$. Here $cnt[0..3]$ works as a unary counter, and it is incremented whenever an update finishes (or the update is not necessary because it has already had the correct bit value). Once all bits in $cnt$ are set to 1, as explained, the head starts shifting.

Finally, the buffer $bf[0..3]$ is used when $ALG_{1}$ is going to shift two bits $b_{k-15}$ and $b_{k-14}$ which were stored in the last two columns. These column are now the tail and the head, and the bits are stored in $cp[0..1]$. The buffer is used to store $b_{k-15}$ and $b_{k-14}$. It is also necessary to separate $code$ and $cp$, so that the wave will not directly shift into $cp$ and the bits will not be lost.

In the following description of Algorithm $ALG_{1}$, $cnt$ increments as $0000\to 1000\to 1100\to 1110\to 1111$, and the counter value is $c$ when the number of $1$’s in $cnt[0..3]$ is $c$.

Algorithm $ALG_{1}$

When the configuration is canonical, first store $b_{1}b_{2}\ldots b_{5}$ to $cp$, then move the robots in the first and the second column to the third and the fifth column to initialize the wave where $head=3$ and $tail=1$, i.e., $head-tail=2$ holds after the moves. 2. 2.

When there are no columns in $code$ that contain two robots, but there are head and tail of the wave, move the two robots to right and append to the right end of the configuration, which move reset the controller all 0, and the configuration returns to the canonical state. 3. 3.

When the wave is in $code$ and $sign=0$ (Note that $cnt=0000$ always holds in this case.):

1. (a)

If $head-tail=2$, referring to $cp[0]$, the correct robot in the tail moves to an empty cell of the $(tail+1)$st column. 2. (b)

If $head-tail=1$, set $sign$ to $1$. 4. 4.

When the wave is in $code$ and $sign=1$:

1. (a)

If $cnt=c<4$, copy $cp[c+1]$ to $cp[c]$ if they are different. Then increment $cnt$. 2. (b)

If $cnt=c=4$, copy $code[head+1]$ to $cp[4]$ if they are different. (As a result, $cp[4]=code[head+1]$ holds.) If $head-tail=1$, one of the two robots in the head moves to an empty cell of column $head+1$. If $head-tail=2$, first reset $cnt$ to 0, and then reset $sign$ to 0 (when $cnt=0$).

Lemma 10

There is a code $\gamma$ based on algorithm $ALG_{1}$ whose size is $|\gamma|=2^{k-14}$. The transmission delay $d_{ALG_{1}}$ is at most $(10k-123.5)(m-k)$.

Proof.

The fact $|\gamma|=2^{k-14}$ is obvious from the definition of algorithm $ALG_{1}$.

As for the transmission delay, one cycle of transitions shifts a configuration in the canonical state right by two columns. During the movement, the wave moves from the first two bits of the codeword to the end of the counter. Thus the total number of shifts of the wave is $2k$. For each bit of the codeword, each bit of the counter moves twice, the signal twice, and each bit of the copy part at most once. Hence, the total number of robot moves in the controller is $(k-14)(5+2+8)=18k-252$. In the beginning of the shift, each bit of the copy part moves at most once. Hence the total number of robot moves to move the codeword by one column is at most

[TABLE]

The distance from the last bit of the counter to $u_{R}$ is at most $(m-k)$. Hence $d_{ALG_{1}}\leq(10k-123.5)(m-k)$. ∎

An obvious consequence of Lemma 10 is that $2^{k-14}\leq\mu_{G_{8}(m,2),k}\leq\mu_{G_{8}(m,n)}$ for all $n\geq 2$. The transmission delay of the code by $ALG_{1}$ is roughly $10k(m-k)$ when $m(\gg k)$ is large, which is not so fast compared with its lower bound $k(m-2(k-1))$ of Theorem 6. This fact motivates the study of a faster algorithm in the next subsection.

3.3 Algorithm $ALG_{2}$ for faster information transmission

It is easy to design a code with a small transmission delay if we do not need to care the code size. In this subsection, we design a code based on an algorithm $ALG_{2}$ whose code size is $2^{\lfloor k/2\rfloor}$. However its transmission delay is near optimal.

For simplicity, we assume that $k$ satisfies $\lfloor k/2\rfloor=\ell$ for some positive integer $\ell\geq 2$. Algorithm $ALG_{2}$ divides the swarm into a codeword and a copy, each of which consists of $\ell$ robots. In the same way as $ALG_{1}$, the codeword represents $\ell$ bits and the copy follows the codeword. When $k$ is odd, a single robot follows the copy, and it does not represent any bit.

In the canonical state, each column contains exactly one robot as illustrated in Figure 5. Algorithm $ALG_{2}$ shifts the canonical state by one column. Suppose that the leftmost cell of the canonical state is in the column $i$. Then the rightmost cell is in the column $(i+k-1)$. The left $\ell$ robots represent the symbol it is transmitting. We can thus transmit one of $2^{\ell}$ symbols, or in other words, these $\ell$ robots can be regarded as memory of $\ell$ bits $B=b_{1}b_{2}\ldots b_{\ell}$. We now regard the robots in the left $\ell$ columns as an array $code[0..\ell-1]$ and those in the right $\ell$ columns as an array $copy[0..\ell-1]$. When $k$ is odd, the last robot is put in the [math]th row of column $i+k-1$. The canonical state in Figure 5 represents a binary sequence $010$.

Starting from a configuration where the swarm is in the canonical state, $ALG_{2}$ shifts the swarm right by one column when the configuration returns to the canonical state. In the canonical state, $ALG_{2}$ first shifts the codeword by generating a wave; the leftmost robot moves to the empty cell of its right column. From now on, we regard the column with two robots as the wave.222 The wave in $ALG_{2}$ consists of just one column and this is different from the wave in $ALG_{1}$, that consists of two columns for synchronization. Once the wave is initialized, the wave moves to right by repeating the following procedure; when the wave is in the $j$th column from the left end of the swarm, one of the two robots in the wave moves to the empty cell of the $(j+1)$st column so that the $j$th column represents $b_{j}$, which is stored at $copy[j-1]$. After the movement, the wave is in the $(j+1)$st column and the left $j$ columns of the swarm represent $b_{1}b_{2}\ldots b_{j}$. When the wave reaches the copy, it repeats the same procedure until it reaches the right end of the swarm. Specifically, when the wave reaches the column of $copy[0]$ (i.e., $\ell$th column from the left end of the swarm), $copy[\ell-1]$ specifies which of the two robots in the wave move to which cell because $\ell\geq 2$. Now, $B$ is fully stored in the left $\ell$ columns of the swarm and the wave proceeds to right with copying these columns. When $k$ is odd, the last robots moves to the [math]th row of the right end of the swarm. Then, the swarm retains the canonical state.

Lemma 11

There is a code $\gamma$ based on algorithm $ALG_{2}$ whose size is $|\gamma|=2^{\lfloor k/2\rfloor}$. The transmission delay $d_{ALG_{2}}$ is $k(m-k)$.

Proof.

The fact that $|\gamma|=2^{\lfloor k/2\rfloor}$ is obvious from the definition of algorithm $ALG_{2}$.

As for the transmission delay, one cycle of transmission shifts the canonical state right by one column. During the movement, the wave moves from the left end of the swarm to the right end with making one robot move in each column. Thus the total number of movement in a cycle is $k$. Consequently, $d_{ALG_{2}}=k(m-k)$. ∎

By comparing two transmission delays in Lemmas10 and 11, when $m(\gg k)$ is large, $ALG_{2}$ is 10 times as fast as $ALG_{1}$.

4 Variable swarm size code

The information transmission scheme in Introduction allow us to assign configurations of different sizes to different symbols. Suppose that, in a code $\gamma$, a configuration with size $k_{i}$ is assigned to a symbol $s_{i}$ whose occurrence probability is $s_{i}$. Let $K_{\gamma}=\sum_{i=1}^{\alpha}k_{i}p_{i}$ be the average swarm size of $\gamma$ and define $K^{*}=\min_{\gamma}K_{\gamma}$, which is the optimal average swarm size. This section analyzes bounds of $K^{*}$.

4.1 Lower bounds of $K^{*}$

We derive a lower bound of $K^{*}$ on $G_{8}(m,n)$. We can assume without loss of generality that $p_{i}\leq p_{i+1}$ for $i=1,2,\ldots,\alpha-1$ and $k_{i}\leq k_{i+1}$ for $i=1,2,\ldots,\alpha-1$, since, if $k_{i}>k_{i+1}$ holds, we could reduce $K^{*}$ by exchanging the assignment to $s_{i}$ and $s_{i+1}$. The size of any code realized by a swarm of $k$ robots on $G_{8}(m,n)$ is bounded from above by $2^{6(k-1)}$, i.e., $\mu_{G_{8}(m,n)}\leq 2^{6(k-1)}$ by Lemma 7. A lower bound of $K^{*}$ can be achieved by a code constructed under the assumption that $2^{6(k-1)}$ configurations of size $k$ are assignable to symbols for each $k$. Let $H(S)=-\sum_{i=1}^{\alpha}p_{i}\log p_{i}$ be the entropy of $S$.

Theorem 12

Suppose that $m>k$ and $n\geq 2$. Then for any code for $S$ on $G_{8}(m,n)$,

[TABLE]

Proof.

By assumption $k_{i}\leq k_{i+1}$ holds for $i=1,2,\ldots,\alpha-1$. We first calculate $k_{\alpha}$. By assumption $k_{\alpha}=\max_{i}k_{i}$ holds. Then $\sum_{k=1}^{k_{\alpha}-1}2^{6(k-1)}<\alpha\leq\sum_{k=1}^{k_{\alpha}}2^{6(k-1)}$. By a simple calculation, we have $k_{\alpha}=\left\lceil\log\frac{63\alpha+1}{6}\right\rceil$.

Let $q_{i}=2^{-6(k_{i}-1)}/k_{\alpha}$. Then, $q_{i}>0$ for all $i=1,2,\ldots,\alpha$ and

[TABLE]

By Shannon’s lemma, we have

[TABLE]

Thus

[TABLE]

∎

Note that $\log\log\alpha>\frac{1}{6}\log\left\lceil\log\frac{63\alpha+1}{6}\right\rceil-1$, we have

[TABLE]

A bound of $K^{*}$ for any code on $G_{8}(m,2)$ can be derived by using Lemma 9, by a similar discussion.

Corollary 13

Suppose that $m>k$. Then for any code for $S$ on $G_{8}(m,2)$,

[TABLE]

Since $1+0.79\log\alpha<\log\alpha$ when $\alpha\geq 2^{5}$, $K^{*}>0.78H(S)-0.79\log\log\alpha$, which may be approximated by $\frac{4}{5}(H(S)-\log\log\alpha)$ when $\alpha\geq 2^{5}$. Note that regardless of $\alpha$, $H(S)$ can be 0, when $p_{1}=1$, which means that these lower bounds can be negative and become meaningless. On the other hand, when $p_{i}=1/\alpha$ for all $i=1,2,\ldots,\alpha$, $H(S)$ take the maximum value $\log\alpha$. Thus $K^{*}$ on $TG_{8}(m,2)$ is roughly bounded from below by $0.78\log\alpha$, when $\log\log\alpha$ is negligible.

4.2 Upper bound of $K^{*}$ based on $ALG_{1}$

To derive an upper bound of $K^{*}$, we construct a code $\gamma_{ALG_{1}}$ for $S$ based on $ALG_{1}$. Although there are $2^{k-14}$ size $k$ configurations assignable to symbols for any $k>14$, there are no size $k$ configurations assignable to symbols for $k\leq 14$. For each $k\leq 14$ however, we can easily construct a code with code size 1 by using a trivial locomotion algorithm illustrated in Figure 6.

Thus we use the configurations defined by $ALG_{1}$ as well as one configuration defined above for each $k\leq 14$. Let $X$ be the set of all configurations assignable. Code $\gamma_{ALG_{1}}$ is defined as follows: We assign a configuration of size $k_{i}$ in $X$ to a symbol $s_{i}$ in such a way that $k_{i}\leq k_{i+1}$ holds for $i=1,2,\ldots,\alpha-1$. By definition, $k_{\alpha}\leq\alpha$. Let $K_{ALG_{1}}$ denote the average code size of $\gamma_{ALG_{1}}$.

Theorem 14

When $m>\alpha$, $K_{ALG_{1}}<H(S)+15$ holds.

Proof.

Consider the “tower” of codewords of $\gamma_{ALG_{1}}$. Each of the first $14$ levels contains a single codeword, and the $\ell$th layer contains $2^{\ell-14}$ codewords for $\ell\geq 15$.

Shannon’s noiseless coding theorem guarantees the existence of a prefix-free code whose average code length is smaller than $H(S)+1$. Let $\ell_{i}$ be the length of the codeword of $s_{i}$ in such a prefix-free code. By the definition of $\gamma_{ALG_{1}}$, $k_{i}-14\leq\ell_{i}$. Thus

[TABLE]

∎

Thus the performance of $\gamma_{ALG_{1}}$ in terms of the average code size is sufficiently good on $G_{8}(m,2)$, since, very roughly, $K_{\gamma}$ of any code $\gamma$ on $G_{8}(m,2)$ is bounded from below by $\frac{4}{5}(H(S)-\log\log\alpha)$.

Code $\gamma_{ALG_{1}}$ can be used not only on $G_{8}(m,2)$ but also on $G_{8}(m,n)$ for $n>2$. On $G_{8}(m,n)$, its performance may not be good, however, since our lower bound of $K^{*}$ on $G_{8}(m,n)$ is $\frac{1}{6}(H(S)-\log\log\alpha)$, and there is still a large gap from $K_{ALG_{1}}$.

4.3 Average transmission delay

We next analyze the average transmission delay. For any code $\gamma$ on $G_{8}(m,2)$, let $D_{\gamma}=\sum_{i=1}^{\alpha}d_{i}p_{i}$. We are interested in the optimal average transmission delay $D^{*}=\min_{\gamma}D_{\gamma}$. First we derive a lower bound of $D^{*}$. Consider any code $\gamma$ on $G_{8}(m,n)$, where $m>2\alpha$. We may assume without loss of generality that $\alpha\geq k_{i}$ for any $i=1,2,\ldots,\alpha$. By Theorem 6, $d_{i}\geq k_{i}(m-2k_{i}+1)$. Since $\alpha\geq k_{i}$,

[TABLE]

Since $K_{\gamma}\geq K^{*}$, we have:

Observation 15

$D^{*}\geq(m+1-2\alpha)K^{*}$.

To derive an upper bound of $D^{*}$, Let $D_{ALG_{1}}$ be the average delay of $\gamma_{ALG_{1}}$. By Lemma 10, $d_{i}\leq(10k_{i}-123.5)(m-k_{i})$. Since $\alpha\geq k_{i}$ holds for all $i=1,2,\ldots,\alpha$, we have:

Observation 16

$D_{ALG_{1}}\leq 10mK_{ALG_{1}}$.

Thus $\gamma_{ALG_{1}}$ may not be a good choice from the view of the average transmission delay, even considering the fact that $K_{ALG_{1}}\leq H(S)+15$. The average number of steps necessary to move one column is approximated from above by $10H(S)$ when $m\gg\alpha$.

Since algorithm $ALG_{2}$ has a smaller transmission delay, we analyze a code $\gamma_{ALG_{2}}$ based on $ALG_{2}$. Since $ALG_{2}$ is defined only for $k\geq 4$, like $\gamma_{ALG_{1}}$, consider set $X$ that contains standard configurations defined in $ALG_{2}$ for all $k\geq 4$, as well as a single configuration of size $i$ for each of $i=1,2,3$. Like $\gamma_{ALG_{1}}$, $\gamma_{ALG_{2}}$ is defined as follows: We assign a size $k_{i}$ configuration in $X$ to a symbol $s_{i}$ in such a way that $k_{i}\leq k_{i+1}$ holds for $i=1,2,\ldots,\alpha-1$. Let $K_{ALG_{2}}$ denote the average code size of $\gamma_{ALG_{2}}$.

Theorem 17

Suppose that $m>\alpha>1$. Then $K_{ALG_{2}}<2H(S)$.

Proof.

Recall that $p_{i}\geq p_{i+1}$ for $i=1,2,\ldots,\alpha-1$. Then $p_{i}\leq 1/i$, and hence $-\log p_{i}\geq\log i$.

Consider the “tower” of codewords of $\gamma_{ALG_{2}}$. Each of the first $3$ levels contains a single codeword, and the $\ell$th layer contains $2^{\lfloor\frac{k}{2}\rfloor}$ codewords for $k\geq 4$. Code $\gamma_{ALG_{2}}$ packs the symbols in its order $s_{1},s_{2},\ldots,s_{\alpha}$ to codewords from the first level to the higher level in its order.

We then divide the tower into three small towers, $T_{1}$, $T_{2}$, and $T_{3}$, where $T_{1}$ consists of the first 3 levels, $T_{2}$ consists of even levels greater than 3, and $T_{3}$ consists of odd levels greater than 4. Hence, $h$th level of $T_{2}$ (and $T_{3}$ also) corresponds to a binary tree in the sense that it contains $2^{h-1}$ codewords.

First consider a codeword for $s_{i}$ in $T_{2}$. Let $h_{i}$ be the level that contains a configuration assigned to $s_{i}$ in $T_{2}$. The total number of symbols assigned to the level lower than $(h_{i}-1)$ in $T_{1}$, $T_{2}$, and $T_{3}$ is smaller than $i$. Thus we have $3+2(1+2+\cdots+2^{h_{i}-1})<i$, which implies that $h_{i}<\log i-1$. Since the size of $k_{i}$ is $2h_{i}+2$, $k_{i}<2\log i$. We then consider a codeword $s_{i}$ in $T_{3}$. Let $h_{i}$ be the level of $s_{i}$ in $T_{3}$. In the same way, $3+2(1+2+\cdots+2^{m_{i}-1})+2^{m_{i}}<i$, which implies $h_{i}<\log i-\log 3$. Since the size of $k_{i}$ is $2h_{i}+3$, $k_{i}<2\log i+3-2\log 3<2\log i$. Thus, we have

[TABLE]

∎

Thus the upper bound of $K_{ALG_{2}}$ obtained by the theorem is roughly twice as much as that of $K_{ALG_{1}}$. Let $D_{ALG_{2}}$ be the average transmission delay of $\gamma_{ALG_{2}}$. By Lemma 11, $d_{i}=k_{i}(m-k_{i})$. Thus

Observation 18

$D_{ALG_{2}}\leq mK_{ALG_{2}}$.

Since $K_{ALG_{2}}<2H(S)$, we have $\leq D^{*}\leq 2mH(S)$. The average number of steps necessary to move one column is approximated from above by $2H(S)$ when $m\gg\alpha$. Thus the variable swarm size code by $ALG_{2}$ is 5 times as fast as that by $ALG_{1}$.

5 Conclusion

We proposed an information transmission scheme by a swarm of anonymous oblivious mobile robots on a graph. We mainly analyzed the performance of our scheme in terms of code size and transmission delay in the 8-gird and proposed two algorithms one achieves exponential code size with large transmission delay and the other achieves optimal transmission delay with small code size. We finally extended these algorithms for variable swarm size codes.

There are many open problems related to the proposed scheme. First, we could not find any algorithm with optimal code size and optimal transmission delay. Second, the gap between the upper bound and the lower bound of the (expected) swarm size of the fixed swarm size code and of the variable swarm size code needs to be closed. One approach is a more sophisticated technique to upper bound the number of initial configurations and terminating behaviors. Third, parallel movement of robots might speed up the transmission and makes algorithms simpler.

One of the most important future directions is robustness. We put our basis on Shannon’s noiseless coding theorem, and the next step is to consider faulty robots. We believe Shannon’s noisy channel coding theorem help the investigation. Another direction is to investigate local algorithms that restricts the visibility of the robots to a constant distance.