Distributed resource coordination in networked systems described by digraphs

Abstract

We consider a multicomponent system in which each component can receive/transmit information from/to components in its immediate neighborhood. Communication links between components are not required to be bidirectional, so that the information exchange between components in the system is in general described by a directed graph (digraph). Each component can contribute a certain amount of some resource (of the same type for each component), and the objective is for the components to distributively compute their individual resource contribution so as to collectively provide a requested amount of the resource. A further constraint is that each component’s contribution is upper and lower bounded by locally known capacity constraints. In order to solve this resource coordination problem, we propose a distributed linear iterative algorithm in which each component maintains a set of values that are updated to be weighted linear combinations of its own previous value(s) and the values of the components it receives information from. Since the original choices of weights used by the components to perform the linear updates may not allow the components to solve the problem, the weights are allowed to adapt (also in a distributed fashion) as the algorithm progresses. Convergence of the proposed algorithm to a feasible solution is established analytically and demonstrated via examples.

Introduction

We consider a multicomponent system in which a certain amount of a resource must be collectively provided by the system components. This amount of resource is known to an (outside) entity who cannot directly communicate with all components, but only with a limited number in its immediate neighborhood. The amount of resource that a component can provide is bounded from above and from below by locally known upper and lower limits, reflecting the constraints on that component’s capacity. In what we refer to as the resource coordination problem, the objective is for the components to distributively compute a feasible solution in the sense that: (i) each node contribution is within its individual (and only locally available) capacity limits; (ii) the nodes collectively provide the total amount of resource requested by the (outside) entity (also called leading node or leader); and (iii) if there is no feasible solution, each node realizes that its computed contribution is outside its capacity limits. Although our development is kept application-independent, the setting described above arises in electric power applications (see, e.g.,  [1]), and networking applications (see, e.g.,  [2]).

In our setup, system components can be thought of as nodes that can only receive/transmit information from/to neighboring nodes; the information exchange between a pair of nodes is not necessarily bidirectional. We adopt the standard assumption that the directed graph (digraph) that describes the exchange of information between nodes be strongly connected. We provide an algorithm that solves the resource coordination problem while adhering to such communication topology. In the proposed algorithm, each node $j$ maintains a set of values that are updated to be weighted linear combinations of node $j$’s own previous set of values and the previous set of values of nodes that transmit information to $j$. As in distributed linear iterative algorithms for consensus (see, e.g.,  [3]), the collective dynamics of the proposed algorithm is described by a discrete-time transition system with no inputs and a time-varying transition matrix (also referred to as weight matrix) that takes values in some set (not necessarily finite). The key idea is for the nodes to use local information to iteratively update their weights so that (i) the weight matrix always remains column stochastic, and (ii) the right eigenvector associated with its largest eigenvalue ${\lambda }_1=1$ asymptotically becomes parallel to a vector defined by the operational ranges of the nodes.

In our earlier work  [1], we showed that when the communication topology between nodes is described by a connected undirected graph, the nodes can solve the resource coordination problem by taking the ratio of two (properly initialized) linear iterations with a weight matrix that is doubly stochastic and primitive; thus, each linear iteration converges to the average of its initial values (see, e.g.,  [3, Theorem 2-iii]). This approach could be extended to communication topologies described by strongly connected directed graphs as long as nodes can obtain a set of weights that form a doubly stochastic matrix using only local information. However, while obtaining a doubly stochastic matrix on an undirected graph using only information locally available to each node is relatively simple, this is not as straightforward on a digraph   [4], [5]. Furthermore, if such an approach were to be adopted, each node would need to: (i) execute the distributed algorithm that allows the nodes to obtain a set of weights that form a doubly stochastic matrix, and (ii) execute two additional linear iterations that use the weights obtained via the algorithm in (i) to compute the necessary averages. In this paper, we show that it is not necessary to execute two additional iterations, but only one, if (instead of obtaining a set of weights that form a doubly stochastic matrix) one obtains a set of weights that form a column stochastic matrix with a specific right eigenvector associated with eigenvalue ${\lambda }_1=1$.

The paper focuses primarily on providing a distributed solution to the resource coordination problem on a strongly connected directed graph without relying on a doubly stochastic matrix; a side contribution of the paper is the distributed algorithm for obtaining a set of weights that form a column stochastic matrix with the right eigenvector associated with its largest eigenvalue ${\lambda }_1=1$ aligned in a certain predetermined direction. This problem is related to the problem of matrix scaling to doubly stochastic form, which has been addressed in centralized (see, e.g.,  [6] and the references therein), and distributed (see, e.g.,  [4], [5]) settings; however, in these works, both right and left eigenvectors associated with ${\lambda }_1$ must be parallel to the all-ones vector.