MinMax Algorithms for Stabilizing Consensus

06/21/2019 ∙ by Bernadette Charron-Bost, et al. ∙ 0

In the stabilizing consensus problem, each agent of a networked system has an input value and is repeatedly writing an output value; it is required that eventually all the output values stabilize to the same value which, moreover, must be one of the input values. We study this problem for a synchronous model with identical and anonymous agents that are connected by a time-varying topology. Our main result is a generic MinMax algorithm that solves the stabilizing consensus problem in this model when, in each sufficiently long but bounded period of time, there is an agent, called a root, that can send messages, possibly indirectly, to all the agents. Such topologies are highly dynamic (in particular, roots may change arbitrarily over time) and enforce no strong connectivity property (an agent may be never a root). Our distributed MinMax algorithms require neither central control (e.g., synchronous starts) nor any global information (eg.,on the size of the network), and are quite efficient in terms of message size and storage requirements.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

There has been much recent interest in distributed control and coordination of networks consisting of multiple mobile agents. This is motivated by the emergence of large scale networks with no central control and time-varying topology. The algorithms deployed in such networks ought to be completely distributed, using only local information, and robust against unexpected changes in topology, despite the lack of global coordination like synchronous starts.

A canonical problem in distributed control is the stabilizing consensus problem [2, 13, 3]: each agent  starts with some initial value and repeatedly updates an output variable  which eventually stabilizes on the same input value. The stabilizing consensus problem arises in a number of applications including eventual consistency in replicated databases (see eg., [20]), motion of autonomous agents [19], and blockchain agreement [17, 6]. Similarly, the stable computation of a predicate in the model of population protocols [1] may be seen as a variant of stabilizing consensus, in which the stabilized output value is the truth value of some predicate of the multiset of initial values.

A stronger form of agreement is captured by the classical consensus problem which differs from stabilizing consensus in the fact that all the output variables are write-once: when the agent  is aware that agreement has been reached on some initial value , it writes  in , in which case  is said to decide on . Hence the discrepancy between stabilizing consensus and consensus typically lies in this additional requirement of irrevocable decisions.

On the other side, asymptotic consensus is a classical weakening of stabilizing consensus: in the case of initial values that are real numbers, agents are only required to compute the same outcome asymptotically. In other words, the condition of eventual stability on the variables  is replaced by the weaker one of convergence. Moreover the limit value is only required to be in the range of the initial values, which prevents the applicability of asymptotic consensus to the class of problems where the limit value must be one of the initial values.

Although there is a plethora of papers on agreement problems in multi-agent systems, few are specifically devoted to stabilizing consensus. To the best of our knowledge, the problem has been first investigated by Angluin, Fischer, and Jiang [2]. They studied solvabilty of stabilizing consensus in an asynchronous totally connected system where agents have distinct identifiers and may experience various type of faults, focusing on Byzantine faults. This problem has been studied later in [13, 3] in the synchronous gossip model. These papers propose randomized stabilizing consensus algorithms with convergence times that are functions of the number of possible input values.

The original consensus problem, with irrevocable decisions, has been the subject of much more study, specifically in the context of fault-tolerance and a fixed topology. There is also a large body of previous work on consensus in dynamic networks. In the latter works, agents are supposed to start synchronously, to share global informations on the network, and to have distinct identifiers [12]. Moreover, topology changes are dramatically restricted [4], or communication graphs are supposed to be permanently bidirectional and connected [15].

The asymptotic consensus problem has been also extensively studied as it arises in a large variety of applications in automatic control or for the modeling of natural phenomenas [19]. Averaging algorithms, in which every agent repeatedly takes a weighted average of its own value and values received from its neighbors, are the natural and widely studied algorithms for this problem. One central result by Cao, Morse, and Anderson [7] is that every safe averaging algorithm – that is, an averaging algorithm where positive weights are uniformly bounded away from zero – solves this problem with a continually rooted, time-varying topology, even if the set of roots and links change arbitrarily.

Contribution. The primary goal of this paper is the design of stabilizing consensus algorithms for synchronous, fault free networks of identical and anonymous agents connected by a time-varying topology without any guarantee of strong connectivity. It should be noted that while stabilizing consensus is trivially solved by a gossip algorithm when the time-varying topology is eventually strongly connected, in the sense that for every pair of agents and there always exists a time consistent path from to , there is no obvious solution in the case some nodes cannot receive information from part of the network. In the absence of such a connectivity property, synchronous starts cannot be simulated [10], and hence tolerating asynchronous starts makes the problem even more challenging.

We start by introducing the notion of kernel that models the set of root agents able at any time to send messages, possibly indirectly, to all other agents. If this can be achieved in at most  communication steps, then the topology is said to be rooted with delay . A time-varying topology with a non-empty kernel is thus rooted with finite but a priori unbounded delays. We first prove that stabilizing consensus is not solvable in the case of an empty kernel. Then we show that in the case of a time-varying topology that is rooted with bounded delay, the stabilizing consensus problem is solvable, even if the bound is unknown.

For that, we introduce the MinMax update rules for the output variables , and then provide a distributed implementation of these update rules that is efficient, both in terms of message size and storage requirements. The resulting distributed algorithms, called MinMax algorithms, require no leader, no agent identifiers, and assume no global knowledge of the network structure or size. Moreover, they tolerate that agents join the system asynchronously. We define the subclass of safe MinMax algorithms, and show that any such algorithm achieves stabilizing consensus if the topology is rooted with bounded delay. As a corollary, we get that stabilizing consensus is solvable in any asynchronous and completely connected network and a minority of faulty agents that crash or commit send omissions. Finally, we show that using safe MinMax algorithms, stabilizing consensus is not solvable under the sole assumption of a non-empty kernel, i.e., the topology is rooted with finite but unbounded delays.

Another contribution of this work is the introduction of new notions that capture global properties of dynamic graphs, like the kernel, the integral, the limit superior of a dynamic graph, which we believe to be useful for investigating other distributed problems in networked systems with time-varying topologies.

2 Preliminaries

2.1 The computational model

We consider a networked system with a fixed set of agents. Our algorithms assume anonymous networks in which agents have no identifiers and do not know the network size .

We assume a round-based computational model in the spirit of the Heard-Of model [11]. Point-to-point communications are organized into synchronized rounds: each agent can send messages to all agents and can receive messages sent by some of the agents. Rounds are communication closed in the sense that no agent receives messages in round  that are sent in a round different from . The collection of possible communications (which agents can communicate to which agents) at each round is modelled by a directed graph (digraph) with one node per agent. The digraph at round  is denoted , and is called the communication graph et round . When dealing with just graph notions, we will use the term node rather than the one of agent for an element of . We assume a self-loop at each node in all these digraphs since every agent can communicate with itself instantaneously. The sequence of digraphs  is called a dynamic graph [8]. A network model is any non-empty set of dynamic graphs.

In every run of an algorithm, each agent  is initially passive: it neither sends nor receives messages, and do not change its state. Then it either becomes active at the beginning of some round , or remains passive forever – in which case we let . A run is active if all agents are eventually active.

At the beginning of its starting round , the agent  sets up its local variables and starts executing its program. In round , sends messages to all agents, receives messages from all its incoming neighbors in the digraph that are active, and finally goes to its next state applying a deterministic transition rule. Then the agent  proceeds to round . The number of the current round is not assumed to be provided to the agents.

The value of a local variable of at the end of round  is denoted by . By convention, the value of for is defined as the initial value of .

Since each agent is deterministic, a run is entirely determined by the initial state of the network, the dynamic graph , and the collection of the starting rounds. For each run, denotes the digraph where is the set of edges that are either self-loops111To allow for simple notation, there are self-loops at all nodes of , including those corresponding to the passive agents at round . or connecting two agents that are active in round . The sets of ’s incoming neighbors (in-neighbors) in the digraphs and are denoted by and , respectively.

2.2 Limits and integrals of dynamic graphs

Let us first recall that the product of two digraphs and , denoted , is the digraph with the set of nodes and with an edge if there exists  such that and . For any dynamic graph and any integers , we let . By convention, , and when , is the digraph with only a self-loop at each node.

Given any dynamic graph and any scheduling of starts, the sets of ’s incoming neighbors (or in-neighbors for short) in and in are denoted by and , respectively, and simply by and when . Because of the self-loops, all these sets contain the node . If , then .

If , then a path in the interval is any finite sequence with and is an edge of for each . Hence there exists a path in the interval if and only if is an edge of , or equivalently .

By extension over the infinite interval , we define the digraphs

and denote by and the sets of ’s in-neighbors in these two digraphs, i.e.,

The dynamic graph , defined by , is called the integral of .

The limit superior of , denoted by , is defined as the digraph , where is the set of edges that appear in an infinite number of digraphs , namely,

In particular, the digraph is the limit superior of .

Proposition 1.

If is a dynamic graph with a permanent self-loop at each node, then eventually stabilizes to , i.e., there is a positive integer  such that

Proof.

Because of the self-loops, every edge of is an edge of . Hence the dynamic graph eventually stabilizes to some digraph , i.e., there is a positive integer  such that

Hence all edges in are edges of .

Conversely, by definition of the limit superior, any edge of  appears in some digraph with , and since , is also an edge of . ∎

Let us recall that a digraph is transitively closed if any edge of is an edge of . In the case has a self-loop at each node, this is equivalent to . The transitive closure of , denoted by , is the minimal transitively closed digraph that contains all edges of .

Theorem 2.

If is a dynamic graph with permanently a self-loop at each node, then is the transitive closure of , namely,

Proof.

First we prove that is transitively closed. Since every edge of is also an edge of , this will show that . For that, let be the index from which stabilizes (cf. Proposition 1), and let and be two edges of . Since , there exists an index such that is an edge in . Since , there exists an index such that is an edge in . It follows that is an edge in , and hence is an edge in .

We now prove the reverse inclusion; let be an edge of . Since there are finitely many edges that appear finitely many times in , there is an index such that for all , any edge in is an edge in . Let . By Proposition 1, is an edge of , i.e., there exists an index such that is an edge of . In other words, there is a path in the interval ; let be such a path. Since , each edge in this path is an edge in , which shows that is an edge of the transitive closure of , namely . ∎

2.3 Roots, central roots, and kernels

A node  is a root of the digraph if for every node , there is a path from to in , and   is said to be rooted if it has at least one root. Node  is a central root of  if for every node , is an edge of . The set of ’s roots and the set of ’s central roots are denoted by and , respectively.

The kernel of a dynamic graph , denoted by , is defined as

or equivalently,

Proposition 3.

If is a dynamic graph with permanently a self-loop at each node, then

Proof.

Because of the self-loops, , which by Proposition 1 implies that

By Theorem 2, the digraph is the transitive closure of , and so

which completes the proof. ∎

The dynamic graph is said to be infinitely connected if , or equivalently, by Proposition 3, if is strongly connected.

2.4 Bounded delay rootedness

A dynamic graph  is said to be permanently rooted if all the digraphs are rooted. This notion naturally extends as follows:

Definition 4.

A dynamic graph is rooted with delay if for every positive integer , is rooted. is rooted with a bounded delay if it is rooted with delay  for some fixed positive integer .

Any dynamic graph that is rooted with a bounded delay has a non-empty kernel, i.e., there are nodes that are central roots of all the digraphs . Proposition 5 below shows that these nodes are actually central roots over bounded length intervals.

Proposition 5.

If is a dynamic graph that is rooted with delay , then there exists a positive integer  such that

Proof.

For simplicity, we assume that ; the general case can be easily reduced to the case by considering the dynamic graph defined by that is rooted with delay one.

Let be a positive integer such that for all , every edge of  is also an edge of the digraph , i.e., . Then we have that

(1)

For any non-negative integer , let us now introduce the set of nodes that are outgoing neighbors in the digraph  of some of the nodes in  . Because of the self-loops, we have that and . We now show that either or .

For that, assume that . Let , and let be a root of the digraph ; hence there exists a path from  to in . From (1) and the above inclusions, we derive that

Thereby, there are two consecutive nodes  and  in the path such that and . By construction,  is an outgoing neighbor of  in the digraph , and thus . In conclusion, , which shows that .

It follows that where , and hence . Thus for every node , it holds that , as required. ∎

3 The Stabilizing Consensus Problem

Let be a totally ordered set and let be an algorithm in which each agent has an input value and an output variable initialized to . The algorithm achieves stabilizing consensus in an active run with the initial values if the following properties hold:

Validity.

At every round and for each agent , there exists some agent  such that .

Eventual agreement.

There exists some round  such that

The common limit value of the variables  is called the consensus value. The algorithm is said to solve the stabilizing consensus problem in a network model if it achieves stabilizing consensus in each of its active runs with a dynamic graph in .

4 A Necessary Condition for Stabilizing Consensus

Next we show a necessary condition for the stabilizing consensus problem to be solvable.

Theorem 6.

There is no algorithm that solves stabilizing consensus in a network model containing a dynamic graph with an empty kernel.

Proof.

Let be any dynamic graph with an empty kernel, and let be an index such that for every , we have . Let us consider the acyclic digraph formed with the strongly connected components of , called the condensation graph of , and let us recall that the condensation graph of a non-rooted digraph contains at least two source nodes, i.e., two nodes with no incoming edges (see e.g. [14]). From Propositions 3, we derive that the condensation graph of has at least two source nodes and . Hence from round , none of the agents corresponding to the nodes in  (resp. ) are reachable from the agents corresponding to the nodes in  (resp. ).

For the sake of contradiction, assume that there exists an algorithm that achieves stabilizing consensus in all the runs with the dynamic graph . Consider now any run of the algorithm  in which all agents start at round , and all agents of the strongly connected components and have the input values 0 and 1, respectively. Because of the validity property, all the agents in must set their output values permanently to 0. Similarly, all the agents in must set their outputs permanently to 1, which shows that the eventual agreement property is violated in this run. ∎

5 MinMax Algorithms

In this section, we define the class of MinMax algorithms by the type of update rules for the variables . The way MinMax algorithms can be implemented in our computing model will be addressed in Section 7.

We start with an informal description of these algorithms. As a first step, consider the Min algorithm, in which each agent has an output variable which is repeatedly set to the minimum input value has heard of. It is easy to see that on dynamic graphs that are infinitely connected, the values of all variables eventually stabilize on the minimum input value.

When the Min algorithm is applied on an arbitrary dynamic graph, eventually stabilizes on the minimum input value received by , to be denoted by :

Hence there is an integer such that for every round  and every agent , it holds that . As shown below in Lemma 7, if is in , then , where

If the integer is given, then the following simple two phase scheme can solve stabilizing consensus on a dynamic graph with a non-empty kernel: The first phase consists of the first rounds in which the Min algorithm is applied. This allows for each agent  to compute the value in the variable . In the second phase starting at round , for each agent the variable is repeatedly set to the maximal value has heard of.

Since is not given, we implement the above scheme by assigning to each agent  at each round an integer , and by computing the value , with the first phase consisting of the interval .

For this procedure to be correct, we need that eventually for each agent . This is the case if . Assuming that each agent has computed the value of by round , we also need that each agent  hears of some agent in the kernel during the round interval . In conclusion, must be chosen (1) large enough to ensure that each agent  has computed by round  and (2) small enough to guarantee that hears of some agent in the kernel during the period .

A MinMax rule for the variable  is an update rule of the form

(2)

where is any integer in the interval . A MinMax algorithm is an algorithm in which for each agent and each round , the value of is updated by a MinMax rule. It is determined by the way the integer-valued functions , called cut-off functions, are chosen.

We now prove the basic property on which our strategy relies.

Lemma 7.

In any active run, if is in , then for every agent it holds that , and .

Proof.

Let be an arbitrary agent in , and let be such that and all agents are active at round . Since is in , there is some round such that . This implies that is an edge of , and hence .

From the definition of , it follows that for every agent , and hence . By definition of , it holds that . Therefore we have that as required. ∎

6 Safe MinMax Algorithms for Stabilizing Consensus

We now define the subclass of safe MinMax algorithms, and present properties of dynamic graphs guaranteeing that safe MinMax algorithms always stabilize on the value .

6.1 Definition of safe MinMax algorithms

Let be the minimal input value that has heard of by round , i.e.,

Using this notation, the update rule (2) can then be rewritten into

(3)

By definition, the sequence is non-increasing and lower-bounded by . Thus it stabilizes to some limit value at some round denoted . We let .

Lemma 8.

For each agent , .

Proof.

By definition of , there exist some agent and some round such that and . Hence, we get , and so . Since , we have , and the lemma follows. ∎

Now consider an arbitrary agent . Our goal is to set restrictions on the cut-off function  enforcing that eventually . The first restriction is that for all large enough ,

(4)

Because the sequence is stationary and by Lemma 8, the condition (4) is satisfied for all large enough if .

Assuming that (4) holds for some , we use Lemma 7 to show that if contains an agent from then as needed. In a large class of dynamic graphs with non-empty kernels, the latter condition is satisfied whenever is larger than some constant (which may depend on the given dynamic graph). So our second restriction is that .

The above discussion leads to the following definition: A MinMax algorithm is safe if in each of its active runs, it holds that

(5)
Theorem 9.

Any active run of a safe MinMax algorithm on a dynamic graph achieves stabilizing consensus if there is a positive integer  such that

(6)
Proof.

Without loss of generality, assume that and . Let us consider an arbitrary agent . Since the algorithm is safe, there is a positive integer such that for all . Then for , Equation (3) can be rewritten into

(7)

This immediately implies that .

We also obtain from (7) that for every agent , it holds that . By (6), the set contains at least one agent in . Lemma 7 implies that , and so .

We conclude that for all , it holds that , i.e., the run achieves stabilizing consensus on . ∎

As observed, the Min (or Max) algorithm solves stabilizing consensus in any infinitely connected dynamic graph. Simple examples show that this is not the case for some MinMax algorithms. However, as a direct consequence of Theorem 9, we obtain the following result.

Corollary 10.

Every safe MinMax algorithm solves the stabilizing consensus problem in the network model of infinitely connected dynamic graphs.

As for dynamic graphs that are rooted with a bounded delay, the combination of Proposition 5 and Theorem 9 yields the following corollary.

Corollary 11.

Every safe MinMax algorithm solves the stabilizing consensus problem in the network model of dynamic graphs that are rooted with a bounded delay.

Interestingly, Corollaries 10 and 11 are the analogs for stabilizing consensus and MinMax algorithms of the fundamental solvability results by Moreau [16] and by Cao, Morse, and Anderson [7] for asymptotic consensus and averaging algorithms. Observe, however, that Corollary 10 holds for all infinitely connected dynamic graphs while the Moreau’s theorem requires the communication graph to be bidirectional at every round.

6.2 A limitation of safe MinMax algorithms

A natural question raised by Theorem 9 is whether safe MinMax algorithms solve stabilizing consensus for every dynamic graph with a non-empty kernel. We show that this is not the case, and first establish the following property of safe MinMax algorithms.

Lemma 12.

In any run of a safe MinMax algorithm in which stabilizing consensus is achieved, the stabilizing consensus value is equal to .

Proof.

Let be the stabilizing consensus value, and consider a agent such that . Observe that for all rounds  it holds that , and for all large enough we have and . Thus we get that for all large enough , and hence .

Conversely, let us consider an arbitrary agent . Since the algorithm is safe, if  is large enough. For each such , by (3), we have , which implies that . The value of  stabilizes to , which shows that .

It follows that , as claimed. ∎

Theorem 13.

There is no safe MinMax algorithm that solves stabilizing consensus in the network model of dynamic graphs with non-empty kernels.

Proof.

The argument is by contradiction: suppose that there is a safe MinMax algorithm  that solves stabilizing consensus in the network model of dynamic graphs over a fixed set  of nodes and with non-empty kernels. Let us denote , and consider the following two digraphs and with the set of nodes :

  1. is the directed chain ;

  2. is the directed chain .

We consider the active runs of  in which all the nodes start at round 1 and where all the input values are equal to 0, except the input value of the node  that is equal to 1.

First, we consider the dynamic graph in which at all rounds . Clearly, we have that , and the corresponding maximal value is . By Lemma 12 the consensus value in this run is equal to 1, i.e., there exists some positive integer  such that for each round  and each node , it holds that . In particular, .

We now consider the dynamic graph such that for  and for . Clearly , and for the corresponding run of , we have . By Lemma 12, the consensus value in this run is 0, i.e., there exists some positive integer  such that for each round  and each node , it holds that . In particular, .

By repeating the above construction, we determine an infinite sequence of positive integers  and the dynamic graph  defined by

We easily check that , and for the corresponding run of , it holds that

In this run with a non-empty kernel, the sequence is not convergent, which violates the eventual agreement property. ∎

Extending the analogy above pointed out, we may observe that a similar impossibility result for averaging algorithms and asymptotic consensus is proved in [5] with a different collection of three node dynamic graphs.

6.3 Convergence time of safe MinMax algorithms

Contrary to safe averaging algorithms that converge in at most an exponential (in the size  of the network) number of rounds with dynamic graphs that are permanently rooted [7, 9], the convergence time of safe MinMax algorithms with such dynamic graphs may be arbitrarily large: For instance, inserting the complete digraph at one round may result in changing the value , and so may require the MinMax algorithm to stabilize again.

Thus MinMax algorithms are highly unstable with respect to – even sporadic – topology changes. However, if we restrict our analysis to a dynamic graph  formed with a fixed rooted digraph, safe MinMax algorithms converge much faster than safe averaging algorithms. To see that, assume all nodes start at round one, and let . It is not hard to see that within less than rounds, each with stabilizes to . Proposition 5 states that for each node and each round it holds that

It follows that if , then .

Since , there exists a positive integer such that if , then it holds that

We conclude that the algorithm stabilizes by round rounds. In particular, setting guarantees convergence within rounds.

The latter result can be interestingly compared with the exponential lower bound proved in [18, 9]: the convergence time of any safe averaging algorithm is exponential in  on the fixed rooted topology of a Butterfly digraph.

7 Efficient Distributed Implementation of MinMax Algorithms

In this section, we discuss distributed implementations of MinMax algorithms in our computing model. Figure 1 presents a general, efficient distributed scheme for this implementation, which is applicable whenever the difference functions defined by

are locally computable. The exact nature of the functions is left unspecified (line 9).

Observe that the cut-off function satisfies the inequalities if and only if satisfies the same inequalities. The inequalities can be easily enforced by having the agent implement the simple round counter defined by . Indeed, the difference function satisfies these two inequalities when is any integer-valued function such that . Besides we can choose so that the difference function provides a safe MinMax algorithm: for instance, we may set or .

A possible, but quite inefficient way for implementing MinMax algorithms consists in using a full information protocol, in which at each round each active agent sends its local view at round to all other agents; the local view of at round for is a rooted tree with labeled leaves, denoted , defined inductively as follows: First, is a single vertex labelled by . Assume now that at round , the agent receives messages with the trees . Then is the tree consisting of a root with children on which the trees are hanged. Using , the agent  can then easily compute corresponding to the cut-off point .

The point of our implementation is precisely to avoid the construction of the trees . For that, each agent maintains, in addition to and , a variable with values in . At each round , the agent sets to the minimal input value it has heard of, i.e., .

We say that an input value is relevant for agent at round  if there is an agent such that . Thus, the agent needs to set to its maximal relevant value at each round, which is done as explained below.

Just to simplify notation, we assume that the set of all the possible initial values is finite and given. To determine the set of its relevant input values, the agent 

maintains a vector of integers

such that for each , is the minimal number of rounds, by ’s local view at round , that have passed since the last time some agent had set to . Thus is relevant for at round  if and only if .

 

0:  
1:  , initially ; , initially ; , initially 0 ; , initially
2:  
3:  while  TRUE do
4:     send to all agents
5:     receive
6:     for all
7:     
8:     
9:     
10:     
11:  end while
Figure 1: Distributed implementation of a MinMax algorithm with the cut-off functions .

 

Now we show that the algorithm corresponding to the difference functions is a MinMax algorithm with the cut-off functions . We start by two preliminary lemmas.

Lemma 14.

For any agent and any round , .

Proof.

This is an immediate consequence of the initialization of the variable (line 1), of its update rule (line 7), and the fact that if then . ∎

Lemma 15.

If the agent is active at round , then for each integer ,

Proof.

First, assume that there is an agent  such that , and let . Since for , we have set , it always holds that . Moreover, we easily check that is in . Hence there exists a path in the interval that we denote by . Because of the update rule of the vectors , we deduce step by step that

The claim follows by observing that .

We now show by induction on the following implication: