Distributed Voting/Ranking with Optimal Number of States per Node

TL;DR

This paper introduces a scalable distributed algorithm for multi-choice voting and ranking in networks, using a minimal and optimal number of node states, with proven efficiency and complexity analysis.

Contribution

It presents a novel distributed voting/ranking algorithm that is simple, scalable, and uses an optimal number of states, with proven optimality in ranking and conjectured optimality in voting.

Findings

Algorithm uses only K×2^{K-1} states for voting.

Time complexity is O(log(n)) in complete graphs.

Number of states is proven optimal for ranking.

Abstract

Considering a network with $n$ nodes, where each node initially votes for one (or more) choices out of $K$ possible choices, we present a Distributed Multi-choice Voting/Ranking (DMVR) algorithm to determine either the choice with maximum vote (the voting problem) or to rank all the choices in terms of their acquired votes (the ranking problem). The algorithm consolidates node votes across the network by updating the states of interacting nodes using two key operations, the union and the intersection. The proposed algorithm is simple, independent from network size, and easily scalable in terms of the number of choices $K$, using only $K\times 2^{K-1}$ nodal states for voting, and $K\times K!$ nodal states for ranking. We prove the number of states to be optimal in the ranking case, this optimality is conjectured to also apply to the voting case. The time complexity of the algorithm is analyzed in complete graphs. We show that the time complexity for both ranking and voting is $O(\log(n))$ for given vote percentages, and is inversely proportional to the minimum of the vote percentage differences among various choices.

Figures

Equations

$$m_{i,|v_i(t^{+})|}(t^{+}):=v_i(t^{+}),m_{j,|v_j(t^{+})|}(t^{+}):=v_j(t^{+}),$$

$${\pi }_k=\{\begin{array}{ll}{m}_{i,k}(t)\backslash m_{i,k-1}(t),& \text{mbox}ifk>1,\\ m_{i,1}(t),& k=1.\end{array}$$

$$|v_i(t)|\le |v_j(t)|⟹v_i(t)\subseteq v_j(t),\forall i,j\in \{1,\cdots ,n\}.$$

$$V(X(t))=n{K}^2-\sum _{i=1}^n|v_i(t){|}^2.$$

$$V(X(t^{+}))-V(X(t))=-[(l+l^{\prime }-r{)}^2+r^2]+(l^2+l^{{\prime }^2})\le -1,$$

$${\tau }_x=\min \{t>0|X(t)\in {\mathcal{X}}_0\}.$$

$$T_{pq}=\min \{t\ge 0\mid Y(0)=p,Y(t)=q\},$$

$$\sigma =\underset{p,q\in V}{\max }\mathbb{E}\{T_{pq}\}.$$

$$\mathbb{E}\{V(X(t+2\sigma ))-V(X(t))\mid X(t)=y\}\le -ϵ,\text{mbox}ify\notin {\mathcal{X}}_0,$$

$$C_{pq}=\min \{t\ge 0\mid Y(t)=Z(t),Y(0)=p,Z(0)=q\}.$$

$$\underset{p,q\in V}{\min }\mathrm{Pr}\{C_{pq}\le t_0\}\ge 1-\frac{\sigma }{t_0}.$$

$$\mathrm{Pr}({\tau }_x<\infty )=1,\forall x\notin {\mathcal{X}}_0.$$

$$v^k=\{\begin{array}{l}{v}_i(\tau ),\exists i\in \{1,\cdots ,n\}:|v_i(\tau )|=k,\\ \varnothing ,\text{mbox}otherwise.\end{array}$$

$$\begin{array}{r}(\{c_1\},\varnothing ),(\{c_1\},\{c_2\}),(\{c_1\},\{c_3\}),(\{c_1\},\{c_2,c_3\})\\ (\{c_2\},\varnothing ),(\{c_2\},\{c_1\}),(\{c_2\},\{c_3\}),(\{c_2\},\{c_1,c_3\})\\ (\{c_3\},\varnothing ),(\{c_3\},\{c_1\}),(\{c_3\},\{c_2\}),(\{c_3\},\{c_1,c_2\})\end{array}$$

$$\begin{array}{rl}{a}_i(t^{+})& :=[{\Pi }_{A_1,a_i(t)},{\Pi }_{A_2\backslash A_1,a_i(t)},{\Pi }_{\mathcal{C}\backslash A_2,a_i(t)}],\\ a_j(t^{+})& :=[{\Pi }_{A_1,a_j(t)},{\Pi }_{A_2\backslash A_1,a_j(t)},{\Pi }_{\mathcal{C}\backslash A_2,a_j(t)}],\end{array}$$

$$a_i(t)=[\stackrel{\downarrow }{1}$$

$$⟶a_i(t^{+})=[1,\stackrel{\downarrow }{2},3,4],a_j(t^{+})=[\stackrel{\downarrow }{1},2,4,3],$$

$$a_i(t)=[\stackrel{\downarrow }{1}$$

$$⟶a_i(t^{+})=[1,\stackrel{\downarrow }{3},4,2],a_j(t^{+})=[3,1,2,\stackrel{\downarrow }{4}],$$

$$N_1=$$

$$\displaystyle\Big{\{}[\#\pi_{1},\cdots,\#\pi_{K}]\in\mathbb{Z}_{+}^{K}:\displaystyle\sum_{i=1}^{K}\#\pi_{i}=n;\#\pi_{i}>\#\pi_{j},\forall i>j\Big{\}}.$$

$$N_{2}=\Big{\{}[n_{1},\cdots,n_{D_{r}}]\in\mathbb{Z}_{+}^{D_{r}}:\displaystyle\sum_{i=1}^{D_{r}}n_{i}=n\Big{\}}.$$

$$\begin{split}&|N_{1}|=\\ &=\frac{1}{K!}\Big{|}\Big{\{}[\#\pi_{1},\cdots,\#\pi_{K}]\in\mathbb{Z}_{+}^{K}:\displaystyle\sum_{i=1}^{K}\#\pi_{i}=n,\#\pi_{i}\neq\#\pi_{j}\Big{\}}\Big{|}\\ &\geq\frac{1}{K!}\Big{(}\Big{|}\Big{\{}[\#\pi_{1},\cdots,\#\pi_{K}]\in\mathbb{Z}_{+}^{K}:\displaystyle\sum_{i=1}^{K}\#\pi_{i}=n\Big{\}}\Big{|}-\\ &\displaystyle\sum_{j,k}\Big{|}\Big{\{}[\#\pi_{1},\cdots,\#\pi_{K}]\in\mathbb{Z}_{+}^{K}:\displaystyle\sum_{i=1}^{K}\#\pi_{i}=n,\#\pi_{j}=\#\pi_{k}\Big{\}}\Big{|}\Big{)}\\ &={n+K-1\choose K-1}-{K\choose 2}\times{n+K-2\choose K-2}=\Theta(n^{K-1}).\end{split}$$

$$\begin{array}{rl}\mathbb{E}\{{\tau }_1\}=\sum _{i=0}^{r-1}\mathbb{E}\{T_{r-i}^1\}& =\sum _{i=0}^{r-1}\frac{n}{2}\times \frac{1}{(r-i)(s-i)}\\ & \approx \frac{n}{2(s-r)}\log (\frac{r(s-r)}{s}),\end{array}$$

$$\mathrm{Var}({\tau }_1)$$

$$\begin{array}{rl}\mathbb{E}\{{\tau }_2\}\le \sum _{i=0}^{r-1}\mathbb{E}\{T_{r-i}^2\}& =\sum _{i=0}^{r-1}\frac{n}{2}\times \frac{1}{(r-i)(n-2n\rho )}\\ & \approx \frac{1}{2(1-2\rho )}\log (2n\rho ),\end{array}$$

$$\mathbb{E}\{\tau_{1}+\tau_{2}\}\leq\frac{1}{2(1-2\rho)}\times\Big{(}\log(\frac{n\rho(1-2\rho)}{1-\rho})+\log(2n\rho)\Big{)}.$$

$$\begin{array}{rl}{X}^{k,l}(t)\in {\mathcal{X}}_0^{k,l}\text{mbox}if|v_i^{\prime }(t)|\le |v_j^{\prime }(t)|⟹v_i^{\prime }(t)& \subseteq v_j^{\prime }(t),\\ & \forall i,j\in \{1,\cdots ,n\}.\end{array}$$

$$\begin{array}{rl}\forall i,j\in & \{1,\cdots ,n\},|v_i(t)|\le |v_j(t)|⟺v_i(t)\subseteq v_j(t)\\ ⟹& |v_i^{\prime }(t)|\le |v_j^{\prime }(t)|\text{mbox}and{v}_i^{\prime }(t)\subseteq v_j^{\prime }(t)⟹X^{k,l}(t)\in {\mathcal{X}}_0^{k,l}.\end{array}$$

$$\mathbb{E}\{Z_{max}\}\leq\frac{1}{R}\displaystyle\sum_{r=1}^{R}\mu_{r}+\sqrt{\frac{R-1}{R}\displaystyle\sum_{r=1}^{R}\Big{[}\sigma_{r}^{2}+(\mu_{r}-\frac{1}{R}\displaystyle\sum_{r=1}^{R}\mu_{r})^{2}\Big{]}}$$

$$\begin{split}\mathbb{E}\{\tau_{x}\}&\leq\mu+\sqrt{\displaystyle\sum_{k,l\in V,k\neq l}\Big{[}\mathrm{Var}(\tau_{x}^{k,l})+(\mathbb{E}\{\tau_{x}^{k,l}\}-\mu)^{2}\Big{]}}\\ &=O(\frac{\log(n)}{\underset{j=1,\cdots,K-1}{\min}\rho_{j+1}-\rho_{j}}),\end{split}$$

$$\begin{array}{r}\mathbb{E}\{{\tau }_j^{\prime }\}\le \frac{n}{2}\sum _{i=0}^{n-1}\frac{1}{(n-i)(n{\rho }_j-n{\rho }_{j+1})}\approx \frac{1}{2({\rho }_j-{\rho }_{j+1})}\log (n),\\ \mathrm{Var}({\tau }_j^{\prime })\le \frac{n^2}{4}\sum _{i=0}^{n-1}\frac{1}{(n-i{)}^2(n{\rho }_j-n{\rho }_{j+1}{)}^2}\approx \frac{1}{4({\rho }_j-{\rho }_{j+1}{)}^2}.\end{array}$$

Full text

I Introduction

One of the key building blocks in distributed function computation is “Majority Voting”. It can be employed as a subroutine in many network applications such as target detection in sensor networks [1, 2], distributed hypothesis testing [3], quantized consensus [4], voting in distributed systems [5], and molcular nanorobots [6]. In the distributed majority voting, each node chooses a candidate from a set of choices and the goal is to determine the candidate with the majority vote by running a distributed algorithm. As an example in target detection [1], wireless sensors combine their binary decisions about the presence of a target through majority voting, and send a report to the fusion center if the majority is in favor of presence.

The majority voting problem for the binary case has been extensively studied in cellular automata (CA) literature. In [7], it has been shown that there is no synchronous deterministic two-state automaton that can solve binary voting problem in a connected network. Several two-state automata have been proposed for the ring topology [8, 9], the most successful of which can get the correct result in nearly $83\%$ of initial configurations of selected votes [10]. In order to circumvent the impossibility result of [7], asynchronous and probabilistic automata have also been presented in CA community [11, 12, 13]. However, none of them can obtain the correct result with probability one [14]. Using a different approach, binary voting problem can be solved by a randomized gossip algorithm [15] that computes the average of initial node values. The drawback of this approach is that the number of required states in its quantized version [16] grows linearly in terms of the network size [14].

In applying gossip algorithms to the implementation of binary majority voting, node does not need to come up with the exact average of the node values; it suffices to determine interval to which the average node values belongs. From this observation, Bénézit et al. [17] proposed an elegant solution based on an automaton, with the state space $\{0,0.5^{-},0.5^{+},1\}$, which resembles the idea in [16]. The initial state of nodes voting for “0” or “1” is [math] or $1$, respectively. When two neighbor nodes get in contact with each other, they exchange their states and update them according to a transition rule. It can be shown that the states of all nodes would be in the set $\{0,0.5^{-}\}$ at the end of the algorithm, if the choice “0” is in majority. Otherwise, the state of all nodes would belong to the set $\{0.5^{+},1\}$. In [14], a Pairwise Asynchronous Graph Automata (PAGA) has been used to extend the above idea to the multiple choice voting problem, and sufficient conditions for convergence are stated. This approach results in a 15-state automaton and a 100-state automaton for the ternary and quaternary voting problems, respectively. For majority voting with more than four choices, pairwise and parallel comparison among the choices, has been proposed [14], requiring $\Theta(2^{K(K-1)})$ number of states in terms of the number of choices, $K$. At the end, authors posed a few open problems. One of the main problems is whether voting automata exist for any number of multiple choices without running multiple binary or ternary voting automata in parallel? Furthermore, what is the minimum number of states of a possible solution?

In more recent works [18, 19, 20, 21], it has been shown that the majority vote can be obtained with high probability if the initial votes are sufficiently biased to the majority or the network size is large enough. However, none of these works can guarantee convergence to the correct result.

A generalization of the distributed voting problem, is the distributed ranking problem in which the goal is to rank all the $K$ choices in terms of the number of votes, each get from different network nodes [20]. In this paper, we propose a Distributed Multi-choice Voting/Ranking (DMVR) Algorithm for solving the majority voting and ranking problems in general networks. The proposed algorithm may also be applied where each node is allowed to vote for more than one choice. Our main contributions are summarized as follows:

• •

Our proposed DMVR algorithm provides a simple and easily scalable approach for distributed voting and ranking that works for any number $K$ of choices, requiring $K\times 2^{K-1}$ and $K\times K!$ number of states for the voting and ranking problems, respectively. For instance, the number of required states is $12$ for ternary voting, and $32$ for quaternary voting, compared to respectively $15$ and $100$ states in the case of PAGA algorithm [14]. Furthermore, unlike the randomized gossip algorithms [16, 15], the number of states is independent from the network size.

• •

We establish a lower bound on the number of required states in any ranking algorithm, and show that the DMVR algorithm achieves this bound. Compared to the existing algorithms, the state of the DMVR algorithm can be encoded by roughly $\Theta(K\log(K))$ bits.

• •

In complete graphs, we analyze the time complexity of the DMVR algorithm for the ranking problem. We will show how the time complexity is related to the percentage of nodes voting for different choices. Besides, we propose a modification for speeding up the DMVR algorithm for the majority voting problem.

The remainder of this paper is organized as follows: In Section II, the DMVR algorithm for majority voting and ranking is described. Section III studies the convergence of the DMVR algorithm. Furthermore, the number of states of the DMVR algorithm is analyzed in both cases of voting and ranking. Section IV is devoted to analyze the time complexity of the DMVR algorithm in complete graphs. In Section V, simulation results are provided. Finally, we conclude the paper in Section VI.

II The Distributed Multi-choice Voting/Ranking (DMVR) algorithm

II-A Problem Statement

Consider a network with $n$ nodes. The topology of the network is represented by a connected undirected graph, $G=(V,E)$, with the vertex set $V=\{1,...,n\}$, and the edge set $E\subseteq V\times V$, such that $(i,j)\in E$ if and only if nodes $i$ and $j$ can communicate directly. Furthermore, it is assumed that each node is equipped with a local clock which ticks according to a Poisson process with rate one. Initially, each node $i$ chooses a choice from a set of $K$ choices $\mathcal{C}=\{c_{1},\cdots,c_{K}\}$. Let $\#c_{k}$ be the number of nodes that select the choice $c_{k}$ and $\rho_{k}\triangleq\frac{\#c_{k}}{n}$. In the majority voting problem, the goal is to find the choice $c_{k}$ in majority, i.e. the choice $c_{k}$ satisfying $\#c_{k}\geq\#c_{j},j\in\{1,\cdots,K\}$. In the ranking problem, the desired output is a permutation, $[\pi_{1},\cdots,\pi_{K}]$ of $\mathcal{C}$ such that $\#\pi_{k}\geq\#\pi_{k+1},\forall k$.

II-B Description of the DMVR algorithm

A value set $v_{i}(t)$ is associated with each node $i$ at time $t$. At $t=0$, the only member of $v_{i}(0)$ is the selected choice of node $i$. In the process of the algorithm, $v_{i}(t)$ always remains a subset of $\mathcal{C}$. The algorithm essentially performs two function. One function of the algorithm deals with consolidating node choices across the network. This function utilizes two key operations, the union and the intersection, in order to update the value sets $v_{i}(t)$ and $v_{i}(t)$ of nodes $i$ and $j$, when they interact. The second part of the algorithm has to do with disseminating the consolidated result of part one throughout the network. For reasons to be clarified later, the above two functions of the algorithm are executed in parallel, not sequentially. The second function of the algorithm operates on a collection of sets $m_{i,k}(t)$, $1\leq k\leq K$, at each node $i$. We collectively refer to the sets $m_{i,k}(t)$, $1\leq k\leq K$, of node $i$ as memory of it. Each $m_{i,k}(t)$ is a subset of $\mathcal{C}$. Unlike the dissemination function, the consolidation function is identical for the voting and ranking. In the following, we describe the dissemination function for the more general case, i.e. for the ranking case, the dissemination for the voting case being a special and simplified version of it.

When node $i$’s clock ticks at time $t$, it chooses one of the neighbor nodes, say node $j$, randomly. Then, nodes $i$ and $j$ update their value sets and memories according to the following transition rules:

[TABLE]

where there is no memory updating if $v_{i}(t^{+})=\emptyset$. Furthermore, we have: $m_{i,k}(t^{+})=m_{i,k}(t)$ for $\forall k\neq|v_{i}(t^{+})|$, $\forall i\in\{1,\cdots,n\}$.

When the algorithm converges111In Section III, Theorem 1, we will describe when the algorithm eventually converges to the correct result., each node $i$ can obtain the correct ranking as follows222 The “$\backslash$” is the set-theoretic difference operator, i.e. $A\backslash B=\{x:x\in A,x\not\in B\}$ for any sets $A$ and $B$.:

[TABLE]

In the case of the majority voting problem, it suffices to keep the memory $m_{i,1}(t)$ at each node $i$. We denote $m_{i,1}(t)$ by $m_{i}(t)$ when the DMVR algorithm is executed for the majority voting problem. The description of the DMVR Algorithm is given in Algorithm 1.

Suppose that $|v_{i}(t)|\leq|v_{j}(t)|$. It is not difficult to show that the updating rule in (1) has the following properties:

• •

Define the size of choice $c_{k}$ as: $|\{i\mid c_{k}\in v_{i}(t)\}|$. The size of every choice $c_{k}$ is preserved during the updates.

• •

We have $v_{j}(t^{+})\subseteq v_{i}(t^{+})$. If $v_{i}(t)\subseteq v_{j}(t)$, the two nodes just exchange their value sets.

• •

The quantity $|v_{i}(t)|^{2}+|v_{j}(t)|^{2}$ strictly increases if $v_{i}(t)\not\subseteq v_{j}(t)$. Otherwise, it remains unchanged.

III Convergence Analysis

In this section, we will show that the DMVR algorithm converges to the correct solution for the majority voting and ranking problems. First, we study how value sets consolidate and get in a convergence set, by defining a Lyapunov function. Then, we discuss how memory updating can disseminate the correct result in parallel to value set updating. Next, we merge value sets and memories of the DMVR algorithm in order to reduce memory usage in both majority voting and ranking problems. At the end, we prove that the proposed implementation is optimal in terms of the required number of states for the ranking problem.

III-A Consolidation of Value Sets

In this part, we analyze how value sets consolidate in the network until the state of the system gets in a convergence set.

Definition 1**.**

Let the network state vector at time $t$ be defined as $X(t)=[v_{1}(t),\cdots,v_{n}(t)]$. The set of all state vectors $X(t)=[v_{1}(t),\cdots,v_{n}(t)]$ with the following property is called the convergence set and is denoted by $\mathcal{X}_{0}$:

[TABLE]

Example 1**.**

Consider a network of $n=8$ nodes and three possible choices $\mathcal{C}=\{c_{1},c_{2},c_{3}\}$. Assume that $X(0)=[\{c_{1}\},\{c_{1}\},\{c_{2}\},\{c_{3}\},\{c_{1}\},\{c_{3}\},\{c_{2}\},\{c_{1}\}]$. The state vector $X(t)=[\{c_{1}\},\emptyset,\{c_{1},c_{2},c_{3}\},\emptyset,\emptyset,\{c_{1},c_{2}\},\{c_{1},c_{3}\},\emptyset]$ cannot be in the set $\mathcal{X}_{0}$ since $\{c_{1},c_{2}\}\not\subseteq\{c_{1},c_{3}\}$. However, the state vector $X(t)=[\{c_{1},c_{2},c_{3}\},\emptyset,\{c_{1},c_{2},c_{3}\},\emptyset,\emptyset,\{c_{1}\},\{c_{1}\},\emptyset]$ is a member of the convergence set.

Lemma 1**.**

If $X(\tau)\in\mathcal{X}_{0}$ at time $\tau>0$, then $X(t)\in\mathcal{X}_{0}$, $\forall t\geq\tau$.

Proof:

Assume that the state vector $X(\tau)$ is in $\mathcal{X}_{0}$. If two nodes $i$ and $j$ get in contact with each other at any time $t>\tau$, then according to Definition 1, the outputs of transition, i.e. the sets $\{v_{i}(t)\cap v_{j}(t)\}$ and $\{v_{i}(t)\cup v_{j}(t)\}$ would be $\{v_{i}(t)\},\{v_{j}(t)\}$ or $\{v_{j}(t)\},\{v_{i}(t)\}$. Since we know that $X(\tau)\in\mathcal{X}_{0}$, $X(t)$ is also in $\mathcal{X}_{0}$. Thus, the proof is complete. ∎

Definition 2**.**

The Lyapunov function $V(X(t))$ is defined as follows:

[TABLE]

Lemma 2**.**

If two nodes $i$ and $j$ contact with each other at time $t$, and $v_{i}(t)\not\subseteq v_{j}(t),v_{j}(t)\not\subseteq v_{i}(t)$, then there would be a reduction in the Lyapunov function $V(X(t))$.

Proof:

Suppose that $|v_{i}(t)|=l$, $|v_{j}(t)|=l^{\prime}$, and $|v_{i}(t)\cap v_{j}(t)|=r$. The change in the Laypunov function is:

[TABLE]

which is strictly less than zero for all $0\leq r\leq\min(l,l^{\prime})-1$. ∎

Definition 3**.**

Let $X(0)=x$. We denote the time that the state vector hits the set $\mathcal{X}_{0}$ for the first time by $\tau_{x}$, i.e.:

[TABLE]

Definition 4**.**

Let $Y(t)$ be a random walk on the network starting from node $p$. We define $T_{pq}$ to be the first time $Y(t)$ visits node $q$:

[TABLE]

and the worst case hitting time, $\sigma$, is defined as follows:

[TABLE]

Lemma 3**.**

There exists $\epsilon>0$ such that:

[TABLE]

where $\sigma$ is defined in (8).

Proof:

Consider two random walks $Y(t)$ and $Z(t)$ on the network starting from nodes $p$ and $q$, respectively. We define the coalescing time of two random walks $Y(t),Z(t)$ as follows:

[TABLE]

It follows from Markov inequality that:

[TABLE]

If $X(t)\not\in\mathcal{X}_{0}$, then there exist $v_{i}(t)$, $v_{j}(t)$ such that $v_{i}(t)\not\subseteq v_{j}(t),v_{j}(t)\not\subseteq v_{i}(t)$. The corresponding random walks meet each other (or some other intermediate such value sets) up to time $t+2\sigma$ with probability at least $\frac{1}{2}$, which results in reduction of $V(X(t))$ according to Lemma 2. Otherwise, $X(t)$ is in the set $\mathcal{X}_{0}$.

∎

Lemma 4**.**

The state vector $X(t)$ hits the set $\mathcal{X}_{0}$ in bounded time with probability one.

Proof:

We know that the Lyapunov function $V(X(t))$ is lower bounded by zero. According to Foster’s criteria (see [22], page 21) and Lemma 3, it follows that:

[TABLE]

∎

III-B Dissemination of Result in Memories

In this part, we show how memory updating disseminates the correct result in the network. Without loss of generality, in the remainder of this paper, we assume that $\#c_{1}>\#c_{2}>\cdots>\#c_{K}$.333We assume that $\#c_{K}>0$. Otherwise, we can reduce the problem to the case with fewer choices. By slight modifications, the DMVR algorithm can also work for the cases where we have choices with equal size.

Definition 5**.**

Assume that the state vector $X(t)$ gets in $\mathcal{X}_{0}$ at time $\tau$. We define the vector $v^{\star}=[v^{1},\cdots,v^{K}]$ as follows:

[TABLE]

and r_{k}(t)=\big{|}\left\{i\big{|}|v_{i}(t)|=k\right\}\big{|}.

Theorem 1**.**

The vector $[\pi_{1},\cdots,\pi_{K}]$ defined in (2), gives the correct ranking of choices in a finite time with probability one.

Proof:

From Lemma 4, we know that the state vector $X(t)$ eventually gets in the set $\mathcal{X}_{0}$ at time $\tau_{x}$. For a choice $c_{k}$, let $\alpha(k)$ be the smallest index such that $c_{k}\in v^{\alpha(k)}$. According to the definition of the convergence set and the preservation property, we know that: $\#c_{k}=\displaystyle\sum_{i=\alpha(k)}^{K}r_{i}(t)$. Hence, we have: $\#c_{k}>\#c_{k^{\prime}}\Longleftrightarrow\alpha(k)<\alpha(k^{\prime})$. Thus, based on assumption $\#c_{1}>\#c_{2}>\cdots>\#c_{K}$, the only possibility is: $r_{k}(t)>0$ and $\alpha(k)=k$, $\forall k\in\{1,\cdots,K\}$ for all $t>\tau_{x}$. Since $r_{k}(t)>0$, there exists at least one value set $v^{k}$, $1\leq k\leq K$ in the network. The value sets $v^{k}$ take random walk in the network and set the memories $m_{i,k}(t)$ to $v^{k}$ for all $i\in\{1,\cdots,n\}$. Let $\tau^{\prime}>\tau_{x}$ be the time that $m_{i,k}(t)=v^{k}$, $\forall i\in\{1,\cdots,n\},1\leq k\leq K$. Based on the definition of $\alpha(k)$, we have: $c_{k}=v^{\alpha(k)}\backslash v^{\alpha(k)-1}=m_{i,k}(t)\backslash m_{i,k-1}(t)$. Hence, all nodes obtain the correct ranking after time $\tau^{\prime}$. ∎

From above theorem, $m_{i,1}(t)$ gives the choice in majority. Hence, the DMVR algorithm can solve the majority voting problem by just updating $m_{i}(t)=m_{i,1}(t)$.

Remark 1**.**

In the proposed solution, each node can also vote for more than one choice. To do so, it is sufficient to initialize the value set of each node to the union of its preferred choices. In this general case as well, the DMVR algorithm gives the correct ranking based on the size of choices.

III-C State-optimal Implementation of DMVR Algorithm

For the case of majority voting, the state of node $i$ is the pair $(m_{i}(t),v_{i}(t))$ where the sets $m_{i}(t)$ and $v_{i}(t)$ have $K$ and $2^{K}$ possible states, respectively. Thus, the total number of states is $K\times 2^{K}$. However, we can implement the DMVR algorithm with fewer states by adding the following rules:

• •

If the output of updating rule, $v_{i}(t)\cap v_{j}(t)$, is the empty set, we replace it by the set $\mathcal{C}$.

• •

If $m_{i}(t^{+})\not\subseteq v_{i}(t^{+})$, we select a random member $c_{k}\in v_{i}(t^{+})$ and change $m_{i}(t^{+})$ to $\{c_{k}\}$. Otherwise, $m_{i}(t^{+})$ remains unchanged. Then, the state of node $i$ is saved in the form of \big{(}m_{i}(t^{+}),v_{i}(t^{+})\backslash m_{i}(t^{+})\big{)}.

When $X(t)\in\mathcal{X}_{0}$, there is at least one value set $\{c_{1}\}$ in the network. When this value set meets a new node with $m_{i}(t)\neq\{c_{1}\}$, it updates $m_{i}(t)$ to $\{c_{1}\}$ and $m_{i}(t)$ will never be changed after that. Because $\{c_{1}\}\subseteq v_{i}(t),\forall i\{1,\cdots,n\}$ when $X(t)\in\mathcal{X}_{0}$. For a fixed $m_{i}(t^{+})$, the number of possible states for $v_{i}(t^{+})\backslash m_{i}(t^{+})$ is $2^{K-1}$. Consequently, the total number of states reduces to $K\times 2^{K-1}$. As an example, in the ternary voting, we have the following 12 states:

[TABLE]

Thus, the number of states for ternary voting is 12 compared to 15 for the PAGA automaton [14] and it is equal to 32 for quaternary voting while the number of states for the PAGA is 100.

In the case of ranking problem, we replace the value set and memories by an ordered $K$-tuple $a_{i}(t)=[a_{i}^{1}(t),\cdots,a_{i}^{K}(t)]$, which is a permutation of the set $\mathcal{C}$ along with an integer $1\leq p_{i}(t)\leq K$ which we perceive as a pointer to an entry of $a_{i}(t)$. At the beginning of the algorithm, each node $i$ puts its preferred choice in the first entry of $a_{i}(0)$, and sets an arbitrary permutation of other choices in the remaining entries. It also sets $p_{i}(0)=1$. Let $a_{i}^{1:p_{i}(t)}$ be a $p_{i}(t)$-tuple containing the first $p_{i}(t)$ entries of $a_{i}(t)$ and $\{a_{i}^{1:p_{i}(t)}\}$ be the set representation of it without any order. For a set $A\subseteq\mathcal{C}$, we define $\Pi_{A,a_{i}(t)}$ as a permutation of $A$ that preserves the order of entries in accordance with $a_{i}(t)$. Now, assume that two nodes $i$ and $j$ get in contact with each other at time $t$, and let $p_{i}(t)\leq p_{j}(t)$. Then, we apply the following updating rule:

[TABLE]

where $A_{1}=\{a_{i}^{1:p_{i}(t)}\}\cap\{a_{j}^{1:p_{j}(t)}\}$, $A_{2}=\{a_{i}^{1:p_{i}(t)}\}\cup\{a_{j}^{1:p_{j}(t)}\}$. We also set $p_{i}(t^{+}):=|A_{2}|$ and $p_{j}(t^{+}):=|A_{1}|$. It is not difficult to verify that this form of implementing the DMVR algorithm can solve the ranking problem by the same arguments in Theorem 1.

From the above implementation, we can run the DMVR algorithm for the ranking problem with $K\times K!$ states where the terms $K$ and $K!$ are the possible values of the pointer $p_{i}(t)$ and the ordered tuple $a_{i}(t)$, respectively.

Example 2**.**

Suppose that $\mathcal{C}=\{c_{1},c_{2},c_{3},c_{4}\}$. Two examples for the updating rule in (15) are given as follows:

[TABLE]

where the arrow symbol points the $p_{i}(t)$-th entry of $a_{i}(t)$.

The following theorem proposes a lower bound for the required number of states of any ranking algorithm. This bound meets the required number of states of the DMVR algorithm, proving optimality of it for the ranking problem.

Theorem 2**.**

Any algorithm that finds the correct ranking in a finite time with probability one over arbitrary network topology, requires at least $K\times K!$ number of states per node.

Proof:

It is enough to show that the theorem applies in complete graphs. Suppose that the ranking problem can be solved by running algorithm $\mathcal{A}$ at each node in a finite time. Consider that each node $i$ has a state $s_{i}(t)$. Let integer $r$ corresponds to the ranking $[\pi_{1},\cdots,\pi_{K}],1\leq r\leq K!$. We define a class of states, $\mathcal{S}_{r}$, as a set of states which nodes associate with ranking $r$. Algorithm $\mathcal{A}$ is said to converge to ranking $r$ at time $\tau$ if $s_{i}(t)\in\mathcal{S}_{r},\forall i\in\{1,\cdots,n\},\forall t\geq\tau$. We denote members of the class $\mathcal{S}_{r}$ by $\mathcal{S}_{r}=\{\mathcal{S}_{r}^{1},\cdots,\mathcal{S}_{r}^{D_{r}}\}$ where $D_{r}=|\mathcal{S}_{r}|$. Let $N_{1}$ be the set of initial configurations that are consistent with the ranking $r=[\pi_{1},\cdots,\pi_{K}]$, i.e.:

[TABLE]

Let $n_{i},1\leq i\leq D_{r}$ be the number of nodes in $\{1,\cdots,n\}$ whose state is $\mathcal{S}_{r}^{i}$. In complete graphs, the whole information of $[s_{1}(t),\cdots,s_{n}(t)]$ can be represented by the set $[n_{1},\cdots,n_{D_{r}}]$. Thus, the class $\mathcal{S}_{r}$ corresponds to a subset of the following set:

[TABLE]

Let $B_{z}$ be the set of vectors $[n_{1},\cdots,n_{D_{r}}]$ that are achievable from the initial configuration $z\in N_{1}$.

Lemma 5**.**

Consider two initial configurations $x,y\in N_{1}$, $x\neq y$. Then, we have: $B_{x}\cap B_{y}=\emptyset$.

Proof:

By contradiction. Suppose that there exists $x_{0}\in B_{x}\cap B_{y}$. We run algorithm $\mathcal{A}$ in a complete graph with nodes $\{1,\cdots,n+n^{\prime}\}$ for two different initial configurations $x,y$ of nodes $\{1,\cdots,n\}$. The algorithm $\mathcal{A}$ should give the correct result for any scheduling of local clocks at nodes. Consider a scheduling which only clocks of nodes in the set $\{1,\cdots,n\}$ are ticking up to time $T$ and the states of these nodes become $x_{0}$. Now, suppose that a centralized algorithm $\mathcal{A}_{c}$ want to obtain correct ranking by just looking at states of nodes in $\{1,\cdots,n\}$ and votes of nodes in $\{n+1,\cdots,n+n^{\prime}\}$. Algorithm $\mathcal{A}_{c}$ finds the ranking of votes of nodes in $\{1,\cdots,n\}$ by the vector $x_{0}$. But the centralized algorithm still needs to obtain all differences $\#\pi_{i}-\#\pi_{i+1}$, $1\leq i\leq K-1$. Otherwise, it cannot rank votes of nodes in the whole network correctly. However, the two different initial configurations $x,y$ are mapped to the same state vector $x_{0}$. Consequently, the algorithm $\mathcal{A}_{c}$ cannot recover the correct initial configuration which is a contradiction. Thus, the proof of lemma is complete. ∎

We know that $|N_{2}|={n+D_{r}-1\choose D_{r}-1}=\Theta(n^{D_{r}-1})$. Furthermore, we have:

[TABLE]

Let $F:N_{1}\longrightarrow N_{2}$ which maps $x\in N_{1}$ to $B_{x}\subset N_{2}$. According to Lemma 5, the mapping $F$ should be invertible. For sufficiency large $n$, this can occur only if $D_{r}\geq K$. Consequently, it can be concluded that each class $\mathcal{S}_{r}$ has at least $K$ members and total number of states is at least $K\times K!$. ∎

IV Time Complexity

In this section, we first analyze the time complexity of the DMVR algorithm for the binary voting problem in complete graphs. Then, we study the multiple choice case and derive a tight bound on the running time of the DMVR algorithm for the ranking problem. At the end, we propose a method to speed up the DMVR algorithm in majority voting problem.

IV-A Binary Voting Case

In order to study the time complexity of the DMVR algorithm, we divide its execution time into two phases:

• •

First phase (extinction of $\{c_{2}\}$): This phase starts at the beginning of the algorithm and continues until none of the value sets are $\{c_{2}\}$. We denote the finishing time of this phase by $\tau_{1}$.

• •

Second phase (dissemination of $\{c_{1}\}$ in memories): This phase follows the first phase and it ends when memories of all nodes are $\{c_{1}\}$. The execution time of this phase is represented by $\tau_{2}$.

IV-A1 Time complexity of the first phase

For the binary case, the transition rule of DMVR algorithm is exactly the same as the PAGA algorithm. In [23], an upper bound, $O(\log(n)/(1-2\rho))$, is given for the PAGA algorithm in complete graphs where $\rho_{2}=\rho$. Here, we propose exact average time complexity for the first phase. Suppose that the number of nodes voting for $c_{1}$, $c_{2}$ are $s=n(1-\rho)$ and $r=n\rho$ at the beginning of the algorithm. We denote the sets of nodes having value sets $\{c_{1}\}$ and $\{c_{2}\}$ at time $t$ by $S_{1}(t)$ and $S_{2}(t)$, respectively. Consider the Markov chain in Fig. 1. The state $r-i$, $0\leq i\leq r$, represents the number of nodes whose value sets are $\{c_{2}\}$. Suppose that the state of Markov chain is $r-i$ at time $t$. The chain undergoes transition from state $r-i$ to $r-i-1$ if one of nodes in the set $S_{2}(t)$ gets in contact with one of nodes in $S_{1}(t)$, which occurs with rate $2(r-i)\times(s-i)/n$. After updating the value sets, both $|S_{1}(t)|$ and $|S_{2}(t)|$ will decreased exactly by one. Let $T_{r-i}^{1}$ be the sojourn time in state $r-i$. Hence, we have:

[TABLE]

in terms of time units. Thus, the average running time of the first phase is: $\mathbb{E}\{\tau_{1}\}\approx\frac{1}{2(1-2\rho)}\log(\frac{n\rho(1-2\rho)}{1-\rho})$ time units. Furthermore, we can obtain the variance of $\tau_{1}$ as follows:

[TABLE]

IV-A2 Time complexity of the second phase

At the beginning of the second phase, the number of nodes in $S_{1}(t)$ is $n(1-2\rho)$ and all the remaining nodes have the value sets $\{c_{1},c_{2}\}$ or $\emptyset$. Furthermore, the memories of all of these nodes are $\{c_{2}\}$ in extreme case. Consider the Markov chain in Fig. 2. The state $r-i,0\leq i\leq r$, represents the number of nodes having value sets $\{c_{1},c_{2}\}$ or $\emptyset$ with memory $\{c_{2}\}$. We denote the set of such nodes by $\mathcal{M}_{2}(t)$. There is a reduction in $|\mathcal{M}_{2}(t)|$ if and only if a node in $\mathcal{M}_{2}(t)$ gets in contact with a node in $S_{1}(t)$. If $|\mathcal{M}_{2}(t)|=r-i$, then with rate $2\times\frac{(r-i)(n-2n\rho)}{n}$, there is a transition from state $r-i$ to state $r-i-1$. Let $T_{r-i}^{2}$ be the sojourn time in state $r-i$. Then, we have:

[TABLE]

Thus, we can conclude that the time complexity of the DMVR algorithm is:

[TABLE]

IV-B Multiple Choice Voting Case

Consider two choices $c_{k}$ and $c_{l}$. From the state vector $X(t)=[v_{1}(t),v_{2}(t),\cdots,v_{n}(t)]$, we define a new state vector $X^{k,l}(t)=[v^{\prime}_{1}(t),\cdots,v_{n}^{\prime}(t)]$ by projecting the value set of each node $i$ on $\{c_{k},c_{l}\}$, i.e. $v_{i}^{\prime}(t)=v_{i}(t)\cap\{c_{k},c_{l}\}$. Thus, the projected state vector $X^{k,l}(t)$ represents the path of execution in a binary voting with just two choices $c_{k},c_{l}$. We define $\mathcal{X}_{0}^{k,l}$ to be the convergence set of the projected system as follows:

[TABLE]

Lemma 6**.**

Let $\tau_{x}$ and $\tau_{x}^{k,l}$ be the time that the state vectors $X(t)$ and $X^{k,l}(t)$ hit their corresponding convergence sets. Then, we have: $\tau_{x}=\max_{k,l\in V,k\neq l}\tau_{x}^{k,l}$.

Proof:

First, we prove that $\tau_{x}\geq\max_{k,l\in V,k\neq l}\tau_{x}^{k,l}$. If $X(t)\in\mathcal{X}_{0}$, then for all $k,l\in\{1,\cdots,K\},k\neq l$:

[TABLE]

Now, we show that $\tau_{x}\leq\max_{k,l\in V,k\neq l}\tau_{x}^{k,l}$. Consider any two nodes $i$ and $j$ at time $t=\max_{k,l\in V,k\neq l}\tau_{x}^{k,l}$. Without loss of generality, assume that $|v_{i}(t)|\leq|v_{j}(t)|$. We will show that $v_{i}(t)\subseteq v_{j}(t)$. By contradiction, suppose that there exists a choice $c_{k}$ such that $c_{k}\in v_{i}(t)$ and $c_{k}\not\in v_{j}(t)$. Now, consider any choice $c_{l}\in v_{j}(t)$. Since $t\geq\tau_{x}^{k,l}$, the state vector $X^{k,l}(t)$ has already hit its convergence set. This occurs if and only if $v_{i}(t)\cap\{c_{k},c_{l}\}=\{c_{k},c_{l}\}$ and $v_{j}(t)\cap\{c_{k},c_{l}\}=\{c_{l}\}$. Hence, we can conclude that $c_{l}\in v_{i}(t),\forall c_{l}\in v_{j}(t)$. However, it means that $|v_{i}(t)|>|v_{j}(t)|$ which is a contradiction. ∎

From (19) and (20), $\mathbb{E}\{\tau_{x}^{k,l}\}$ and $\mathrm{Var}(\tau_{x}^{k,l})$ can be obtained by substituting $r,s$ with $n\rho_{k}$ and $n\rho_{l}$, respectively.

Lemma 7**.**

(Order Statistics [24]) Let $[Z_{1},\cdots,Z_{R}]$ denote $R\geq 2$ random variables (not necessarily independent or identically distributed) with means $[\mu_{r}]$ and variances $[\sigma^{2}_{r}]$. Let $Z_{max}=\max_{r=1,\cdots,R}Z_{r}$. Then, we have:

[TABLE]

Now, we can give an upper bound on $\mathbb{E}\{\tau_{x}\}$ from above lemma:

[TABLE]

where $\mu=\frac{1}{{K\choose 2}}\displaystyle\sum_{k,l\in V,k\neq l}\mathbb{E}\{\tau_{x}^{k,l}\}$.

After the state vector gets in the convergence set, we should still wait to copy vector $v^{\star}$ in memories of all nodes. At time $\tau_{x}$, the number of nodes with the value state $\{c_{1},c_{2},\cdots,c_{j}\}$ is $n\rho_{j}-n\rho_{j+1}$, $1\leq j<K$. Let $\mathcal{M}_{j}^{\prime}$ be the set of such nodes and $\tau_{j}^{\prime}$ be the time until memories $m_{i,j}(t)$’s of all nodes are set to $\{c_{1},\cdots,c_{j}\}$. When a node $i$ contacts with any node in $\mathcal{M}_{j}^{\prime}$, its memory $m_{i,j}(t)$ will be set to $\{c_{1},\cdots,c_{j}\}$. With the same arguments in previous part, we have:

[TABLE]

Thus, an upper bound on $\tau^{\prime}=\max_{1\leq j<K}\tau_{j}^{\prime}$ can be obtained from order statistics:

[TABLE]

where $\mu^{\prime}=\frac{1}{K-1}\displaystyle\sum_{j=1}^{K-1}\mathbb{E}\{\tau_{j}^{\prime}\}$. From the bounds in (26) and (28), we can conclude that the time complexity of the DMVR algorithm is $O(\frac{\log(n)}{\underset{j=1,\cdots,K-1}{\min}\rho_{j+1}-\rho_{j}})$.

IV-C Speeding up the DMVR algorithm for majority voting problem

The execution time of the DMVR algorithm can be divided into two phases: The first phase starts at time zero and it ends when the state vector $X(t)$ gets in the convergence set $\mathcal{X}_{0}$. Afterwards, the second phase starts and it terminates when all nodes’ memories are set with the majority vote. In order to speed up the second phase, we add the following rule when two nodes $i$ and $j$ contact with each other at time $t$:

1:if $|v_{i}(t^{+})|>1\land|v_{j}(t^{+})|>1$ then

2:     Generate $u$ from Bernoulli distribution with success probability $0.5$.

3:     if $u=1$ then

4:         $m_{i}(t^{+}):=m_{j}(t)$,

5:     else

6:         $m_{j}(t^{+}):=m_{i}(t)$.

7:     end if

8:end if

It is worth mentioning that the added rule is executed from the beginning of the algorithm. The idea behind this rule is that even nodes with the value sets other than the majority vote, cooperate in spreading the majority vote in the memories of all nodes. We call the proposed solution as the enhanced version of the DMVR algorithm. Simulation results show that the enhanced version of the DMVR algorithm can speed up the DMVR algorithm in complete graph, torus, and ring networks.

Lemma 8**.**

Each node converges to the majority vote in a finite time with probability one by running the enhanced version of the DMVR algorithm.

Proof:

Let $\tau_{x}$ be the time that the state vector $X(t)$ gets in the convergence set. Since then, the only value set with size one in the network would be $\{c_{1}\}$. Consider the vector $M(t)=[m_{1}(t),\cdots,m_{n}(t)]$. We define the Lyapunov function $V^{\prime}(M(t))$, $t>\tau_{x}$, as follows:

[TABLE]

Suppose that two nodes $i$ and $j$ get in contact with each other at time $t>\tau_{x}$. Let $M_{0}$ be the vector of length $n$ with all entries equal to $\{c_{1}\}$. Then, we have:

[TABLE]

where $y\neq M_{0}$. Hence, by the same arguments in Lemma 3, we conclude that $M(t)$ converges to vector $M_{0}$ with probability one. ∎

V Simulations

In this section, we evaluate the time complexity of the DMVR algorithm through simulations and compare it with PAGA automaton in binary and ternary voting. Furthermore, we study the proposed time complexity bounds in complete graphs. Each point in simulations is averaged over 1000 runs.

We compare the proposed bounds on $\mathbb{E}\{\tau_{1}\}$ and $\mathbb{E}\{\tau_{2}\}$ derived in (19) and (21) with simulation results for binary voting in Fig. 3. As it can be seen, the bound $\mathbb{E}\{\tau_{1}\}$ is exact as we expected while there is a constant gap between simulation and analysis for $\mathbb{E}\{\tau_{2}\}$.

In Fig. 4, the time complexities of DMVR algorithm, its enhanced version, and the PAGA automaton are depicted versus $\rho_{1}$. Since the transition rule of DMVR algorithm is identical to the PAGA automaton in binary case, the performance of two algorithms are very close to each other. However, the enhanced version of DMVR algorithm outperforms the other two algorithms as $\rho_{1}$ gets close to 0.5. In Fig. 5, we can also see this trend in ring and torus networks.

For ternary voting problem, we consider the percentage of initial votes in the form of $[\rho_{1},\rho_{2},\rho_{3}]=[\frac{1}{3}+\delta,\frac{1}{3},\frac{1}{3}-\delta]$ where $0<\delta<\frac{1}{3}$. In Fig. 6, time complexities of enhanced version of the DMVR algorithm and the PAGA automaton are given for $\delta\in[0.005,0.041]$, $n=198$. As it can be seen, the enhanced version of the DMVR algorithm outperforms the PAGA automaton for small $\delta$.

At the end, we compare the bounds for $\mathbb{E}\{\tau_{x}\}$ and $\mathbb{E}\{\tau^{\prime}\}$ derived in (26) and (28) for the ranking problem with three votes. In Fig. 7, bounds from order statistics have a small gap with simulation results and they can predict the behaviour of the DMVR algorithm accurately based on the percentage of initial votes.

VI Conclusions

In this paper, we proposed the DMVR algorithm in order to solve the majority voting and ranking problems for any number of choices. The DMVR algorithm is a simple solution with bounded memory and it is optimal for the ranking problem in terms of number of states. Furthermore, we analyzed time complexity of the DMVR algorithm and showed that it relates inversely to $\underset{i=1,\cdots,K-1}{\min}\rho_{i+1}-\rho_{i}$. As a future work, it is quite important to obtain the minimum required number of states for solving majority voting problem. We conjecture that the DMVR algorithm is an optimal solution for majority voting problem, i.e. at least $K\times 2^{K-1}$ states are required for any possible solution.