Distributed Pattern Formation in a Ring

TL;DR

This paper studies distributed algorithms for agents on a ring to rearrange themselves into diverse patterns satisfying specific color distributions within blocks, with optimal or near-optimal time complexity.

Contribution

It introduces algorithms for pattern formation in rings with multiple colors, providing optimal solutions for two-color cases and general methods for multiple colors.

Findings

Algorithm for two-color pattern formation with optimal time complexity

Extension to multiple colors with $O(nk)$ steps

Ability to achieve arbitrary final patterns with at least one agent of each color

Abstract

Motivated by concerns about diversity in social networks, we consider the following pattern formation problems in rings. Assume $n$ mobile agents are located at the nodes of an $n$-node ring network. Each agent is assigned a colour from the set $\{c_1, c_2, \ldots, c_q \}$. The ring is divided into $k$ contiguous {\em blocks} or neighbourhoods of length $p$. The agents are required to rearrange themselves in a distributed manner to satisfy given diversity requirements: in each block $j$ and for each colour $c_i$, there must be exactly $n_i(j) >0$ agents of colour $c_i$ in block $j$. Agents are assumed to be able to see agents in adjacent blocks, and move to any position in adjacent blocks in one time step. When the number of colours $q=2$, we give an algorithm that terminates in time $N_1/n^*_1 + k + 4$ where $N_1$ is the total number of agents of colour $c_1$ and $n^*_1$ is the minimum number of agents of colour $c_1$ required in any block. When the diversity requirements are the same in every block, our algorithm requires $3k+4$ steps, and is asymptotically optimal. Our algorithm generalizes for an arbitrary number of colours, and terminates in $O(nk)$ steps. We also show how to extend it to achieve arbitrary specific final patterns, provided there is at least one agent of every colour in every pattern.

Equations

$$n_b^{\ast }=\underset{1\le j\le k}{\min }{n}_b(j)\text{mbox}and{n}_r^{\ast }=\underset{1\le j\le k}{\min }{n}_r(j)$$

$$y_i=n_b(S_i)-n_b(i)$$

$$y(\mathcal{C},1,j)\le 0\text{mbox}andy(\mathcal{C},j+1,k-j)\ge 0$$

$$0\le y(\mathcal{C},\ell ,k-\ell +1)=y(\mathcal{C},\ell +1,k-\ell )-z_{\ell }$$

$$y({\mathcal{C}}^{\prime },\ell +1,k-\ell )=y(\mathcal{C},\ell +1,k-\ell )-t\ge 0$$

$$dest(i)=\underset{\ell }{\mathrm{argmin}}\sum _{i=1}^{\ell }{n}_i(\ell )\ge i$$

$$displacement(i,j)=j-dest(i)$$

Full text

When the number of colours $q=2$, we give an algorithm that terminates in time $N_{1}/n^{*}_{1}+k+4$ where $N_{1}$ is the total number of agents of colour $c_{1}$ and $n^{*}_{1}$ is the minimum number of agents of colour $c_{1}$ required in any block. When the diversity requirements are the same in every block, our algorithm requires $3k+4$ steps, and is asymptotically optimal. Our algorithm generalizes for an arbitrary number of colours, and terminates in $O(nk)$ steps. We also show how to extend it to achieve arbitrary specific final patterns, provided there is at least one agent of every colour in every pattern.

1 Introduction

Recent research in sociology and network science indicates that diverse social connections have many benefits. For example, de Leon et al [23] conclude that increasing diversity, and not just increasing size, of social networks may be essential for improving health and survival among the elderly. Eagle et al find that social network diversity is at the very least a strong structural signature for the economic development of communities [12]. Reagans and Zuckerman [26] found that increased organizational tenure diversity in R&D teams correlated positively with higher creativity and productivity.

On the other hand, the pioneering work of Schelling [27, 28] provided a model to describe how even small preferences for locally homogeneous neighbourhoods result in globally segregated cities. In his model, individuals of two colours are situated on a path, ring or mesh (i.e. a one- or two-dimensional grid) and have a threshold for the minimum number of neighbors of the same colour they require in their local neighborhood. If this threshold is not met, they move to a random new location. Schelling showed via simulations that this process inevitably led to a globally segregated pattern. This model has been studied extensively and the results confirmed repeatedly; see for example [1, 2, 10, 18, 25, 30, 31]. Recent work in theoretical computer science [4, 19] has shown that the expected size of these segregated communities can be exponential in the size of the local neighbourhoods in some social network graphs. The Schelling model has also been studied from a games perspective, where neighborhood formation is determined by agents that can be selfish, strategic [6, 13] or form coalitions [5].

In this paper, we study an algorithmic approach to seeking diversity. Consider a social network formed by a finite number of individuals, henceforth called agents that can be classified into a set of categories, called colours. The group collectively seeks diversity in local neighborhoods. Is it possible to achieve a specified version of diversity? If so, how can the agents achieve this diversity? These questions were first raised and studied in a recent paper [21], in which the authors studied a model with red and blue agents specifying their local neighbourhood preferences in a ring network. Centralized algorithms to satisfy the preferences of all agents, when possible, were given in [21].

In this paper, we study distributed algorithms for achieving diversity in local neighborhoods (blocks) in a ring network.

1.1 Model and problem definition

We assume we are given a collection of $n$ agents situated on the nodes of an $n$-node ring network. We fix a partition of the ring into $k$ paths or blocks of length $p$, with $n=kp$. Each agent has a colour drawn from the set $\{c_{1},c_{2},\ldots,c_{q}\}$. For ease of exposition, we initially focus our analysis on the case $q=2$, and call the colours $c_{1}$ and $c_{2}$ as blue and red respectively. Any specific clockwise ordering of these $n$ coloured agents around the ring is called a configuration or $n$-configuration. Starting from an initial configuration, we are interested in distributed algorithms for the agents to rearrange themselves into final configurations that meet certain given constraints, for example, alternating red and blue agents, or each red agent has at least one blue agent as a neighbour.

A configuration can be represented by a string ${\cal C}$ of length $n$ drawn from the alphabet $\{c_{1},c_{2},\ldots,c_{q}\}$. Following standard terminology, for any string $u$, we denote by $|u|$ the length of $u$; by $u^{i}$ the string $u$ repeated $i$ times; by $uv$ the string $u$ concatenated with the string $v$. The number of occurrences of the colour $c_{i}$ in a string $u$ is denoted by $n_{i}(u)$. A pattern $P$ is a string of length $p$ drawn from the alphabet $\{c_{1},c_{2},\ldots,c_{q}\}$ with $n_{i}(P)>0$ for all $1\leq i\leq q$. Corresponding to the partition of the ring into blocks mentioned above, a configuration can be seen as a concatenation of $k$ patterns $S_{1}S_{2}\ldots S_{k}$, in which $S_{i}$ is the pattern of agents in the $i$-th block.

We are interested in distributed algorithms for the following problems:

1. P1:

Given positive integers $n_{i}(j)$ for all $1\leq i\leq q$ and $1\leq j\leq k$ and a valid initial configuration ${\cal C}$, give a distributed algorithm that achieves a final configuration $S_{1}S_{2}\ldots S_{k}$ with $n_{i}(S_{j})=n_{i}(j)$ for all $1\leq i\leq q$ and $1\leq j\leq k$. 2. P2:

Given positive integers $n_{i}(j)$ for all $1\leq i\leq q$ and $1\leq j\leq k$ and a valid initial configuration ${\cal C}$, give a distributed algorithm that achieves a final configuration $S_{1}S_{2}\ldots S_{k}$ with $n_{i}(S_{j})\geq n_{i}(j)$ for all $1\leq i\leq q$ and $1\leq j\leq k$. 3. P3:

Given a sequence of patterns $P_{1},P_{2},\ldots,P_{k}$, and a valid initial configuration ${\cal C}$, give a distributed algorithm to achieve the final configuration $P_{1}P_{2}\cdots P_{k}$.

A given initial configuration ${\cal C}$ is valid for the three problems above (respectively) if and only if for all $1\leq i\leq q$, we have (P1) $n_{i}({\cal C})=\sum_{j=1}^{k}n_{i}(j)$ (P2) $n_{i}({\cal C})\geq\sum_{j=1}^{k}n_{i}(j)$ and (P3) $n_{i}({\cal C})=\sum_{j=1}^{k}n_{i}(P_{j})$. Clearly the problem is only solvable for valid initial configurations. Figure 1 shows an input configuration and an output configuration for problem P1 with the required number of agents of colours $c_{1}$ and $c_{2}$ being $2$ in all the blocks.

Notice that an algorithm for P1 can be used to solve P3 with a few modifications. If specific patterns are required in blocks as in Problem P3, we can first apply an algorithm for problem P1 to obtain the correct number of agents of different colours in every block. Once a block has the correct number of agents of every colour, they can rearrange themselves in one additional step to form the required pattern.

Agent model. Our agent model is similar to the widely studied autonomous mobile agent model [15], where initially the agents are assumed to occupy arbitrary positions in the plane, and each agent repeatedly performs a Look-Compute-Move cycle. First an agent looks at the positions of the other agents. Then, using the positions of other agents it found and its own, it computes its next position. Finally it moves to the newly computed position. The agents are generally assumed to have identical capabilities, they have no centralized coordination, and they do not communicate with each other. Indeed, their decisions are based only on their observations of their surroundings made during the look phase. Many different variations of the model have been studied, based on whether or not the agents are synchronized or not, how far they can see, whether or not they agree on a coordinate system, etc.

In this paper, as already stated, we assume that agents are initially placed at the nodes of a $n$-node ring network $G$. They belong to $q$ colour classes, but agents within a colour class are identical, and they do not have or use any id. Agents are aware of their position in the ring, and may use this position in their calculations; for example agents at odd positions in the ring may behave differently from agents at even positions. They are completely synchronous, and time proceeds in discrete time steps. We assume that agents have a common limited visibility range: each agent can see all agents in the ring that are within the same block or in adjacent blocks. They also have a limited movement range: in one step, an agent can move to any position in the same or adjacent blocks222We note that if the visibility and movement ranges are smaller, our algorithms still work, though they take more time. The details are lengthy and uninteresting, and therefore omitted from this paper.. It is the responsibility of the algorithm designer to ensure that there are no collisions, i.e., we must never have two agents in the same position in the ring. Agents are memoryless, and do not communicate; their decisions are made solely on what they see during their“look” phase. We say that a distributed algorithm for pattern formation by agents terminates in a time step, if agents have formed the required pattern, and no agent moves after this time step.

1.2 Our results

We give solutions for problems P1, P3, and a restricted case of P2. We first consider in detail the case when the number of blocks $k$ is even, and the number of colours $q=2$, that is, all agents are blue or red. We give an algorithm that terminates in time $N_{b}/n^{*}_{b}+k+4$ where $N_{b}$ is the total number of blue agents, and $n^{*}_{b}$ is the minimum number of blue agents required in any block (Theorem 2.2). Note that this time is upper bounded by $n/2$ in the worst case where $n$ is the total number of agents. When the requirements are homogeneous, that is, the same number of blue agents are required in every block, our algorithm terminates in $3k+4$ steps; we show that this is optimal (Corollary 2.2).

We then give algorithms for the cases when:

$k$ is odd. 2. 2.

the number of colours $q$ is more than 2. 3. 3.

a specific final configuration $P_{1}P_{2}\ldots P_{k}$ is desired.

or any combination of the above (see Theorem 3.1). These algorithms terminate in $O(nk)$ time.

Finally, given $n_{1}(j)>0$ for all $1\leq j\leq k$, we give an $O(nk)$ algorithm to achieve a final configuration in which the number of agents of colour $c_{1}$ is at least $n_{1}(j)$ in every block $S_{j}$ (see Theorem 3.2).

1.3 Related work

There is a large literature on distributed computing by autonomous mobile agents, see the book [15] that provides a very complete survey of results in this area. Much of this work is done for mobile agents located in the plane or a continuous region, and the main problems that have been considered are gathering of robots [8, 17], scattering and covering [9], and pattern formation [29, 7] by autonomous mobile robots (see [16, section 1.3]). The solvability, i.e., termination or convergence, of these problems depends on the type of synchronization, visibility, agreement on orientation [15]. In [24], the authors introduce the problem of using a set of pairwise-communicating processes to constructing a given network.

In discrete spaces, typically graphs like grids or rings, similar problems have been studied, see for example: gathering [20, 11]; exploration [22]; pattern formation [3]; and deployment [14]. Unlike in our paper, in all these studies, only a subset of the nodes of the graph is occupied by agents, and typically agents are identical, and not partitioned into colour classes.

The work closest to our work is [21], which considers a similar setting of red and blue agents on a ring of $n$ nodes, and every node of a ring contains an agent. The agents are required to achieve final configurations on a ring, with specified diversity constraints similar to ours. However, unlike the present paper, in which the final configuration specifies the diversity constraints per block and agents are interchangeable, in [21], each agent has a preference for the colours of other agents in its $w$-neighborhood. The authors consider there three ways for agents to specify these preferences: each agent can specify (1) a preference list: the sequence of colours of agents in the neighborhood, (2) a preference type: the exact number of neighbors of its own colour in its neighborhood, or (3) a preference threshold: the *minimum *number of agents of its own colour in its neighborhood. The main result of [21] is that satisfying seating preferences is fixed-parameter tractable (FPT) with respect to parameter $w$ for preference types and thresholds, while it can be solved in $O(n)$ time for preference lists. They also show a linear time algorithm for the case when all agents have homogeneous preference types. However, in [21], all algorithms are centralized unlike in the present paper, in which we are only interested in distributed algorithms.

2 Distributed Algorithm for Two colours

In this section we consider problem P1 with $q=2$, that is, all agents are blue or red. We denote the number of blue and red agents in a pattern $u$ by $n_{b}(u)$ and $n_{r}(u)$ respectively. We first describe an algorithm for the first problem, i.e. when the exact number of blue and red agents in the $i$-th block, denoted by $n_{b}(i)$ and $n_{r}(i)$ respectively, is specified. For simplicity, we assume the number of blocks $k$ is even. We will show in Section 2.3 that the algorithm also works when $k$ is odd. Let $N_{b}$ and $N_{r}$ be the total number of blue and red agents in the initial configuration. Furthermore, let

[TABLE]

We assume without loss of generality that $N_{b}/n_{b}^{*}\leq N_{r}/n_{r}^{*}$. If not, we reverse the roles of the blue and red agents in the algorithm and subsequent analysis.

We use $S_{i}$ to denote both the $i$-th block and the pattern of agents in it at a particular time step; the meaning used will be clear from context. For every $i$, $1\leq i\leq k$ we denote by $y_{i}$ the difference between the number of blue agents in $S_{i}$ and the desired number of blue agents:

[TABLE]

We call $y_{i}$ a surplus if positive, and a deficit if negative.

In each step, we partition the ring into windows of length $2p$, each window consisting of 2 adjacent blocks. If blocks $S_{i}$ and $S_{i+1}$ are paired into a window in this partitioning, we denote the window by $[S_{i}|S_{i+1}]$. Recall that in our agent model, agents can see and move to adjacent blocks, and know their positions in the ring. Therefore, agents in the same window can all see each other and can move to any position within the window (as $S_{i}$ has access to $S_{i+1}$ and vice-versa). Also, notice that this pairing is specific to our algorithm, and not a constraint of our model. Agents in the window $[S_{i}|S_{i+1}]$ execute the following algorithm

Note that neither moving blue agents before red agents, nor the specification that it is the leftmost agents that swap places, is necessary for the algorithm to terminate, nor do these affect the termination time; they only simplify the analysis. Furthermore, agents can compute the net effect of the two moves mentioned above, and perform a single movement in a single Look-Compute-Move cycle; thus Algorithm 1 comprises a single time step.

Clearly agents in different windows can perform the above algorithm in parallel in the same time step without collisions. We give our pattern formation algorithm for agents of two colours below:

We call one iteration of the loop in Algorithm 2 a round. It is straightforward to see that each round takes constant time and can be performed without collisions. Notice that if a block is paired with the block on its right in a round, then it will be paired with the block on its left in the next round. In one round, surplus red agents (if any) in the blocks $S_{i},S_{i+2},S_{i+4},\ldots,S_{i-2}$ move to $S_{i+1},S_{i+3},S_{i+5},$ $\ldots,S_{i-1}$ respectively, and in the next round surplus red agents in the blocks $S_{i+1},S_{i+3},S_{i+5},\ldots,S_{i-1}$ move to $S_{i+2},S_{i+4},S_{i+6},\ldots,S_{i}$, respectively, and this is repeated. In other words, there is a flow of red agents to the right and an equivalent flow of blue agents to the left. Since blue agents moving left from the block $S_{i+1}$ to $S_{i}$ are always the leftmost blue agents in $S_{i+1}$, and move to positions after the blue agents already present in $S_{i}$, and the blue agents move up to the beginning of each block before the next round, each round preserves the clockwise order of the blue agents as stated in the following lemma:

Lemma 2.1** (Order-preserving property of blue agents)**

Let ${\cal C}$ and ${\cal C^{\prime}}$ be the configurations before and after a round in Algorithm 2. Then the clockwise ordering of blue agents in ${\cal C}$ and ${\cal C^{\prime}}$ is the same.

2.1 Proof of correctness and termination

We now show that this flow of agents eventually stops, and the algorithm terminates with the desired number of blue and red agents in every block. We first introduce some definitions and observations about the properties of a configuration.

Definition 2.1

For any given valid configuration ${\cal C}=S_{1}S_{2}\ldots S_{k}$, define $y({\cal C},i,\ell)$ $=\sum_{j=0}^{\ell-1}{y_{i+j}}$, i.e., $y_{i}$ is the cumulative surplus of blue agents in $\ell$ consecutive blocks starting from $S_{i}$.

Definition 2.2

For any given valid configuration ${\cal C}=S_{1}S_{2}\ldots S_{k}$, define $y({\cal C},i)$ to be the maximum in the set $\{y({\cal C},i,1),y({\cal C},i,2),\ldots,y({\cal C},i,k)\}$.

Figure 2 shows $y({\cal C},1,\ell)$ for a sample configuration. Notice that $y({\cal C},1)=y({\cal C},1,5)=4$.

Lemma 2.2

In any given valid configuration ${\cal C}=S_{1}S_{2}\ldots S_{k}$ there exists an integer $i$ such that $y({\cal C},i)=0$.

Proof. Let $j$ be the integer such that $y({\cal C},1,j)=y({\cal C},1)$, i.e., the index of the block where the sum of differences of number of blue agents between the blocks and patterns, when counted from $S_{1}$, is maximized. See Figure 2. Consider the value $y({\cal C},j+1,\ell)$ for some integer $\ell$. Clearly, $y({\cal C},j+1,\ell)=y({\cal C},1,\ell)-y({\cal C},1,j)\leq 0$ by our choice of $j$. On the other hand in any valid configuration the total excess of red agents in the configuration is [math]. Thus, $y({\cal C},j+1)=0$. See Figure 2; in this example,  $j=5$; the figure on the right shows $y({\cal C},6,\ell)$, which is always $\leq 0$ for every $\ell$. $\Box$

Since the input configuration is circular, and the algorithm runs in parallel in all blocks, we can rename the blocks. We will therefore assume in the sequel that $y({\cal C},1)=0$. This means that starting in block $S_{1}$, the cumulative surplus of blue agents is never positive. This implies the following useful non-positive prefix and non-negative suffix property.

Lemma 2.3** (Non-Negative Suffix Property)**

For any valid input configuration $\cal C$ and for every integer $j$, $1\leq j<k$ we have:

[TABLE]

In other words, the total surplus of blue agents in the first $j$ blocks is at most [math] while the total surplus of blue agents in the last $k-j$ blocks is at least [math].

Proof. Since $y({\cal C},1)=0$, we have that $y({\cal C},1,j)\leq 0$. Since $y({\cal C},1)=y({\cal C},1,j)+y({\cal C},j+1,k-j)=0$, we get $y({\cal C},j+1,k-j)=-y({\cal C},1,j)\geq 0$. $\Box$

In particular, notice that the non-negative suffix property implies that $y_{k}=y({\cal C},k,1)\geq 0$.We now show that every round of Algorithm 2 maintains the non-negative suffix property.

Lemma 2.4

Let ${\cal C}=S_{1}S_{2}\ldots S_{k}$ be a configuration such that for any $j$, $1\leq j\leq k$, we have $y({\cal C},1,j)\leq 0$ and $y({\cal C},j+1,k-j)\geq 0$. Executing one round of Algorithm 2 gives a configuration ${\cal C^{\prime}}=S_{1}^{\prime}S_{2}^{\prime}\ldots S_{k}^{\prime}$ such that $y({\cal C^{\prime}},1,j)\leq 0$ and $y({\cal C^{\prime}},j+1,k-j)\geq 0$ for any $j$, $1\leq j\leq k$.

Proof. For a block $S_{\ell}$, define $z_{\ell}=n_{r}(S_{\ell})-n_{r}(\ell)$ as the surplus of red agents in $S_{\ell}$. Let $\ell$ be an integer, $1\leq\ell<k$ such that Algorithm 1 is applied to the pair $[S_{\ell}|S_{\ell+1}]$. Assume for now that $\cal C^{\prime}$ is the configuration obtained after only $[S_{\ell}|S_{\ell+1}]$ have made their exchanges and no other blocks. We will show that the conditions of the Lemma hold for $\cal C^{\prime}$. This proves our statement, since we may repeat our analysis by applying the exchanges between pairs of blocks one at a time while maintaining the invariants of the Lemma.

Performing the exchanges between $S_{\ell}$ and $S_{\ell+1}$ can affect only the suffixes $y({\cal C^{\prime}},\ell,k-\ell+1)$ and $y({\cal C^{\prime}},\ell+1,k-\ell)$; any movement of agents that happens cannot affect a suffix $y({\cal C^{\prime}},j,k-j)$ with $j<\ell$ or $j>\ell+1$. Clearly, if $y(S_{\ell})\geq 0$ or there are no blue agents in $S_{\ell+1}$ then there is no movement of agents between $S_{\ell}$ and $S_{\ell+1}$ and thus, obviously, $y({\cal C^{\prime}},\ell,k-\ell+1)=y({\cal C},\ell,k-\ell+1)\geq 0$, and $y({\cal C^{\prime}},1,\ell-1)=y({\cal C},1,\ell-1)\leq 0$.

Thus we only need to consider the case when $S_{\ell}$ has $z_{\ell}=-y_{l}>0$ excess red agents and $S_{\ell+1}$ contains $n_{b}(S_{\ell+1})>0$ blue agents. Let $t=min\{z_{\ell},n_{b}(S_{\ell+1}),n_{b}^{*}\}$. Then $t$ blue agents move from $S_{\ell+1}$ to $S_{\ell}$ and $t$ move from $S_{\ell}$ to $S_{\ell+1}$. Clearly, the total surplus of blue agents in the $\ell$-th suffix does not change, that is, $y({\cal C^{\prime}},\ell,k-\ell+1)=y({\cal C},\ell,k-\ell+1)\geq 0$. We only need to show that the movement of $t$ blue agents to $S_{\ell}$ does not render the $(\ell+1)$-th suffix negative. Observe that

[TABLE]

In other words, since $S_{\ell}$ lacks $z_{\ell}$ blue agents and yet the $\ell$-th suffix is non-negative, it must be that the $(\ell+1)$-st suffix is at least $z_{\ell}$. Thus, $y({\cal C},\ell+1,k-\ell)\geq z_{\ell}\geq t$, and moving $t\leq z_{\ell}$ blue agents from $S_{\ell+1}$ to $S_{\ell}$ cannot make the $(\ell+1)$-st suffix negative. That is,

[TABLE]

$\Box$

Lemma 2.4 implies that the property $y_{k}\geq 0$ is maintained after every round. This means $S_{k}$ never has a deficit of blue agents, and therefore when it participates in the window $[S_{k}|S_{1}]$, there is no swap of agents. Therefore we obtain the following corollary:

Corollary 2.1

Algorithm 2 never does any swap of agents between the blocks $S_{k}$ and $S_{1}$.

We now develop a potential function argument to show that Algorithm 2 eventually reaches the desired final configuration, after which no agents ever move. Given a configuration ${\cal C}=S_{1}S_{2}\cdots S_{k}$, we define the destination block of the $i$-th blue agent (from position 1 in the ring) to be

[TABLE]

That is, the destination block of the leftmost $n_{b}(1)$ blue agents in the input configuration is $S_{1}$, the next $n_{b}(2)$ blue agents in the input configuration is $S_{2}$, and so on. Next we define the displacement of the $i$-th blue agent (from position 1 in the ring) that is located in block $S_{j}$ to be the difference between the index of its present block and the index of its destination block:

[TABLE]

Given a configuration ${\cal C}=S_{1}S_{2}\cdots S_{k}$, we define the distance of the configuration $d({\cal C})$ to be the sum of displacements of all blue agents in the configuration. We first prove some properties of the distance function.

Lemma 2.5

Let ${\cal C}$ be the configuration after $i$ rounds in Algorithm 2. Then:

$d({\cal C})\geq 0$** 2. 2.

$d({\cal C})\leq d({\cal C^{\prime}})$* where $\cal C^{\prime}$ was the configuration before the $i$-th round.* 3. 3.

If $d({\cal C})=0$, no agent ever moves again.

Proof. It follows from Lemma 2.4 that the displacement of any blue agent is non-negative, as otherwise, there would be a deficit of blue agents in some suffix. Thus $d({\cal C})$ must always be non-negative. Second, since blue agents only move left in an order-preserving manner (Lemma 2.1), and from Corollary 2.1, they never move left past $S_{1}$ to $S_{k}$, the displacement of any blue agent cannot increase, and therefore $d({\cal C})$ cannot increase. Finally, if $d({\cal C})=0$, then every block has its desired number of blue agents, and no agent will ever move again. $\Box$

We now show that the distance function is guaranteed to decrease after at most 2 rounds.

Lemma 2.6

Assume that we are given a configuration ${\cal C}=S_{1}S_{2}\ldots,S_{k}$ and positive integers $n_{b}(i)>0$ for $1\leq j\leq k$ such that $d({\cal C})>0$. After at most two rounds in Algorithm 2 to ${\cal C}$ we obtain configuration ${\cal C}^{\prime}$ such that $d({\cal C}^{\prime})\leq d({\cal C})-1$.

Proof. Since $d({\cal C})>0$, we know that ${\cal C}$ is not a valid final configuration, and Lemma 2.3 and the assumption $n_{b}(i)>0$ for all $1\leq j\leq k$ implies that there exists a window $[S_{j}|S_{j+1}]$ such that $n_{b}(S_{j})<n_{b}(j)$ and $n_{b}(S_{j+1})>0$, i.e., there is a surplus of red agents in $S_{j}$, and $S_{j+1}$ contains some blue agents. Then $t=\min\{|y_{j}|,n_{b}(S_{j+1}),n_{b}^{*}\}$ as defined in Algorithm 1 is positive. Now, if the window $[S_{j}|S_{j+1}]$ is active in the next round in Algorithm 2, then $t$ blue agents from $S_{j+1}$ are swapped with $t$ red agents from $S_{j}$. Clearly, the displacement of these blue agents goes down by 1. Thus after this round, we obtain configuration ${\cal C^{\prime}}$ with $d({\cal C^{\prime}})<d({\cal C})$.

Suppose instead the window $[S_{j}|S_{j+1}]$ is not active in the next round of Algorithm 2. Let ${\cal C}_{1}$ be the configuration obtained after the next round of Algorithm 2. By Lemma 2.5, $d({\cal C}_{1})\leq d({\cal C})$. In the following round of Algorithm 2 the window $[S_{j}|S_{j+1}]$ is active and we transfer $t$ blue agents from $S_{j+1}$ to $S_{j}$, and the displacement of these $t$ agent goes down by 1. Thus after two rounds, we obtain the configuration ${\cal C}^{\prime}$ with $d({\cal C}^{\prime})\leq d({\cal C}_{1})-1\leq d({\cal C})-1$. $\Box$

Notice that the condition $n_{b}(P_{j})>0$ for $1\leq j\leq k$ is necessary. For example, if there is a block $S_{j}$ with $n_{b}(P_{j})=0$ and $y(S_{j})=0$ then this block will never receive a blue agent, and this would prevent any flow of blue agents to the left of $S_{j}$, even when blue agents are needed there, and any flow of red agents across $S_{j}$.

Theorem 2.1

Given $n_{b}(j)>0$ and $n_{r}(j)\geq 0$ for all all $1\leq j\leq k$, where $k$ is even, and a valid input configuration, Algorithm 2 reaches a configuration where $n_{b}(S_{j})=n_{b}(j)$ and $n_{r}(S_{j})=n_{r}(j)$ in every block $S_{j}$. Furthermore, this takes $O(nk)$ steps, and after this configuration is reached, no agent ever moves again.

Proof. Since the initial value of the distance function is at most $nk$, the result follows from Lemma 2.6 and Lemma 2.5. $\Box$

2.2 Proof of termination time

In this section, we show an upper bound on the number of iterations required for Algorithm 2 to terminate. Recall that $n_{b}^{*}=p-\max_{1\leq j\leq k}(n_{r}(j))$ and $N_{b}$ is the total number of blue agents in the input configuration ${\cal C}$. Let $B$ be the set of blue agents, and assume (for the purpose of the analysis) that they are numbered from left to right as $b_{1},b_{2},\ldots b_{N_{b}}$. Partition the members of $B$ into subsets $B_{1},\ldots,B_{L}$ as follows. Let $B_{1}=\{b_{1},\ldots,b_{n_{b}^{*}}\}$, $B_{2}=\{b_{n_{b}^{*}+1},\ldots,b_{2n_{b}^{*}}\}$, and so on, so that $L=\lceil N_{b}/n_{b}^{*}\rceil$ and each subset has $n_{b}^{*}$ elements, except perhaps $B_{L}$. We say that an agent $b_{i}$ is $(t)$-cooperative if, in every round $t^{\prime}\geq t$, either (1) $b_{i}$ moves left; or (2) $b_{i}$ has reached its destination block as defined in the previous section.

The key idea is that the first $n_{b}^{*}$ blue agents (i.e. $B_{1}$) start travelling every round at the latest by round $2$ until they reach their destination blocks. After this round, they “free” the path for the blue agents of $B_{2}$, which then start travelling every round from round $4$ until they reach their destination blocks. This unblocks $B_{3}$ from round $6$, and so on. In the end, the blue agents of $B_{L}$ can freely travel from round $2L+2$, and they only need to travel at most $k$ slices. Note that agents in blocks $B_{l}$ may indeed move before round $2l+2$ but they may be subsequently blocked; however from round $2l+2$ onward, they will continue to travel every round until they reach their destination block. These ideas are formalized in the next lemma.

Lemma 2.7

For every $l\in[L]$, each blue agent in $B_{l}$ is $(2l+2)$-cooperative.

Proof. For convenience, define $B_{0}=\emptyset$. By induction over $l\in\{0,1,\ldots,L\}$ we show that each blue agent in each $B_{l}$ is $(2l+2)$-cooperative. Using $l=0$ as a base case, this statement is vacuously true: each blue agent in $B_{0}$ is $(0)$-cooperative. Now suppose that the lemma holds for all $B_{l^{\prime}}$ with $l^{\prime}<l$. Assume that there is $b_{i}\in B_{l}$ such that in some round $w\geq 2l+2$, the agent $b_{i}$ does not move left and it is not in its destination block. Let $S_{a}$ be the block that contains $b_{i}$ before (and after) the execution of round $w$. It follows from the earlier discussions that $S_{a}\neq S_{1}$, as this would mean the destination block of $b_{i}$ requires it to move left from $S_{1}$ to $S_{k}$.

There are 2 cases: either, in round $w$,

(*) $S_{a}$ is in the active window $[S_{a-1}|S_{a}]$;

(**) $S_{a}$ is in the active window $[S_{a}|S_{a+1}]$.

Let us first suppose that (*) holds. Note that since $w\geq 2l+2$, we may assume by induction that all the blue agents in $B_{1}\cup\ldots B_{l-1}$ are $(w-1)$-cooperative333The reader may bear in mind that the proof works in the particular case $l=1$ and $w=1$. This means that at the start of round $w$, the block $S_{a-1}$ cannot contain any blue agent in $B_{1}\cup\ldots\cup B_{l-1}$, as such an agent could not advance in round $w$, contradicting its $(w-1)$-cooperativeness. Moreover, by Lemma 2.1, $S_{a-1}$ also cannot contain any blue agent in $B_{l+1},\ldots,B_{L}$, as this would break the ordering of the blue agents since $b_{i}\in B_{l}$ is in $S_{a}$. It follows that $S_{a-1}$ can only have blue agents from $B_{l}$ at the start of round $w$.

Suppose $S_{a-1}$ has $z>0$ blue agents from $B_{l}$ at the beginning of round $w$. Then it has $p-z$ red agents. Since the maximum number of red agents required in a block is $p-n_{b}^{*}$, there are at least $p-z-(p-n_{b}^{*})=n_{b}^{*}-z$ agents that are surplus red agents in $S_{a-1}$. Meanwhile by the order preserving property of Lemma 2.1, $S_{a}$ contains no agents from $B_{j}$ for any $j<l$, since $S_{a-1}$ has an agent from $B_{l}$. Furthermore, $S_{a}$ contains at most $n_{b}^{*}-z$ blue agents from $R_{l}$, and any agents that it contains from $B_{j}$ with $j>l$ would occur to the right of any blue agents from $R_{l}$. Hence agent $b_{i}$ would move to $S_{a-1}$ in round $w$, a contradiction.

If instead $S_{a-1}$ has no blue agents at the beginning of round $w$, it must have only red agents, that is, $p$ of them. Then there must be at least $n_{b}^{*}$ excess red agents in $S_{a-1}$, and at most $n_{b}^{*}$ agents from $B_{l}$ in $S_{a}$. Thus the only reason that $r_{i}$ would not move to $S_{a-1}$ in round $w$ is that there are agents from $B_{l-1}$ in $S_{a}$ which have priority moving left over the agent $b_{i}$. Let $b_{h}$ be such an agent. Consider the round $w-1$. At the start of that round, $S_{a}$ was in the window $[S_{a}|S_{a+1}]$ and so $S_{a}$ could not have contained a blue agent from $B_{1}\cup\ldots B_{l-1}$, as these would not be able to move left in round $w-1$, contradicting our inductive hypothesis. Consequently, $b_{h}$ was in $S_{a+1}$ and by the order preserving property of Lemma 2.1, $S_{a}$ could not contain a blue agent from $B_{l}\cup\ldots\cup B_{L}$ either. In other words $S_{a}$ had no blue agents at the start of round $w-1$. At most $n_{b}^{*}$ blue agents could have moved left to $S_{a}$ in round $w-1$, and it follows that at the start of round $w$, $S_{a}$ has at most $n_{b}^{*}$ blue agents. But as we argued, $S_{a-1}$ has at least $n_{b}^{*}$ excess red agents at the start of round $w$, which means that all the blue agents in $S_{a}$ are able to move left to $S_{a-1}$, including $b_{i}$, a contradiction.

Next let us suppose that (**) holds. At the start of round $w-1$, the agent $b_{i}$ was either in $S_{a}$ or in $S_{a+1}$. But if $b_{i}$ was in $S_{a+1}$ at the start of round $w-1$, it could not move from $S_{a+1}$ to $S_{a}$, as $S_{a+1}$ was in the window $[S_{a+1}|S_{a+2}]$ in that round. Thus $b_{i}$ was in $S_{a}$ in round $w-1$ and it did not advance, noting that $S_{a}$ belonged to the window $[S_{a-1}|S_{a}]$. We now use an identical argument for time $w-1\geq 2l+1$, as we did above for the case when (*) holds, to obtain a contradiction. We conclude that every $b_{i}\in B_{l}$ is $(2l+2)$-cooperative. $\Box$

Theorem 2.2

Given even $k$ and positive integers $n_{r}(j)$ and $n_{b}(j)$ for all $1\leq j\leq k$ and a valid input configuration ${\cal C}$, Algorithm 2 terminates in at most $\frac{2N_{b}}{n_{b}^{*}}+k+4$ time steps, where $n_{b}^{*}=\min_{1\leq j\leq k}(n_{b}(j))$ and $N_{b}$ is the total number of blue agents in ${\cal C}$.

Proof. Consider the partition $B_{1},\ldots,B_{L}$ of the blue agents as defined above. We have $L=\lceil N_{b}/n_{b}^{*}\rceil\leq N_{b}/n_{b}^{*}+1$. By Lemma 2.7, each $b_{i}$ is $(2L+2)$-cooperative, implying that each $b_{i}$ is also $(2N_{b}/n_{b}^{*}+4)$-cooperative. This means that after at most $2N_{b}/n_{b}^{*}+4$ rounds, every blue agent that is not yet at its destination block advances a block in every round. Since there are $k$ blocks, such a $b_{i}$ will reach its destination after at most $k$ additional rounds. Since this holds for any $b_{i}$, and recalling that every round can be executed in one step, this proves the statement. $\Box$

Corollary 2.2

If the diversity requirements are homogeneous, that is $n_{b}(i)=m$ for all $1\leq j\leq k$, then Algorithm 2 terminates in at most $3k+4$ steps, and this is optimal.

Proof. Suppose $n_{b}(j)=m$ for all $1\leq j\leq k$. Then $n_{b}^{*}=m$ and $N_{b}=km$, and the bound given by Theorem 2.2 is $\frac{2km}{m}+k+4=3k+4$.

We now show that there are inputs for which $\Omega(k)$ is a lower bound on the number of steps required for any algorithm in our agent model. In particular consider an input with the size of the blocks $p$ even, and $n_{b}(i)=p/2$ for every block $i$, and the input configuration such that the first $k/2$ blocks have only red agents and the last $k/2$ blocks have only blue agents. Then $pk/4$ blue agents need to move to blocks $S_{1}$ to $S_{k/2}$. Since agents can only move to the next block in a single time step, all these agents would have to move from $S_{k/2+1}$ to $S_{k/2}$ or from $S_{k}$ to $S_{1}$ in some step. However, at most $p$ blue agents can move from $S_{k/2+1}$ to $S_{k}$ and similarly at most $p$ blue agents can move from $S_{k}$ to $S_{1}$ in one time step. It follows that the number of time steps required is at least $pk/(4(2p))=k/8$. $\Box$

Notice that when the diversity patterns are identical, given by a string $u$ of length $p$, the solution obtained by our algorithm is of type $u^{k}$. The results in [21] imply that in this case, in the final ring network, in any neighbourhood of length $p$ starting at any position of the ring, the number of blue and red agents is the same as in $u$.

2.3 When the number of blocks $k$ is odd

Consider now the situation when the number of blocks $k$ is odd. Notice that in one round of Algorithm 2, the surplus red agents from the blocks $S_{i},S_{i+2},S_{i+4},\\ \ldots,S_{i-3}$ move to $S_{i+1},S_{i+3},S_{i+5},\ldots,S_{i-2}$, respectively, and in the next round, surplus red agents from the blocks $S_{i+1},S_{i+3},S_{i+5},\ldots S_{i-2}$ move to $S_{i+2},S_{i+4},\\ S_{i+6},\ldots,S_{i-1}$ respectively. In this case surplus red agents from $S_{i-1}$ can move only in the subsequent third round, but this delay happens to $S_{i-1}$ only once in $k$ rounds since the value of $i$ is incremented after every round. Then in the proof of Lemma 2.6 the window $[S_{i},S_{i+1}]$ in which there is swap of agents between $S_{i}$ and $S_{i+1}$ is only in the third round of the algorithm. Thus, the value of $d({\cal C})$ is only guaranteed to decrease after 3 rounds. However, due to the way the windows are shifted in the algorithm after each round, this can occur to $S_{i-1}$ only once in $k$ rounds. It is clear that Theorem 2.1 still holds.

3 Distributed Algorithm for $q$ colours

In this section we consider the pattern formation problem when the given set of colours $\{c_{1},c_{2},\ldots,c_{q}\}$ is of size $q\geq 3$. We show that Algorithm 2 can be generalized to solve the pattern formation problem for any $q\geq 3$.

The main idea of the generalization is to iteratively ”correct” the number of agents of colour $i$, starting with colour $c_{1}$. Assume that we are given an input instance ${\cal C}$ consisting of a set of colours $\{c_{1},c_{2},\ldots,c_{q}\}$, $q\geq 3$, number $n_{i}(j)$ for each colour specifying the required number of agents of colour $c_{i}$ in block $S_{j}$, and a valid input configuration ${\cal C}$ over alphabet $\{c_{1},c_{2},\ldots,c_{q}\}$.

Let $c_{2}^{\prime}$ be a new colour not in $\{c_{1},c_{2},\ldots,c_{q}\}$. Consider now the input instance ${\cal C}_{1}$ of two colours $c_{1}$ and $c_{2}^{\prime}$, obtained from ${\cal C}$ by treating all colours $\{c_{2},\ldots,c_{q}\}$ as $c_{2}^{\prime}$. For every $1\leq j\leq k$, the parameters $n_{1}(j)$ remain the same as in the original instance, while $n^{\prime}_{2}(j)=\sum_{2\leq i\leq q}n_{i}(j)$, that is, the required number of agents of colour $c_{2}^{\prime}$ in block $S_{j}$ is the sum of requirements of colours $\{c_{2},\ldots,c_{q}\}$ in block $S_{j}$ of the original problem. If we run Algorithm 2 on the transformed input ${\cal C}^{\prime}$ we get a final configuration ${\cal C}_{1}^{\prime}$ in which the number of agents of colour $c_{1}$ in each block is correct.

Next we consider input instance ${\cal C}_{2}$ of two colours $c_{2}$ and $c_{3}^{\prime}$ obtained from ${\cal C}_{1}^{\prime}$ by treating all colours $\{c_{3},\ldots,c_{q}\}$ as a new colour $c_{3}^{\prime}$. The requirement $n_{2}(j)$ remains as in ${\cal C}$ while $n_{3}^{\prime}(j)$ is the sum of requirements of colours $\{c_{3},\ldots,c_{q}\}$ in block $S_{j}$ of the original problem. If we run Algorithm 4 on input instance ${\cal C}_{2}$ while the agents of colour $c_{1}$ do not participate or move, we get a final configuration ${\cal C}_{2}^{\prime}$ in which the number of agents of colours $c_{1}$ and $c_{2}$ in each block is correct. Clearly this can be repeated in $q-1$ phases to get a solution to the original instance ${\cal C}$; in phase $i$, we obtain the correct number of agents of colour $i$ in every block. The above description assumes that the phases are run sequentially, and phase $i+1$ starts after phase $i$ is completed.

In fact, since in phase $i$, the agents of colours $\ell<i$ do not move, and as such their numbers do not change, it is enough for agents to verify locally that the number of agents of colours $c_{\ell}$ with $\ell<i$ is correct before applying the algorithm for phase $i$. In other words, the phases can be interleaved. We describe how to modify the algorithms for a window $[S_{j},S_{j+1}]$ as given in Algorithm 3.

Clearly, the termination of this algorithm follows directly from the termination of Algorithm 4 as shown in Theorem 2.1. Notice that $n_{i}(c_{j})\geq 1$ is needed for every $1\leq i\leq q-1$ and $1\leq j\leq k$ to guarantee termination.

The discussion above yields the following theorem:

Theorem 3.1

Algorithm  4 solves the pattern formation problems P1 and P3 and terminates in time $O(nk)$ where $n$ is the number of agents and $k$ is the number of blocks.

3.1 When there is a lower bound on the number of agents

In this section we address a restricted version of the second problem P2: given $n_{1}(j)>0$ and $n_{i}(j)=0$ for all $2\leq i\leq q$ and $1\leq j\leq k$, achieve a final configuration ${\cal C^{\prime}}=S_{1}S_{2}\ldots S_{k}$ with $n_{i}(S_{j})\geq n_{i}(j)$. In other words, there is a positive lower bound required on the number of agents of colour $c_{1}$ in every block, but no lower bound on agents of any other colour. Observe that in this case a valid initial configuration $w$ must satisfy the condition $n_{1}({\cal C})\geq\sum_{i=1}^{k}n_{1}(S_{i})$.

Let $d=n_{1}({\cal C})-\sum_{i=1}^{k}n_{1}(S_{i})$, that is, $d$ is the number of extra agents of colour $c_{1}$ present in the input configuration. Consider now applying Algorithm 2 (for 2 colours) on the given input instance, treating agents of all colours except for colour $c_{1}$ as agents of colour $c_{2}^{\prime}$, a new colour. Given a valid block configuration ${\cal C}$ we use the definitions of $y({\cal C},i,\ell)$ and $y({\cal C},i,\ell)$ from the preceding section. It is easy to see that by replacing every [math] by $d$ in the statements of Lemmas 2.2, 2.3, 2.4, and Corollary 2.1, they remain valid for this problem. This implies that Lemma 2.6 and Theorem 2.1 remain valid exactly as stated in the previous section. Thus we get the following:

Theorem 3.2

Algorithm  4 solves the following restricted version of the pattern formation problem P2 in time $O(nk)$: Given a valid input configuration ${\cal C}$ and $n_{1}(j)>0$ and $n_{i}(j)=0$ for all $2\leq i\leq q$ and $1\leq j\leq k$, achieve a final configuration ${\cal C^{\prime}}=S_{1}S_{2}\ldots S_{k}$ with $n_{i}(S_{j})\geq n_{i}(j)$.

4 Discussion

Given $n$ agents of $q$ different colours situated on the nodes of a ring network that has been partitioned into $k$ blocks, we gave distributed algorithms for the agents to move to new locations where they satisfy specified patterns or diversity constraints in every block. Our analysis for the case of even $k$ and two colours is tight, but for the other problems, it would be interesting to obtain tight bounds. Our algorithms need a positive number of agents of at least the first $q-1$ colours to be required in the final configuration in every block; it is unclear to what extent this restriction is necessary for the existence of distributed algorithms for the problem.

Although we only considered a ring network, our algorithms could be adapted to other neighbourhood networks provided that a ring-like flow among the neighbourhoods can be established. It would also be interesting to consider bounds on the movement capacity or bandwidth and its impact on the number of steps needed.