On the Necessary Memory to Compute the Plurality in Multi-Agent Systems

TL;DR

This paper investigates the minimum memory required for agents in multi-agent systems to compute the plurality, providing new protocols with polynomial memory and establishing lower bounds, thus advancing understanding of the problem's complexity.

Contribution

The paper introduces a new plurality protocol with polynomial memory and refutes previous conjectures about optimality, also establishing lower bounds on memory requirements.

Findings

Proposed a polynomial-memory protocol with O(k^{11}) states.

Refuted the conjecture that polynomial memory protocols are optimal.

Established a lower bound of Ω(k^2) states for solving the problem.

Abstract

We consider the Relative-Majority Problem (also known as Plurality), in which, given a multi-agent system where each agent is initially provided an input value out of a set of $k$ possible ones, each agent is required to eventually compute the input value with the highest frequency in the initial configuration. We consider the problem in the general Population Protocols model in which, given an underlying undirected connected graph whose nodes represent the agents, edges are selected by a globally fair scheduler. The state complexity that is required for solving the Plurality Problem (i.e., the minimum number of memory states that each agent needs to have in order to solve the problem), has been a long-standing open problem. The best protocol so far for the general multi-valued case requires polynomial memory: Salehkaleybar et al. (2015) devised a protocol that solves the problem by employing $O(k 2^k)$ states per agent, and they conjectured their upper bound to be optimal. On the other hand, under the strong assumption that agents initially agree on a total ordering of the initial input values, Gasieniec et al. (2017), provided an elegant logarithmic-memory plurality protocol. In this work, we refute Salehkaleybar et al.'s conjecture, by providing a plurality protocol which employs $O(k^{11})$ states per agent. Central to our result is an ordering protocol which allows to leverage on the plurality protocol by Gasieniec et al., of independent interest. We also provide a $\Omega(k^2)$-state lower bound on the necessary memory to solve the problem, proving that the Plurality Problem cannot be solved within the mere memory necessary to encode the output.

Full text

The state complexity that is required for solving the Plurality Problem (i.e., the minimum number of memory states that each agent needs to have in order to solve the problem), has been a long-standing open problem. The best protocol so far for the general multi-valued case requires polynomial memory: Salehkaleybar et al. (2015) devised a protocol that solves the problem by employing $\mathcal{O}(k2^{k})$ states per agent, and they conjectured their upper bound to be optimal. On the other hand, under the strong assumption that agents initially agree on a total ordering of the initial input values, G\kasieniec et al. (2017), provided an elegant logarithmic-memory plurality protocol.

In this work, we refute Salehkaleybar et al.’s conjecture, by providing a plurality protocol which employs $\mathcal{O}(k^{11})$ states per agent. Central to our result is an ordering protocol which allows to leverage on the plurality protocol by G\kasieniec et al., of independent interest. We also provide a $\Omega(k^{2})$-state lower bound on the necessary memory to solve the problem, proving that the Plurality Problem cannot be solved within the mere memory necessary to encode the output.

1 Introduction

Consider a network of $n$ people, where each person supports one opinion from a set of $k$ possible opinions. There is also a scheduler who decides in each round which pair of neighbors can interact. The goal is to eventually reach an agreement on the opinion with the largest number of supporters, i.e. the plurality opinion (or majority when $k=2$). Here, eventually means at an unspecified moment in time, which the agents are not necessarily aware of (i.e. global termination is not required [25]).

The main resource we are interested in minimizing is the state complexity of each node:

How many different states does each person need to go through during such computation?

This voting task is known as the Plurality Problem (or as the Voting Problem) in the asynchronous Population Protocols model [1, 24]. For $k=2$, the problem is well understood: each person needs to maintain two bits in order for the people to elect the opinion of the majority [9, 21], regardless of the network size $n$, and the problem cannot be solved with a single bit [21].

However, the state complexity of the problem for general $k$ has so far remained elusive: a clever protocol by Salehkaleybar et al. [24], called DMVR, shows how to solve the problem with $O(k2^{k})$ states per person. They conjectured the DMVR protocol to be optimal:

“We conjecture that the DMVR protocol is an optimal solution for majority voting problem, i.e. at least $k2^{k-1}$ states are required for any possible solution.”

On the other hand, under the assumption that agents initially agree on a total ordering of the initial input values, [17] provide an elegant plurality protocol which makes use of a polynomial number of states only. It remained however rather unclear whether the above assumption can be removed in order to achieve a polynomial number of states for the general Plurality Problem as well.

1.1 Related Work

Progress towards understanding the inherent computational complexity for a multi-agent system to achieve certain tasks has been largely empirical in nature. More recently, deeper insights have been offered by analytical studies with respect to some coordination problems [23]. In this regard, understanding the amount of memory necessary for a multi-agent system in order to solve a computational problem is a fundamental issue, as it constrains the simplicity of the individual agents which make up the system [22]. Several research areas such as Chemical Reaction Networks [13] and Programmable Matter [18] investigate the design of computing systems composed of elementary units; in this regard, a high memory requirement for a computational problem constitute a prohibitive barrier to its feasibility in such systems.

The Plurality Problem (also known as Plurality Consensus Problem in Distributed Computing), is an extensively studied problem in many areas of distributed computing, such as population protocols [1, 8, 9, 21, 24], fixed-volume Chemical Reaction Networks [13, 27], asynchronous Gossip protocols [5, 6, 10, 15, 16], Statistical Physics [12] and Mathematical Biology [7, 11, 20, 26].

In the Population Protocols model, the memory is usually measured in terms of the number of states (state complexity) rather than the number of bits, following the convention for abstract automata [19]. In the context of the Plurality Problem, for $k=2$, the protocols of [9, 21] require $4$ states per node, and in [21], they showed that the problem cannot be solved with $3$ states. For general $k$, the protocol of [24] uses $O(2^{k-1}\cdot k)$ states per node, and the only lower bound known has been so far the trivial $\Omega(k)$, as each node/agent needs at least $k$ distinct states to specify its own opinion (which is from a set of size $k$). Under the crucial assumption that agents initially agree on a representation of the input values as distinct integers, [17] provides an elegant solution to the Plurality Problem which employs $\mathcal{O}(k^{6})$ states only.

1.2 Our Results

In this work we refute the conjecture of [24], by devising a general ordering protocol which allows the agents to agree on a mapping of the initial $k$ input values to the integers $\left\{0,\cdots,k-1\right\}$, thus satisfying the assumption of the protocol by [17]. We further show how to adapt the plurality protocol by [17] in a way that allows to couple its execution in parallel with the ordering protocol such that, once the ordering protocol has converged to the aforementioned mapping, the execution of the plurality protocol is also eventually consistent with the provided ordering of colors. We emphasize that agents are not required to detect when the protocol terminates; this is indeed easily shown to be impossible under the general assumption of a fair scheduler. The resulting plurality protocol make use of $\mathcal{O}(k^{11})$ states per agent.

Theorem 1

There is a population protocol $P_{general}$ which solves the Plurality Problem under a globally fair scheduler, by employing $\mathcal{O}(k^{11})$ states per agent.

Furthermore, we prove that $k^{2}-k$ states per node are necessary (Theorem 2).

1.2.1 Insights on the Ordering Problem.

The main idea for solving the ordering problem is to have some agents form a linked list, where each node is a single agent representing one of the initial colors. The fairness property of the scheduler allows for an adversarial kind of asynchronicity in how agents’ interactions take place. Because of this distributed nature of the problem, (temporary) creation of multiple linked lists cannot be avoided. Thus, it is necessary to devise a way to eliminate multiple linked lists, whenever more than one of them are detected. We achieve this goal by having agents from one of the linked lists leave it; also, as soon as these leaving agents interact with their successor or predecessor in their former list, they force them to leave the list as well, thus propagating the removal process until the entire list gets destroyed.

On the other hand, in order to form the linked list, the simple idea of having removed agents appending themselves to an existing linked list does not work. One of the issues with this naive approach is that a free agent $u$ may interact with the last agent $v$ of a list $\ell$ which is in the process of being destroyed, but the removal process in $\ell$ may still not have reached $v$. Our approach to resolve this latter issue consists of, firstly, forcing the destruction process of a linked lists to start from the first agents of the lists, and secondly, forcing free agents to attach to an existing list by climbing it up from its first agent and appending themselves to its end once they have traversed it all. This way, by the time that there is only one first agent $r$ of a linked list (we call such agents root agents), we can be sure that all the free agents must follow the linked list starting by the agent $r$, thus avoid extending incomplete linked lists.

1.3 Model and Basic Definitions

1.3.1 Population Protocols

In this work, we consider the communication model of Populations Protocols [1]: the multi-agent system is represented by a connected graph $G=(V,E)$ of $n$ nodes/agents, where each node implements a finite state machine with state space $\Sigma$. The communication in this model proceeds in discrete steps. We remark that, as for asynchronous continuous-time models with Poisson transition rates, they can always be mapped to a discrete-time model [14].

At each time step, an (oriented) edge is chosen by a certain scheduler, and the two endpoint nodes interact. Furthermore, there is a transition function $\Gamma:\Sigma\times\Sigma\rightarrow\Sigma\times\Sigma$ that, given an ordered pair of states $\left(\sigma_{u},\sigma_{v}\right)\in\Sigma\times\Sigma$ for two interacting nodes $u$ and $v$, returns their new states $\Gamma\left(\left(\sigma_{u},\sigma_{v}\right)\right)=\left(\sigma_{u}^{\prime},\sigma_{v}^{\prime}\right)$. We call configuration, and denote it by $\smash{S}^{(t)}$, the vector whose entry $u$ corresponds to agent $u$’s state after $t$ time steps. We say that a configuration $\smash{S}^{\prime}_{1}$ is reachable from configuration $\smash{S}^{\prime}_{2}$ if there exists a sequence of edges $s_{seq}$ such that if we start from $\smash{S}^{\prime}_{2}$ and we let the nodes interact according to $s_{seq}$, the resulting configuration is $\smash{S}^{\prime}_{1}$.

In recent works, the scheduler in this model is typically assumed to be probabilistic: the edge that is selected at each step is determined by a probability distribution on the edges. The most general studied scheduler is the fair scheduler [2], which guarantees the following global fairness property [3, 4].

Definition 1

A scheduler is said to be globally fair, iff whenever a configuration $\smash{S}$ appears infinitely often in an infinite execution $\smash{S}^{(1)},\smash{S}^{(2)},\cdots$, also any configuration $\smash{S}^{\prime}$ reachable from $\smash{S}$ appears infinitely often.

Some of our results hold for an even weaker111Formally, the globally fair scheduler is not a special case of the weak one since, if the activation of an edge does not lead to a different configuration, it can be ignored under a globally fair scheduler. However, if such useless activations are ignored, it is easy to see that the globally fair scheduler is a special case of the weak one. version of scheduler, which satisfies the weak fairness property [4, 17].

Definition 2

A scheduler is said to be weakly fair, iff any edge $e\in E$ appears infinitely often in the activation series $e_{1},e_{2},...$ .

Note that any probabilistic scheduler which selects any edge with a positive probability, is a globally fair scheduler, in the sense that the global fairness property holds with probability 1. Indeed, the fairness condition for a scheduler may be viewed as an attempt to capture, in a general way, useful probability-1 properties in a probability-free model [2]. This is crucially the case when correctness is required to be deterministic (i.e. the probability of failure should be 0) [21, 24].

We emphasize that our theoretical results concern the existence of certain times in the execution of the protocols for which some given properties hold, but no general time upper bound is provided, since a fair scheduler can typically delay some edge activation arbitrarily.

1.3.2 $k$-Plurality Problem.

Let $G=(V,E)$ be a network of $n$ agents, such that each agent $v\in V$ initially supports a value in a set of possible values $C$ of size $k$. We refer to the $k$ input values as colors. For each color $c\in C$, denote by $supp(c)$ the set of agents supporting color $c$. We further denote $c(v)$ as the input color of $v\in V$. We say that a population protocol solves the $k$-plurality problem if it reaches any configuration $\smash{S}^{(t)}$, such that for any $t^{\prime}\geq t$ it holds that the agents agree on the color with the greatest number of supporters in the initial configuration $\smash{S}^{(0)}$. More formally, there is an output function $\Phi:\Sigma\rightarrow C$ such that for any $t^{\prime}\geq t$ and any agent $u$, $\Phi((\smash{S}^{(t^{\prime})})_{u})$ equals the plurality color. If the relative majority is not unique, the agents should reach agreement on any of the plurality colors.

In this work, we focus on solving the $k$-Plurality Problem under a fair scheduler with the goal of optimizing the state complexity, which we denote by $\mathcal{M}_{k}$.

We emphasize that we do not assume any non-trivial lower bounds on the support of the initial majority compared to other colors, nor that the agents know the size of the network $n$, or that they know in advance the number of colors $k$. We do not make any assumption on the underlying graph other than connectedness. We remark that the analysis of our protocol $P_{general}$ in Theorem 1 holds for strongly connected directed graphs; however, for the sake of simplicity, we restrict ourselves to the original setting by [23].

Crucially, motivated by real-world scenarios such as DNA computing and biological protocols, we do not even assume that the nodes initially agree on a binary representations of the colors: they are only able to recognize whether two colors are equal and to memorize them. This latter assumption separates the polynomial state complexity of [17] from the exponential state complexity of [23].

2 Lower Bound on $\mathcal{M}_{k}$

Since the agents need at least to be able to distinguish their initial colors from each other, the trivial lower bound $\mathcal{M}_{k}\geq k$ follows. In this section, we show that $\mathcal{M}_{k}\in\Omega(k^{2})$.

Theorem 2

Any protocol for the $k$-Plurality Problem requires at least $k^{2}-k$ memory states per agent.

Proof

The high level idea is to employ an indistinguishability argument. That is, we show that for any protocol with less than $k^{2}-k$ states, there must be two initial configurations, $\smash{\smash{S}^{(0)}}_{1}$ and $\smash{\smash{S}^{(0)}}_{2}$, with different plurality colors, such that a configuration is reachable from both $\smash{\smash{S}^{(0)}}_{1}$ and $\smash{\smash{S}^{(0)}}_{2}$. Therefore, the protocol must fail in at least one of these two initial configurations.

Let $P$ be a protocol that solves the plurality consensus problem with $k$ initial colors, and let $\Phi:\Sigma\rightarrow C$ be the output function of $P$. Define $\textsc{EndStates}(c)=\{\sigma\in\Sigma\,|\,\Phi(\sigma)=c\}$. We start by observing that there must be some color $c^{*}\in C$, such that $|\textsc{EndStates}(c^{*})|\leq|\Sigma|/k$. For any initial configuration $\smash{\smash{S}^{(0)}}$ and color $c$, let $\Delta^{\smash{\smash{S}^{(0)}}}_{c}$ be the number of agents in $\smash{\smash{S}^{(0)}}$ with initial color $c$.

Definition 3

For an odd integer $x>0$, let $\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}$ be the set of all initial configurations $\smash{\smash{S}^{(0)}}$, such that $|\smash{\smash{S}^{(0)}}|=2x-1$, $\Delta^{\smash{\smash{S}^{(0)}}}_{c^{*}}=x$ and for any color $c\neq c^{*}$, $\Delta^{\smash{\smash{S}^{(0)}}}_{c}$ is an even number.

Given that, for the sake of the lower bound, we can assume a complete topology, the number of configurations in $\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}$ is equal to the number of ways to put $(x-1)/2$ pair of balls into $k-1$ bins. Therefore, we have $|\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}|\geq(\nicefrac{{\frac{x-1}{2}+k-2}}{{k-2}})^{k-2}.$ For each $\smash{\smash{S}^{(0)}}\in\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}$, since the plurality color in $\smash{\smash{S}^{(0)}}$ is $c^{*}$, $\smash{\smash{S}^{(0)}}$ will reach a configuration that $\Phi$ maps all agents in the configuration to $c^{*}$. The number of such possible configurations is at most the number of ways to put $2x-1$ balls into $|\textsc{EndStates}(c^{*})|$ bins. For a sufficiently large $x$, the number of such possible configurations is at most $(\nicefrac{{(2x-1+\frac{|\Sigma|}{k}-1)e}}{{\frac{|\Sigma|}{k}-1}})^{\frac{|\Sigma|}{k}-1}.$ Observe that for $|\Sigma|<k^{2}-k$ and sufficiently large $x$, the upper bound on the number of possible final configurations is less than the lower bound on $|\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}|$. Therefore, there must be two distinct initial configurations $\smash{\smash{S}^{(0)}}_{1},\smash{\smash{S}^{(0)}}_{2}\in\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}$ and a configuration $\smash{S}$ in which all agents are mapped to $c^{*}$, such that $\smash{S}$ is reachable from both $\smash{\smash{S}^{(0)}}_{1}$ and $\smash{\smash{S}^{(0)}}_{2}$, by some activation sequences $T_{1}$ and $T_{2}$ respectively. By definition of $\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}$, we have the following observation.

Observation 1

For each $\smash{\smash{S}^{(0)}},\smash{\smash{S}^{(0)}}^{\prime}\in\smash{\mathcal{\smash{S}}^{c^{*}}_{x}}$ where $\smash{\smash{S}^{(0)}}\neq\smash{\smash{S}^{(0)}}^{\prime}$, there exists a color $c$ such that $|\Delta^{\smash{\smash{S}^{(0)}}}_{c}-\Delta^{\smash{\smash{S}^{(0)}}^{\prime}}_{c}|\geq 2$.

Let $c$ be the color obtained from Observation 2 when applied to $\smash{\smash{S}^{(0)}}_{1}$ and $\smash{\smash{S}^{(0)}}_{2}$. Without loss of generality, assume that $\Delta^{\smash{\smash{S}^{(0)}}_{1}}_{c}\geq\Delta^{\smash{\smash{S}^{(0)}}_{2}}_{c}+2$. Let $\smash{\smash{S}^{(0)}}_{3}$ be an initial configuration with $x-\Delta^{\smash{\smash{S}^{(0)}}_{1}}_{c}+1$ agents, all having initial color $c$. Let us consider the two initial configurations $\smash{\smash{S}^{(0)}}_{4}=\smash{\smash{S}^{(0)}}_{1}\cup\smash{\smash{S}^{(0)}}_{3}$ and $\smash{\smash{S}^{(0)}}_{5}=\smash{\smash{S}^{(0)}}_{2}\cup\smash{\smash{S}^{(0)}}_{3}$. Observe that the plurality color in $\smash{\smash{S}^{(0)}}_{5}$ is still $c^{*}$, while the plurality color in $\smash{\smash{S}^{(0)}}_{4}$ is now $c$. Since $T_{1}$ and $T_{2}$ are possible initial sequences of interactions in $\smash{\smash{S}^{(0)}}_{4}$ and $\smash{\smash{S}^{(0)}}_{5}$ respectively, both $\smash{\smash{S}^{(0)}}_{4}$ and $\smash{\smash{S}^{(0)}}_{5}$ can reach the configuration $\smash{S}\cup\smash{\smash{S}^{(0)}}_{3}$. Therefore, a protocol $P$ using only $k^{2}-k-1$ states can fail to distinguish between initial configurations $\smash{\smash{S}^{(0)}}_{4}$ and $\smash{\smash{S}^{(0)}}_{5}$. Hence, $P$ fails to solve the problem on at least one initial configuration.

3 Upper bound on $\mathcal{M}_{k}$

In the following, we present a protocol that solves the problem with polynomial state complexity; we prove that $\mathcal{M}_{k}\in O(k^{11})$. The protocol proposed by G\kasieniec et al. [2] solves the problem using a polynomial number of states, under the hypothesis that agents agree on a way to represent each color with a $m$-bit label.

First, we present a protocol that constructs such a shared labeling for the input colors (Theorem 3). Then, we combine these two protocols to design a new protocol that solves the $k$-Plurality Problem (Theorem 1).

3.1 Protocol for the Ordering Problem

In the Ordering Problem, each agent $a\in V$ initially obtains its input color $c_{a}$, from a set of possible colors $C$ of size $k$. The goal of the agent is to eventually agree on a bijection between the set of the possible input colors of size $k$, and the integers $\{0,...,k-1\}$. In other words, each agent $a$ eventually gets a label $d_{a}\in\{0,1,...,k-1\}$ , such that for any two agents $a$ and $b$, $d_{a}=d_{b}$ iff $c_{a}=c_{b}$. We want to solve the Ordering Problem by means of a protocol which uses as few states as possible.

A weakly fair scheduler activates pairs of agents to interact. We consider the underlying topology of possible interactions to be a complete directed graph. We show how to remove such assumption in General Graphs section.

In this section, we prove the following theorem.

Theorem 3

There is a population protocol $P_{o}$ which solves the Ordering Problem under a weakly fair scheduler, by employing $\mathcal{O}(k^{4})$ states per agent.

We refer the reader to the section Insights on the Difficulty in the Introduction for an overview of the main ideas behind protocol $P_{o}$.

Memory Organization. The state of each agent $a$, encodes the following information:

$c_{a}$, the initial color, which never changes. 2. 2.

$d_{a}$, the desired value, stored in $\lceil{log_{2}k}\rceil$ bits. 3. 3.

$l_{a}$, a bit, indicating whether or not $a$ is a leader. 4. 4.

$r_{a}$, a bit, indicating whether or not $a$ is a root. 5. 5.

$pre_{a}$, a color from the set $C$. If $r_{a}=0$ and $a$ is on a linked list, then $pre_{a}$ is the color of the agent preceding $a$ on the linked list. Otherwise $pre_{a}$ is set to be $c_{a}$. 6. 6.

$suc_{a}$, a color from the set $C$. If $a$ is on a linked list, $suc_{a}$ is the color of the agent succeeding $a$ on the linked list (or $c_{a}$ if $a$ is the last agent in the linked list). Otherwise, $suc_{a}$ is the color of the agent whom $a$ is following on a linked list, to reach the end of that linked list, or $c_{a}$ if $a$ is not following a linked list yet.

Thus, the number of states used is at most $8k^{4}$.

Definitions. An agent $a$ is called a leader, iff $l_{a}$ is set. A leader $a$ is called a root, iff $r_{a}$ is set. A leader $a$ is called isolated, iff $a$ is not a root and $pre_{a}=c_{a}$.

A linked list of $n$ links, is a sequence of leaders $a_{0},a_{1},..,a_{n}$, such that only $a_{0}$ is a root, and $\forall i,0<i\leq n:suc_{a_{i-1}}=c_{a_{i}}\land pre_{a_{i}}=c_{a_{i-1}}$. A linked list is said to be consistent, iff none of its agents’ information change by any sequence of further activations, except possibly $suc_{a}$ where $a$ is the last agent on the linked list.

An isolated agent $a$ is a good agent, iff $suc_{a}$ is either $c_{a}$ or the color of one of the agents of a consistent linked list.

Initialization. Before the execution of the protocol, each agent sets $d=0$, $l=1$, $r=1$, $pre=c$ and $suc=c$.

Transition Function. Let us suppose two agents $a,b\in A$ interact, $a\neq b$. The transition function $\Gamma_{o}$ that updates their states is given by the following Python code, where clear function is for isolating an agent.

As seen above, there are 11 rules. The rules are defined for directed pair interactions, but can easily be modified to handle the undirected-interaction case.

3.1.1 Proof of Theorem 3.

We now prove the correctness of Protocol $P_{o}$ (Algorithm 1). We have the following.

Lemma 1

After some number of activations $T$, in each nonempty set $supp(c)$ of agents, only one is a leader, and among all leaders only one is a root. After such configuration is reached, the leader and root bits of all agents will never change.

Proof

The protocol never changes a leader or root bit from False to True. When two leaders with the same color interact, one of them clears its leader bit, due to Rule 1 (notice that the direction of interaction is relevant here). Therefore, the number of leaders decreases until no two leaders have the same color, after which no leader bit of any agent ever changes. Afterwards, when two roots interact, they now have different colors and only one of them remains a root, due to Rule 3. Furthermore, note that when two leaders interact where one of them is a root, the one who remains a leader is also a root, due to Rule 1. Hence, we conclude that there is always a root, and after some number of interactions the root must be unique, after which no root bit of any agent ever changes.

Let $T$ be the number of activations described in Lemma 1. Let $L$ be the set of leaders after $T$ activations and let $q\in L$ represent the unique root. We now prove, by using induction on $n$, that for any integer $n,1\leq n<|L|$, after some number of activations $t_{n}\geq T$, there is a consistent linked list of $n$ links whose agents belong to $L$.

From now on, we may refer to a leader $a\in L$ by its color $c_{a}$. Observe that, since there is only one root and no two leaders have the same color, any linked list that exists after $T$ activations, is a consistent one.

Base case $n=1$. If after $T$ activations, $q$ does not have a successor (i.e. $suc_{q}=c_{q}$), then as soon as $q$ interacts with another leader, it makes the other one its successor, due to Rule 5. Otherwise, as soon as $q$ interacts with $suc_{q}$, by Rule 5 we can be sure that they form a consistent linked list of 1 link.

Induction step. Suppose that $n+1<|L|$ and after $t_{n}\geq T$ activations, a consistent linked list of $n$ links exists. Let $v_{1}$, $v_{2}$, …, $v_{n}$ denote the agents succeeding agent $q$ on the linked list, respectively. Suppose $suc_{v_{n}}\neq c_{v_{n}}$, and let $p$ denote $suc_{v_{n}}$. Consider the first interaction between $v_{n}$ and $p$, after $t_{n}$ activations. After such interaction, if $pre_{p}=c_{v_{n}}$ and $d_{p}=d_{v_{n}}+1$, we have a consistent linked list of $n+1$ links; otherwise, Rule $7$ or Rule $9$ executes and $suc_{v_{n}}=c_{v_{n}}$. We now assume $suc_{v_{n}}=c_{v_{n}}$.

We prove the following.

Lemma 2

Suppose some number of activation $T^{\prime}\geq T$ has passed, and $q$, $v_{1}$, $v_{2}$, …, $v_{n}$ form a consistent linked list of $n$ links where $n+1<|L|$, and also $suc_{v_{n}}=c_{v_{n}}$. After some more activations, a good agent exists.

Proof (Proof of Lemma 2)

If a good agent already exists after $T^{\prime}$ activations, the claim is proved. Therefore, we assume that no good agent exists right after $T^{\prime}$ activations. Define $M=L\setminus\{q,v_{1},v_{2},...,v_{n}\}$. Let $M_{1}$ be the set of agents in $M$ which are isolated and $M_{2}=M\setminus M_{1}$. It follows from the hypothesis that $|M|>0$. First, we prove the lemma assuming $|M_{1}|=|M|$. Then, we prove the other cases by induction on the size of the $|M_{1}|$.

Case $|M_{1}|=|M|$. From the definitions above, it follows that $|M_{1}|=|M|$ implies $|M_{1}|>0$ and $|M_{2}|=0$. Let $a\in M_{1}$ be an agent. Since $a$ is not a good agent, we have $suc_{a}\neq c_{a}$. Let $b$ denote $suc_{a}$. Consider the first moment after $t_{k}$ activations in which $a$ and $b$ interact. If one of $a$ or $b$ became a good agent, we are done. Otherwise, Rule 4 executes and $a$ is cleared. Thus, after some number of activations $t\geq T^{\prime}$, $a$ is a good agent.

We now use induction on $|M_{1}|=0,1,...,|M|-1$ to prove the remaining cases.

Base case $|M_{1}|=0$. Consider an agent $a_{0}\in M_{2}$. Let agent $a_{1}$ be $prev_{a_{0}}$. If $a_{1}\in M_{2}$, let agent $a_{2}$ be $prev_{a_{1}}$. We repeat this process until we reach some agent $a_{i}$ such that either $a_{i}\notin M_{2}$ or $a_{i}=a_{j}$ for some $j<i$. Since $|M_{1}|=0$, if $a_{i}\notin M_{2}$ then $a_{i}\notin M$ and $a_{i-1}$ is cleared by the time it and $a_{i}$ interact, due to Rule 8. Note that the only way $M_{1}$ gets new members, is that an agent becomes cleared, which implies the existence of a good agent. Otherwise, $a_{i}=a_{j}$ for some $j<i$, which means that we incur in a cycle when we follow the $prev$ values of agents. In particular, there will be a pair of agents on this cycle such that when they interact (if they are not already cleared by that time), Rule 8 or Rule 9 executes and an agent is cleared. Therefore, after some activations $t\geq t_{n}$, an agent is cleared and a good agent exists.

Induction step. Suppose $h<|M|$ and the statement holds for all $|M_{1}|<h$. We show that it also holds for $|M_{1}|=h$. Again, we repeat the process described in the base case. This time, we stop at agent $a_{i}$ if any of the following holds: i) $a_{i}\notin M$, ii) $a_{i}=a_{j}$ for some $j<i$, or iii) $a_{i}\in M_{1}$.

The first two cases follow from the same argument as in the base case. In the third case, suppose that agents $a_{i-1}$ and $a_{i}$ interact at time $t_{ind}$. If an agent $a\in M$ has been cleared by time $t_{ind}$, then we have a good agent. Otherwise, if no agents has been cleared between $t_{n}$ activations and $t_{ind}$ and, by time $t_{ind}$, agent $a_{i}$ is not in $M_{1}$ anymore, then the size of $M_{1}$ has been reduced by at least 1. The latter event implies that, by induction hypothesis, after some more activations either good agent exists or, by Rule 8, an interaction between $a_{i-1}$ and $a_{i}$ clears $a_{i}$. Thus, eventually a good agent exists.

Let $a$ be a good agent, whose existence is guaranteed by Lemma 2. The only activation that changes the state of $a$, is an interaction with $suc_{a}$ (or $q$ when $suc_{a}=c_{a}$). If $suc_{a}$ is not the last agent of the linked list, it will be updated to be its successor (or $v_{1}$ when $suc_{a}=c_{a}$). Therefore, after at most $n$ such activations, $a$ interacts with the last agent on the linked list, and since $suc_{v_{n}}=c_{v_{n}}$, it is added to the linked list (provided that the linked list have not already increased its size by attaching another good agent to it). Therefore, after some activations $t_{n+1}\geq t_{n}\geq T$, a consistent linked list of $n+1$ links is formed, concluding the induction.

We have thus proved that, after some number of activations $t_{|L|-1}$, there is a consistent linked list that includes all agents from $L$. Let $a$ be the last agent on the linked list. Rule 7 ensures that after some activations, $suc_{a}=c_{a}$. Also, after some activations all non-leader agents copy the assigned number of their leader. Afterwards, the whole system stabilizes and no agent changes its state, concluding the proof of the theorem.

As a final remark notice that, for an agent $a$, there may be sequences of edge activations that lead the assigned label $d_{a}$ to reach a value which grows as a function of $n$ before stabilizing. We thus assume that the variable $d_{a}$ overflows when exceeding the largest number it can store, and gets set back to [math]. Notice that $d_{a}$ is guaranteed to be large enough to store $k$. It is straightforward to verify that this latter assumption does not affect our analysis above. ∎

4 Plurality Protocol with $\mathcal{O}(k^{11})$ States

We now come back to the original problem by proving the following result.

Theorem 4

There is a population protocol $P_{cli}$ which solves the $k$-Plurality Problem under a weakly fair scheduler, when the underlying graph is complete, by employing $\mathcal{O}(k^{11})$ states per agent.

Recall that, initially, each agent $a\in V$ obtains its initial color which we shall rename to $ic_{a}$, from a set of possible colors $C$ of size $k$. Let $m$ be $\lceil{log_{2}k}\rceil$. For the sake of simplicity, in this section we consider the underlying topology of possible interactions to be a complete graph. We show how to remove such assumption in Section General Graphs, thus proving Theorem 1. A weak scheduler activates pairs of agents to interact. The goal is for all agents to agree on the plurality color, using as few states as possible.

4.0.1 Main Intuition behind $P_{cli}$.

The protocol proposed by Gasieniec et al. [17], which we shall call $P_{r}$, solves this problem under the hypothesis that each color is denoted by a never changing $m$-bit label, such that each bit is either -1 or 1, rather than the more standard 0 or 1. We adopt the same notation and assume that the ordering protocol $P_{o}$ stores the $d$ values in such format. The idea is to run both protocols, $P_{o}$ and $P_{r}$, in parallel and, whenever for an agent $a$, $l_{a}$ and $d_{a}$ are not equal, we ensure that after some activations, $\forall i,0\leq i<m:c_{a}[i]=w(s_{a}[i])$. When the latter condition holds, we can set $l_{a}$ to be $d_{a}$ and reinitialize $c_{a}$ and $s_{a}$ according to initialization of $P_{r}$.

Notice that, since every agent is required to eventually learn the label of the plurality color, each agent also stores a color that corresponds to that label.

Memory Organization. The state of each agent $a$, encodes the following information:

$ic_{a},d_{a},ld_{a},rt_{a},pre_{a}$ and $suc_{a}$, as described for $P_{o}$ (where $c_{a}$, $l_{a}$ and $r_{a}$ in $P_{o}$ are renamed to $ic_{a}$, $ld_{a}$ and $rt_{a}$, respectively), 2. 2.

$l_{a},c_{a},s_{a}$, as described in $P_{r}$, and 3. 3.

$ans_{a}$, a color from the set $C$, which holds the relative majority color.

The number of states used is at most $8k^{11}$.

Definitions. An agent $a$ is called unstable, iff $l_{a}\neq d_{a}$. For each $i,0\leq i<m$, and for each $x$ that is an $i$-bit number with bit values either -1 or 1, let us define $L_{x}$ to be the set of all agents $a$ such that the first $i$ bits of $l_{a}$ are equal to $x$.

Initialization. Before the execution of the protocol, for each agent $a$, the variables $d_{a},ld_{a},rt_{a},pre_{a}$ and $suc_{a}$ are initialized according to $P_{o}$. Note that, instead of all bits set to 0, $d_{a}$ has all bits set to -1. Moreover, we set $l_{a}=d_{a}$ and initialize $c_{a}$ and $s_{a}$ according to $P_{r}$. $ans_{a}$ is set to be $ic_{a}$.

Transition Function. We now define the transition function $\Gamma_{cli}$. Let us suppose that two agents $a$ and $b$ are activated, with $a\neq b$. Let $\Gamma_{o}$ be the transition function of $P_{o}$, and $\Gamma_{r}$ be the transition function of $P_{r}$.

First, the values related to $P_{o}$ are updated according to $\Gamma_{o}$. If $l_{a}$ or $l_{b}$ is the label of the winning color in $P_{2}(0)$ (as described in $P_{r}$), let us set $ans_{a}=ic_{a}$ or $ans_{a}=ic_{b}$, respectively. Afterwards,

If $d_{a}=l_{a}$ and $d_{b}=l_{b}$, we update the values related to $P_{r}$ according to $\Gamma_{r}$. 2. 2.

If $d_{a}\neq l_{a}$, let $L_{a}=\{i|0\leq i<m\land c_{a}[i]<w(s_{a}[i])\}$, and let $G_{a}=\{i|0\leq i<m\land c_{a}[i]>w(s_{a}[i])\}$. Let $L_{b}$ and $G_{b}$ be analogously defined. If $L_{a}\cup G_{a}=\emptyset$, we set $l_{a}=d_{a}$ and initialize $c_{a}$ and $s_{a}$ according to initialization rule of $P_{r}$. Otherwise, let $M$ be $L_{a}\cup G_{a}$ if $d_{b}=l_{b}$, $(L_{a}\cup G_{a})\cap(L_{b}\cup G_{b})$ otherwise. For each $i\in M$, if $l_{a}$ and $l_{b}$ share the same $i$-bit prefix, we have that

1. (a)

If $i\in(L_{a}\cap G_{b})\cup(G_{a}\cap L_{b})$, set $s_{a}[i]=[c_{a}[i]]$ and $s_{b}[i]=[c_{b}[i]]$, 2. (b)

Otherwise, update $s_{a}[i]$ and $s_{b}[i]$ according to $\Gamma_{r}$.

If $d_{b}=l_{b}$, we update the array $c_{b}$ and, if needed, we propagate the changes as in $\Gamma_{r}$.

4.0.2 Proof of Theorem 4.

First, we prove that for each $i,0\leq i<m$, and for each $x$ that is an $i$-bit number with bit values equal to either -1 or 1, the two invariants of $P_{2}(i)$ hold for $L_{x}$, that is

$\sum_{a\in L_{x}}c_{a}[i]=\sum_{a\in L_{x}}w(s[i])$, and 2. 2.

$\forall a\in L_{x},|w(s_{a}[i])-c_{a}[i])|\leq 1$.

The interactions in which states are updated according to $P_{r}$ satisfy the invariants due to the correctness of $P_{r}$. The other interactions can be divided into the following two cases.

For any agent $a$, if $l_{a}$ changes and the change includes a bit from the $i$-bit prefix of $l_{a}$, we know that $c_{a}[i]=w(s[i])$ by definition of the protocol. Therefore, if $a$ is in $L_{x}$ before the change, the same value is subtracted from both sides of the first invariant. Otherwise, if $a$ is in $L_{x}$ after the change, the same value is added to both sides of the first invariant. Moreover, since after the reinitialization of $a$ it is still the case that $c_{a}[i]=w(s[i])$, the invariants hold. 2. 2.

If $a\in L_{x}$ and $b$ are two agents such that $s_{a}[i]$ and $s_{b}[i]$ changes simultaneously, then we know that $b\in L_{x}$ by definition of the protocol and, because of the second invariant, either $c_{a}[i]=w(s_{a}[i])-1$ and $c_{b}[i]=w(s_{b}[i])+1$, or $c_{a}[i]=w(s_{a}[i])+1$ and $c_{b}[i]=w(s_{b}[i])-1$. In both cases, $w(s_{a}[i])+w(s_{b}[i])$ remains unchanged after $s_{a}[i]$ is set to $[c_{a}[i]]$ and $s_{b}[i]$ is set to $[c_{b}[i]]$, so the first invariant holds. It is immediate to check that the second invariant still holds as well.

We proved that the two invariants hold throughout the execution of the protocol. It follows from the correctness of $P_{o}$ that after some number of activations $T_{o}$, for each agent $a$, $d_{a}$ doesn’t change anymore.

Lemma 3

After some number of activations $T\geq T_{o}$, for each agent $a$, $l_{a}$ equals $d_{a}$.

By the definition of $P_{cli}$, since $d_{a}$ remains unchanged after $T$ activations, it is obvious that $l_{a}$ remains unchanged as well. Thus, from the correctness of $P_{r}$, it follows that the whole system eventually stabilizes and every agent knows the label of the plurality color. Furthermore, when an agent $a$ interacts with an agent $b$ with the winning color label, $P_{cli}$ sets $ans_{a}$ to $ic_{b}$. Otherwise, if $a$ has the winning color itself, as soon as it is activated it sets $ans_{a}$ to $ic_{a}$ (if it is not set already). Therefore, it only remains to prove Lemma 3.

4.0.3 Proof of Lemma 3.

Suppose $T_{o}$ activations have passed. Since after $T_{o}$ activations, the $d$ value of agents remains unchanged, by the definition $P_{cli}$ it immediately follows that the number of unstable agents never increases.

Hence, to conclude the proof it suffices to prove the following fact.

Fact 1

Suppose that, after some number of activations $T\geq T_{o}$ have passed, an unstable agent still exists. Then, after some additional number of activations, the number of unstable agents decreases.

To see why Fact 1 holds, suppose that some number of activations $T\geq T_{o}$ have passed and $a$ is an unstable agent. Let $I=\{i|0\leq i<m\land c_{a}[i]\neq w(s_{a}[i]))\}$. Since the protocol does not change $s_{a}[i]$ and $c_{a}[i]$ for all $i\notin I$, the size of $I$ never increases. We prove Fact 1 by induction on $|I|$.

Base case $|I|=0$. As soon as $a$ is activated, it will set $l_{a}$ to $d_{a}$ and thus the number of unstable agents will decrease.

Induction step. Suppose $|I|=n,0<n\leq|A|$, and for all $|I|<n$, after some activations either $I=\emptyset$ or the number of unstable agents decreases. Let $i\in I$ be an integer, and let $x$ denote the $i$-bit prefix of $l_{a}$. Let $U$ be the set of all agents $a\in L_{x}$ such that $a$ is unstable and $c_{a}[i]=w(s_{a}[i])$. $P_{cli}$ does not let agents in $U$ interact in $P_{2}(i)$, but any two agents from $L_{x}\setminus U$ can interact with each other. It can easily be seen that the two invariants hold for agents in $L_{x}\setminus U$ in $P_{2}(i)$. After some interactions, we can distinguish the following cases: i) an unstable agent in $U$ becomes stable, ii) an unstable agent becomes stable and is added to $L_{x}$, or iii) the agents in $L_{x}\setminus U$ in $P_{2}(i)$ stabilize.

In the latter case, suppose without loss of generality that $c_{a}[i]<w(s_{a}[i])$. By the first invariant of $P_{2}(i)$ on $L_{x}\setminus U$, we know that there will be another agent $b\in L_{x}\setminus U$ such that $c_{b}[i]>w(s_{b}[i])$. As soon as $a$ and $b$ interact, the protocol ensures that after the interaction, $i\notin I$. Thus, after some number of activations, either the number of unstable agents decreases or the size of $I$ decreases. Hence, Fact 1 follows by the induction hypothesis, and the proof of Lemma 3 is completed. ∎

5 General Graphs

The protocol $P_{cli}$ works on complete directed graphs, but it can be easily modified to work on complete undirected graphs. We now present a protocol $P_{gen}$ which works on undirected connected graphs, under a globally fair scheduler, and finally prove our main result, Theorem 1.

5.0.1 Plurality Protocol on General Graphs.

The idea is that, whenever a pair of agents is activated, the two agents can swap their updated states. This way, the agents effectively travel on the nodes of the underlying graph and possibly interact with other agents that were not initially adjacent.

Therefore, let us define the transition function $\Gamma_{gen}(p,q)=\Gamma_{cli}(q,p)$, where $\Gamma_{cli}$ is the transition functions of modified $P_{cli}$. The initialization of $P_{gen}$ is the same as that of $P_{cli}$

Proof (Proof of Theorem 1)

Let $G$ be any connected graph. Let $\smash{\smash{S}^{(0)}}$, $\smash{S}^{(1)}$ , … any an infinite sequence of configurations obtained by running $P_{gen}$ on $G$ under a globally fair scheduler, where $\smash{\smash{S}^{(0)}}$ is the initial configuration. Since the number of possible states is finite, the number of possible configurations is also finite. Therefore, there exists a configuration $\smash{S}$ that appears infinitely often in the sequence.

For all distinct pairs $u,v\in V(G)$, let $Path_{u,v}$ be a series of edges forming a path from $u$ to $v$, and suppose that the edges in $Path_{u,v}$ gets activated first in the order in which they appear in the path, and then in reverse order. Let $\mathcal{E}_{u,v}$ be the concatenation of such edge activations. If we activate edges according to $\mathcal{E}_{u,v}$, then $u$ travels along $Path_{u,v}$ (possibly interacting with some other agents), until it interacts with $v$, and then travels back to its position. Therefore, the sequence of activations $\mathcal{E}_{u,v}$ ensures that pair $\{u,v\}$ of agents interact with each other at least once. If we keep activating edges according to the sequences $\{\mathcal{E}_{u,v}\}_{u,v\in V}$, for each pair of agents $\{u,v\}$, then starting from $\smash{S}$, each pair of agents interact infinitely often.

Remark that, a globally fair scheduler is also a weakly fair one. By correctness of $P_{cli}$ under a weakly fair scheduler (Theorem 4), by repeating the mentioned edge activation sequence starting from $\smash{S}$, a stable configuration $\smash{S}^{\prime}$ will be reached (a configuration in which all agents know the initial plurality color, and their guess remains correct thereafter). Therefore, $\smash{S}^{\prime}$ is reachable from $\smash{S}$. By the definition of a globally fair scheduler, since $\smash{S}$ is infinitely reached, the stable configuration $\smash{S}^{\prime}$ is eventually reached.