Automatica 48 (2012) 2298–2304

Contents lists available at SciVerse ScienceDirect

Automatica

journal homepage: www.elsevier.com/locate/automatica

Brief paper

A distributed simplex algorithm for degenerate linear programs andmulti-agent assignmentsI

Mathias Bürger a, Giuseppe Notarstefanob, Francesco Bullo c, Frank Allgöwer a,1a Institute for Systems Theory and Automatic Control, University of Stuttgart, Pfaffenwaldring 9, 70550 Stuttgart, Germanyb Department of Engineering, University of Lecce, Via per Monteroni, 73100 Lecce, Italyc Center for Control, Dynamical Systems and Computation, University of California at Santa Barbara, CA 93106, USA

a r t i c l e i n f o

Article history:Received 12 May 2011Received in revised form2 April 2012Accepted 9 April 2012Available online 7 July 2012

Keywords:Distributed simplexDistributed linear programmingAsynchronous algorithmMulti-agent task assignment

a b s t r a c t

In this paper we propose a novel distributed algorithm to solve degenerate linear programs on asyn-chronous peer-to-peer networks with distributed information structures. We propose a distributed ver-sion of the well-known simplex algorithm for general degenerate linear programs. A network of agents,running our algorithm, will agree on a common optimal solution, even if the optimal solution is notunique, or will determine infeasibility or unboundedness of the problem. We establish how the multi-agent assignment problem can be efficiently solved by means of our distributed simplex algorithm. Weprovide simulations supporting the conjecture that the completion time scales linearly with the diameterof the communication graph.

© 2012 Elsevier Ltd. All rights reserved.

1. Introduction

The increasing interest in performing complex tasks via multi-agent systems has raised the interest in solving distributed op-timization problems. The fundamental paradigms in distributedcomputation are that: (i) information, relevant for the solution ofthe problem, is distributed all over a network of processors withlimited memory and computation capability, and (ii) the overallcomputation relies only on local computation and information ex-change amongst neighboring processors. Although parallelized op-timization algorithms have been studied for a long time (see e.g.,Bertsekas and Tsitsiklis (1997)) the multi-agent perspective hasrecently become subject of renewed interest. Several algorithms

I M. Bürger and F. Allgöwer were supported by the German Research Foundationwithin the Cluster of Excellence in Simulation Technology (EXC 310/1) and thePriority Program SPP 1305. The research of G. Notarstefano has received fundingfrom the European Community’s Seventh Framework Programme (FP7/2007–2013)under grant agreement no. 224428 (CHAT). The work by F. Bullo is supported byNSF Award CPS-1035917 and ARO AwardW911NF-11-1-0092. The material in thispaperwas partially presented at the 2011American Control Conference (ACC 2011),June 29–July 1, 2011, San Francisco, California, USA. This paper was recommendedfor publication in revised form by Associate Editor Hideaki Ishii under the directionof Editor Ian R. Petersen.

E-mail addresses: mathias.buerger@ist.uni-stuttgart.de (M. Bürger),giuseppe.notarstefano@unile.it (G. Notarstefano), bullo@engineering.ucsb.edu(F. Bullo), frank.allgower@ist.uni-stuttgart.de (F. Allgöwer).1 Tel.: +49 711 685 67734; fax: +49 711 685 67735.

ranging from subgradient to Quasi-Newton methods were pro-posed to solve strictly convex programs (Bolognani & Zampieri,2010; Nedic, Ozdaglar, & Parrilo, 2010; Zhu & Martínez, 2012).The named approaches rely on strict convexity and cannot effi-ciently handle linear programs. Algorithms explicitly dedicated todistributed linear programming are, to the best of our knowledge,still rare. Simplex algorithms have been proven extremely suc-cessful for linear programming, which motivates searching for adistributed realization of it.While the idea of parallelizing the com-putation of the simplex algorithm has found some attention, seee.g., Hall and McKinnon (1998) and Yarmish and Slyke (2009), afirst contribution, explicitly dedicated to multi-agent networks,is given in Notarstefano and Bullo (2011), where distributed ab-stract programs are introduced as a general class of optimizationproblems including linear programs. A constraints consensus algo-rithm is proposed to solve them.We follow here the trail opened inNotarstefano and Bullo (2011).

A class of problems closely related to linear programs aremulti-agent assignment problems. Assignment problems are combina-torial problems with exact linear programming representations;see Burkard (2002) for an introduction. In contrast to general dis-tributed linear programming, distributed multi-agent assignmentproblems have attained significant attention in the recent litera-ture, and various problem formulations were studied (Castañón &Wu, 2003; Moore & Passino, 2007; Smith & Bullo, 2009). To solvethe standard assignment problem in a fully distributed way, suit-able versions of the Auction Algorithm (Bertsekas, 1998) combined

0005-1098/$ – see front matter© 2012 Elsevier Ltd. All rights reserved.doi:10.1016/j.automatica.2012.06.040

M. Bürger et al. / Automatica 48 (2012) 2298–2304 2299

with a max consensus law have been recently proposed in Brunet,Choi, and How (2008) or Zavlanos, Spesivtsev, and Pappas (2008).The progress on distributed assignment problems has not beentranslated into a general theory for distributed linear programs.

The contributions of this paper are as follows. In a first step,the multi-agent assignment problem is used to derive a moregeneral formulation of distributed linear programs. The assign-ment problem directly motivates the distribution of informationthroughout the network and emphasizes an important challengefor distributed algorithms: the non-uniqueness of optimal solu-tions or, more formally, the degeneracy of optimization programs.As main contribution, we introduce a distributed version of thewell known simplex algorithm to solve these degenerate linearprograms in asynchronous networks with time-varying directedcommunication topology. We prove that a network of agents run-ning our algorithm will agree in finite time on a common optimalsolution of the linear program even if it is highly degenerate. Theproposed algorithm is inspired by the constraints consensus algo-rithm proposed in Notarstefano and Bullo (2011). We show that,if constraints consensus is implemented for non-degenerate lin-ear programs, then the proposed distributed simplex turns to beits dual implementation. Finally, we show how to apply the al-gorithm to the multi-agent assignment problem, a highly degen-erate linear program. We provide numerical experiments for thedistributed assignment problem supporting our conjecture thatthe distributed simplex algorithm scales linearly with the diam-eter of the graph in networks with fixed topologies.

Wewant to point out three main differences between our workand the existing literature. First, our objective is not to improvethe convergence speed of a centralized algorithm, but rather todesign a stable and robust distributed negotiation protocol to solvean optimization problem in a peer-to-peer network without anycoordination unit. Second, our distributed (peer-to-peer) approachis different from the classical decomposition methods such asthe Dantzig–Wolfe or Bender’s decomposition (Dantzig & Wolfe,1961), which utilize a master/subproblem structure. Third, ouralgorithm differs from the parallel simplex algorithms (Dutta &Kargupta, 2008; Yarmish & Slyke, 2009). Indeed, these require a‘‘two-step’’ communication in which first a consensus is reachedon the column with minimal reduced cost and then a basis updateis performed at each node.

The remainder of the paper is organized as follows. Section 2introduces the multi-agent assignment as a motivating examplefor the distributed linear program set-up presented in Section 3.Section 4 reviews some fundamental principles of degeneratelinear programming and introduces a non-standard version of thesimplex algorithm. The main results of the paper are presented inSection 5, where a distributed simplex algorithm for degeneratelinear programs is proposed and analyzed. The usefulness of thealgorithm is illustrated in Section 6 on themulti-agent assignmentproblem. Simulation results are provided for a time complexityanalysis of the algorithm.

2. A motivating example for distributed linear programming:

the multi-agent assignment

Distributing a number of tasks to a number of agents is oneof the most important resource allocation problems and hasapplications in numerous control systems. In this paper it servesas a motivating application for a general definition of distributedlinear programs.

We shortly review the assignment problem here, following thestandard Ref. Bertsekas (1998). The assignment problem can beillustrated with a bipartite assignment graph Ga = {Va,Ua; Ea},where the node sets Va = {1, . . . ,N} and Ua = {1, . . . ,N}represent the set of agents and tasks respectively. An edge (i, ) 2

Fig. 1. Assignment graph Ga .

Ea exists if and only if agent i can be assigned to the task . The costci 2 Z for agent i to perform the task is a weight on the edge(i, ). Fig. 1 illustrates the assignment graph.

For each agent i and task a binary decision variable xi 2{0, 1} is introduced, which is 1 if agent i is assigned to task and 0 otherwise. The assignment problem corresponds now tothe integer optimization problem minxi2{0,1}

P(i,)2Ea cixi , with

the constraints that a full assignment is achieved. The convexrelaxation gives rise to the linear optimization problem (Bertsekas,1998):

minx�0

X

(i,)2Eacixi

s.t.X

{|(i,)2Ea}xi = 1, 8i 2 {1, . . . ,N},

X

{i|(i,)2Ea}xi = 1, 8 2 {1, . . . ,N}.

(1)

It is well-known that (1) has always an optimal solution xi 2{0, 1}, and that this solution corresponds exactly to the optimalassignment. Note that the linear program (1) has n = |Ea| decisionvariables with |Ea| N2, and d = 2N equality constraints.

We are interested in applications where only the agentscan communicate and perform computations, and where nocoordinator or mediator is involved. This setup is different fromthe one in Bertsekas (1989), where the tasks serve as auctioneersand perform computations in the proposed Distributed AuctionAlgorithm. We assume that every agent initially knows the costit takes for itself to perform a specific task. In particular, agent iknows all ci with (i, ) 2 Ea. This is a reasonable assumption ina multi-agent scenario. We want to stress that it is fundamentalthat the agents agree upon the same optimal assignment. In thisrespect, the assignment problemhighlights an additional challengefor distributed optimization algorithms.

Remark 2.1. In general, (1) has several optimal solutions x⇤corresponding to different optimal assignments.

This property of the optimization problem is called degeneracy, andhas strong implications on the design of distributed algorithms.

3. Distributed linear programming set-up

Throughout this paper we consider linear programs in thestandard equality form

min cT xs.t. Ax = b, x � 0,

(2)

where A 2 Rd⇥n, b 2 Rd and c 2 Rn, are the problem data andx 2 Rn is the vector of decision variables. Note that the assignmentproblem (1) is a particular representation of (2). We assume in the

2300 M. Bürger et al. / Automatica 48 (2012) 2298–2304

following that rank(A) = d. A column of problem (2) is a vectorhi 2 R1+d defined as

hi := [ ci, ATi ]T , (3)

where ci 2 R is the i-th entry of c and Ai 2 Rd⇥1 is the i-thcolumn of the matrix A. The set of all columns is denoted by H ={hi}i2{1,...,n}. For any subset G ⇢ H, the notation cG and AG refers tothe cost vector and the constraint matrix, respectively constructedfrom the columns contained in G. The same notation xG is used todenote the corresponding decision variables. A linear program (2)is fully characterized by the pair (H, b).Distributed information structure: We assume that every agentinitially knows a subset of the problem columns. This means thereexists a partitioning P = {P[1], . . . , P[N]} of the problem columnswith H = [N

i=1 P[i] and P[i] \ P[j] = ;, and agent i initially knowsthe column set P[i]. Throughout the paper we use the notationalconvention that superscript [i] denotes a quantity belonging toagent i. Note that in the assignment problem (1) there is a one-to-one correspondence between a column and an edge of theassignment graph Ga and that each agent initially knows thoseedges corresponding to its own assignments.Communication network model: We model the communicationbetween the N agents by a directed graph (digraph) Gc =({1, . . . ,N}, Ec), named communication graph. The node set{1, . . . ,N} represents the agents, and the edge set Ec ⇢ {1, . . . ,N}2 characterizes the communication between the agents. Weconsider in particular time-dependent digraphs of the formGc(t) = ({1, . . . ,N}, Ec(t)), where t 2 R�0 represents theuniversal time. A graph Gc(t) models the communication in thesense that at time t there is an edge from node i to node j if andonly if agent i transmits information to agent j at time t . The time-varying set of outgoing (incoming) neighbors of node i at time t ,denoted by NO(i, t) (NI(i, t)), are the set of nodes to (from) whichthere are edges from (to) i at time t . A static digraph is said to bestrongly connected if, for every pair of nodes (i, j), there exists apath of directed edges that goes from i to j. For the time-varyingcommunication graph, we rely on the notion of a uniformly jointlystrongly connected graph.

Assumption 3.1 (Connectivity). There exists a positive andboundedduration Tc , such that for every time instant t 2 R�0, the digraphGt+Tcc (t) := [t+Tc

⌧=t Gc(⌧ ) is strongly connected.In a static directed graph, the minimum number of edges betweennode i and j is called the distance from i to j and is denoted bydist(i, j). The maximum dist(i, j) taken over all pairs (i, j) is thediameter of the graph Gc and is denoted by diam(Gc). Distributedlinear programs can now be formally defined as follows.

Definition 3.2 (Distributed Linear Program). A distributed linearprogram is a tuple (Gc, (H, b), P ) that consists of (i) a time-varyingcommunication graph Gc(t) = ({1, . . . ,N}, Ec(t)); (ii) a linearprogram (H, b); (iii) a unique partitioning P = {P[1], . . . , P[N]} ofthe problem columns. A solution of the distributed linear programis attained when all agents have agreed on the same optimalsolution solving (H, b).

We develop in this paper a distributed algorithm to solvethis class of problems. A distributed algorithm consists of (i) theset W , called the set of states w[i](t), (ii) the set ⌃ , called thecommunication alphabet including the null element, (iii) the mapMSG : W ⇥ {1, . . . ,N}! ⌃ , called message function, and (iv) themap STF : W ⇥⌃ |NI (i,t)| ! W , called the state transition function.The algorithm starts at t = 0 and each agent initializes its state tow[i](0). Every agent i performs two actions repeatedly: (i) it sendsto each of its outgoing neighbors j 2 NO(i, t) a message computedas MSG(w[i](t), j); (ii) whenever it receives information from its in-neighbors NI(i, t), it updates its state w[i](t) according to the statetransition function. Each agent performs these two actions at itsown speed and no synchronization is required in the network.

4. Centralized solution of degenerate linear programs

We discuss in the following a non-standard algorithm, pro-posed in Jones, Kerrigan, and Maciejowski (2007), which solvesdegenerate linear programs of the form (2) in a centralized frame-work without network constraints.

An important concept in linear programming is the one of abasic solution. A set of exactly d columns B ✓ H is called a basisif rank(AB) = d. If a linear program (H, b) has an optimal feasiblesolution, it has an optimal basic feasible solution, i.e., there existsan optimal vector x⇤ composed of d basic variables xB 6= 0, andn � d non-basic variables xN = 0. Note that for linear programswith d ⌧ n the dimension of the non-zero components of thesolution vector is significantly smaller than the dimension of thefull decision vector. Two bases B1 and B2 are said to be adjacent, ifthere exist columns e 2 B2 and ` 2 B1 such thatB2 = {B1[e}\{`}.For each feasible basis there is a value called the primal cost zB =cTB xB. Given a basis B and a single non-basic column h 62 B, thereduced cost of the column is

ch = ch � ATh(A�1B )T cB =: rT{B[h}c{B[h}, (4)

where ch 2 R and Ah 2 Rd refer to the problem datarelated to column h. The reduced cost gives rise to the standardoptimality condition (Luenberger, 1973): Given a basis B and thecorresponding primal solution xB = A�1B b, if ch � 0, for all columnsh 2 H, then xB is an optimal solution.

Amajor challenge in linear programming is the non-uniquenessof optimal solutions, called degeneracy. Commonly, two types ofdegeneracy are distinguished. A linear program is said to be primaldegenerate if there is more than one basis that lead to the sameoptimal primal solution. It is said to be dual degenerate if thereis more than one primal optimal solutions. That is, there existseveral bases, say Bi and Bj, providing different basic solutions,xBi 6= xBj but have the same optimal primal cost zBi = zBj = z⇤.A problem is said to be non-degenerate, if it is neither primal nordual degenerate. The following holds for non-degenerate linearprograms.

Lemma 4.1 (Solution Uniqueness Fukuda, Lüthi, & Namiki, 1997).Every fully non-degenerate linear program has at most one optimalsolution.

Theorem 4.2 (Solution Reachability Fukuda et al., 1997). If a linearprogram has an optimal solution and is fully non-degenerate, thenthere exists a sequence of adjacent bases from any basis B to theunique optimal basis B⇤.

A well established procedure for solving linear programs is thesimplex algorithm, which is informally described as follows: Let aprimal feasible basisB be given.While there exists an entering columne 62 B such that ce < 0, find a leaving basic column `(e) 2 B suchthat (B [ {e}) \ {`} is again a feasible basis. Exchange the column `with e to get a new basis. The procedure of replacing a basic columnwith a non-basic one is called pivot.

In order to handle degeneracy, a variant of the simplexalgorithm is presented in the following. We use the algorithmproposed in Jones et al. (2007), building on results in Fukudaet al. (1997). The algorithm relies on the lexicographic ordering ofvectors.

Definition 4.3 (Lex-Positivity). A vector � = (�1, . . . , �r) is said tobe lexico-positive (or lex-positive) if � 6= 0 and the first non-zerocomponent of � is positive.

Lexico-positivity will be denoted by the symbol � � 0. We write� ⌫ 0 if � is either lex-positive or the zero vector. The notion

M. Bürger et al. / Automatica 48 (2012) 2298–2304 2301

� � 0 denotes that �� � 0. For two arbitrary vectors v andu, we say that v � u (v ⌫ u) if v � u � 0 (v � u ⌫ 0).Given a set of vectors {v1, . . . , vr}, the lexicographical minimum,denoted by lexmin, is the element vi, such that vj ⌫ vi for all j 6= i.We use lexsort{v1, . . . , vr} to refer to the lexicographically sortedset of the vectors {v1, . . . , vr}. Note that for any list of pairwisedistinct vectors lexsort provides a unique ordering of the vectors.The concept of lex-positivity gives rise to a refinement of the notionof a feasible basis.

Definition 4.4 (Lex-Feasibility). A feasible basis B is called lex-icographically feasible (lex-feasible) if every row of the matrix[A�1B b, A�1B ] is lex-positive.Starting with a lex-feasible basis, the simplex method can berefined such that after a pivot iteration the new basis is againprimal lex-feasible; see Jones et al. (2007). Let B be a lex-feasiblebasis and e the entering column, let the leaving column be chosenby the lexicographic ratio test,

`lex(e) = arg lexminj2B

{[A�1B b, A�1B ]•j/(A�1B Ae)•j|(A�1B Ae)•j > 0},

(5)

where the subscript •j denotes selection of the j-th row of thematrix, respectively vector, then thenext basis is again lex-feasible.Such a selection rule prevents the simplex algorithm from cycling.To guarantee convergence to a unique solution, we change theoptimization criterion to the lexicographically perturbed cost

�(x) = cT x + �0x1 + �20x2 + · · · + �n

0xn, (6)

where xi represents the i-th component of the vector x. Notethat for a sufficiently small constant �0, the optimizer x⇤ =argminx �(x) corresponds to the unique lexicographicallyminimalsolution of (2). Let now � = [�0, �2

0, . . . , �n0]T and write �(x) =

(cT + �T )x. A column becomes admissible with respect to theperturbed cost � if the reduced cost is negative, i.e., ce =rT{B[e}c{B[e} + rT{B[e}�{B[e} < 0, which is equivalent to the analyticcondition, (Jones et al., 2007),

[rT{B[e}c{B[e}, rT{B[e}] � 0. (7)

Replacing the original definition of the reduced cost with (7)provides a mean to minimize the lexicographically perturbed cost(6) without having small numbers involved in the computation.

Algorithms 1 and 2 give a pseudo code description of themodified Pivot and Simplex algorithms. The basic algorithmis here slightly extended to handle unbounded problems. If atsome Pivot iteration (5) returns no leaving column, then theproblem is unbounded. We then set the new basis to null, andstop the execution of the algorithm. This version of the Simplexis proposed in Jones et al. (2007) and determines the uniquelexicographically optimal solution.

Algorithm 1 Pivot (B, e)Require: Lex-feasible basis B, non-basic column e /2 B

if [rT{B[e}c{B[e}, rT{B[e}] � 0 then

select leaving column `lex(e) via lex ratio test (5)if `lex(e) 6= ; then

B (B [ {e}) \ {`lex(e)} % make the pivotelse

B null % problem is unboundedend if

end if

Return B

Algorithm 2 Simplex (H, B)Require: A set of columns H, a lex-feasible basis B ✓ H

while 9e 2 H such that [rT{B[e}c{B[e}, rT{B[e}] � 0 do

B Pivot (B, e)end while

Remark 4.5. The perturbation � used in (6) and (7) requiresa fixed and known ordering of the decision variables and thecorresponding columns. For a centralized algorithm workingwith a classical simplex tableau, such an ordering is naturallygiven. However, this requirement is not naturally satisfied in thedistributed settings.

5. The distributed simplex algorithm

The main contribution of this paper is the presentation of thedistributed simplex algorithm, to solve distributed linear programswithin multi-agent systems.

5.1. Distributed simplex definition

Using the abstract description for distributed algorithmspresented in Section 3, the distributed simplex algorithm isinformally as follows.

The state of each agent is a lex-feasible basis, w[i](t) = B[i],i.e., each agent stores and updates a set of columns forming a basis.A set of basis columns suffices to fully determine the solution ofa linear program, and thus every agent keeps and updates a copyof a possible solution. A basis is defined by exactly d columns, andtherefore the state w[i](t) 2 Rd⇥(d+1). For linear programs withd ⌧ n the basis information required to be stored is reasonablysmall. To initialize the algorithm, every agent creates an artificialbasis using a method known as big-M method. Let, without lossof generality, each entry of the vector b be non-negative. Then,each agent constructs artificial decision variables x1, . . . , xd andgenerates a corresponding initial basis BM as follows: it choosesABM = Id and cBM = M · 1, where Id is the d ⇥ d identity matrix,and 1 is a d-dimensional vector of ones. The cost coefficients are allgiven the artificial valueM , which is larger than any cost coefficientin the original problem (M � maxi=1,...,n(ci)), i.e.,M can be chosenas the largest number realizable by the processor.

The message function MSG simply implements the transmissionof the current basis B[i] to the out neighbors. Note that the size ofMSG is bounded by d ⇥ (d + 1) numbers, and that therefore theexchanged data is small for problemswith small dimension d⌧ n.

The state transition function STF performed by each agent toupdate its basis B[i] proceeds as follows. Having received columnsfrom its in-neighbors, and having its set of permanent columns P[i]in its memory, the agent performs two actions:

(i) it sorts all columns in its memory lexicographically, i.e.,lexsort{P[i], B[i],[j2NI (i,t) MSG(B

[j], i)};(ii) it performs theSimplex algorithm (Algorithm2), and updates

its basis with the new, improved basis.

We provide a pseudo code description of the algorithm in thefollowing table.

Problem data:

(Gc(t), (H, b), P )Processor state: B[i] ⇢ H with card(B) = dInitialization: B[i] := BM

function MSG(B[i], j)return B[i]

2302 M. Bürger et al. / Automatica 48 (2012) 2298–2304

function STF(B[i],[j2NI (i,t)yj) % with yj := MSG(B[j], i)

if yj 6= null for all j 2 NI(i, t) thenHtmp lexsort{P[i] [ B[i] [ �[j2NI (i,t)yj

�}B[i] Simplex(Htmp, B[i])

else

B[i] null

end if

Two steps of the algorithm deserve particular attention. First,every agent has to evaluate its ownpermanent columnsP[i] repeat-edly, since otherwise the algorithmwill not converge to an optimalsolution. Second, each agent needs to perform a lexicographic sort-ing of the columns in itsmemory. Note that agents receive columnsin an unsortedmanner and an ordering of the columns required for(6) and (7) is not defined. The lexicographic comparison providesa unique ordering of the columns which can be locally determinedby every agent. The lexicographic ordering ensures that all agentsoptimize with respect to the same lexicographic objective (6).

5.2. Convergence analysis

The following theorem summarizes the convergence propertiesof the distributed simplex algorithm.

Theorem 5.1 (Distributed Simplex Correctness). Consider a dis-tributed linear program (Gc(t), (H, b), P ) with a uniformly jointlystrongly connected networkGc(t), t 2 R�0. Let the agents run the dis-tributed simplex algorithm. Then there exists a finite time Tf such that

(i) if the centralized problem (H, b) has a finite optimal solution,then the candidate bases B[i] of all agents have converged to thesame lex-optimal basis;

(ii) if the centralized problem (H, b) is unbounded, then all agentshave detected unboundedness, in the sense that all bases are thenull symbol; and

(iii) if the centralized problem (H, b) is infeasible, then all agents candetect infeasibility, in the sense that all basesB[i] have converged,but still contain artificial columns.

Proof. Statement (i) is shown first. Here, by assumption the cen-tralized linear program (H, b) is neither infeasible nor unbounded.Throughout the proof, let x[i](t) 2 Rn

�0 denote a primal feasiblesolution to (H, b) whose nonzero components are the ones asso-ciated to the columns in the basis B[i] of agent i at time t . A majorpremise for concluding the convergence is the use of the lexico-graphically perturbed cost �[i](x[i](t)) = cT x[i](t) + �0x

[i]1 (t) +

�20x

[i]2 (t)+· · ·+�n

0x[i]n (t),with �0 sufficiently small and the ordering

of the decision variables defined according to the lexicographic or-dering of the complete column data set, i.e., lexsort{H}. We denotethe unique lexicographically minimal primal solution with x⇤ andcorrespondingly �⇤ := �(x⇤). To conclude convergence we con-sider the function

V(t) :=NX

i=1

�[i](x[i](t)). (8)

The minimum of V(t) is attained if and only if at some timeTf , �[i](x[i](Tf )) = �⇤ for all i 2 {1, . . . ,N}, which is equivalent toall agents having converged to the unique lexicographicminimizer,i.e., x[i](Tf ) = x⇤. All agents initialize their local problems witha lex-feasible basis of finite value, i.e., �[i](x[i](0)) < 1, and thePivot iteration never leads to an increase of �[i](x[i](t)). Thus,V(0) � V(t) � N�⇤. We have to show that V(t) strictlydecreases within a finite time interval, as long as the algorithm isnot converged. Since the number of possible bases for a problem(H, b) is finite, �[i](x[i](t)) can take only a finite number of values,

and a strict decrease of V(t) ensures convergence to the optimalsolution in finite time.

As long as the algorithm has not yet converged to the optimalsolution there must exist at least one agent, say i, such that�[i](x[i](t)) > �⇤. As an immediate consequence of Theorem 4.2,there exists at least one column h 2 H, such that the cost of thebasis Pivot(B[i], h) is strictly less than the cost of B[i]. We shownow that within a finite time at least one of the following twoactions happens: (a) an agent with a non-optimal basis improvesits basis with a column from its permanent columns P[i], or (b) anagent in the network receives a column which improves its basisfrom one of its in-neighbors.

Since the state transition function STF is performed regularlyby each agent, update (a) happens, if possible at all, in finite time.Our claim is now that if no agent can improve its objective withone of its permanent columns, then (b) happens in finite time.First, let us observe that if all agents have identical objectives�[i](x[i](t)) = �[j](x[j](t)) 6= �⇤, then (a) happens. Thus, if(a) does not happen, there is at least one pair of agents, say iand j, with different objective values �[i](x[i](t)) < �[j](x[j](t)).As long as there are two agents i and j with �[i](x[i](t)) <�[j](x[j](t)), there must exist at least two agents l and k with�[l](x[l](t)) < �[k](x[k](t)), such that l is an in-neighbor to k inthe (by Assumption 3.1) strongly connected communication graphGTcc (t) = [t+Tc

⌧=t Gc(⌧ ) and the edge (l, k) is an element of thedirected path from i to j. This last implication can be shown by thefollowing contradiction argument. Assume no such agent pair l andk exists, i.e. �[l](x[i](l)) = �[k](x[k](t)), then all agents precedingl in the directed path, including the agent i must have the sameobjective value so that �[i](x[i](t)) = �[l](x[l](t)). Additionallyall agents succeeding k, including agent j must have the sameobjective value so that �[j](x[j](t)) = �[k](x[k](t)), contradictingthe basic assumption �[i](x[i](t)) < �[j](x[j](t)). We conclude that,due to Assumption 3.1, at least after a time interval with maximallength Tc , agent k will receive from agent l a basis B[l], which hasa smaller objective value than B[k]. Thus, within the time intervalTc agent k updates its basis so that �[k](x[k](t + Tc)) < �[k](x[k](t))and V(t + Tc) < V(t). This concludes the first part of the proof.

Next, we prove part (ii) and (iii) of the theorem. If the originalcentralized linear program is unbounded, also the modified prob-lem including the artificial columns h is unbounded. Then at leastone agent will detect unboundedness in finite time and transmitthe null symbol to all its out-neighbors. Since the communicationgraph is uniformly jointly strongly connected, after a finite time Tfthe whole network will determine unboundedness.

Finally, if the original problem (H, b) is infeasible, then thereexists no non-negative solution to Ax = b. Since �[i](x[i](t)) is notincreasing and is bounded, and the number of possible bases is fi-nite, all agents will converge in a finite time Tf to some limit bases.These limit bases must then contain some of the artificial columnsgenerated for the initialization and infeasibility can then be con-cluded in finite time. ⇤

We provide here the stopping criterion proposed in Notarstefanoand Bullo (2011) for a synchronous implementation. We say thatthe algorithm is synchronous, if all agents exchange informationand update their state at the same times, with the time elapsingbetween two communications being Tc .

Theorem 5.2 (Stopping Criterion Notarstefano & Bullo, 2011). Con-sider a network of agents communicating according to a static,strongly connected digraph Gc and implementing distributed simplexalgorithm in a synchronous realization. Each agent can stop the ex-ecution of the algorithm if B[i] has not changed in a time interval oflength (2 diam(Gc) + 1)Tc .

M. Bürger et al. / Automatica 48 (2012) 2298–2304 2303

5.3. Duality to constraints consensus algorithm

Distributed linear programs are strongly related to distributedabstract programs introduced in Notarstefano and Bullo (2011). Anabstract program is defined as a pair (H, ✓), where H is a finiteset of constraints, and ✓ : 2H ! ⇥ is a function taking valuesin a linearly ordered set (⇥,). In distributed abstract programs,defined in Notarstefano and Bullo (2011), the constraints aredistributed throughout a network of agents. Abstract programsare a generalization of linear programs presented in the dualform {max bT y, subj. to AT y c}; see, e.g., Gärtner andWelzl (1996). The proposed distributed solution algorithm inNotarstefano and Bullo (2011), the constraints consensus, is suchthat agents exchange constraints which form a local basis. Whenreceiving constraints, an agent updates its local basis based on theconstraints received and its original constraints. We now clarifythe relation between the constraints consensus algorithm andthe distributed simplex algorithm. We write �[i](t) for the valueof the basis of agent i at time t , when applying the distributedsimplex algorithm, and ✓ [i](t) for the value of the basis (in theabstract sense) for an agent applying the constraints consensusalgorithm. We speak of the trajectories �[i] and ✓ [i] to denotethe evolution of these quantities during the run-time of thealgorithm.

Proposition 5.3 (Duality). Let (H, b) be a fully non-degenerate,feasible linear program with a bounded optimal solution. Thenthe trajectories �[i] produced by the distributed simplex algo-rithm applied to the primal problem (2) are equivalent to thetrajectories ✓ [i] produced by the constraints consensus algorithm,Notarstefano and Bullo (2011), applied to the dual linear program{min �bT y, subj. to AT y c}.Proof. Given a subset of columns or constraints, respectively, G ⇢H, by strong duality, it holds that �G = {min cTGxG, AGxG =b, xG � 0} = {min �bTGyG, AT

GyG c} = ✓G. In both algorithms,the ‘‘local’’ solvers Simplex and Subex_LP (see Notarstefano &Bullo, 2011) solve the subproblems and determine �G and ✓G. Thecorresponding bases (in the primal and in the abstract sense) areunique, since the problem is by assumption non-degenerate andSubex_LP is applicable since the problem is feasible and bounded.Thus, given the same information setG, both algorithms compute abasis in the respective sensewith the same value. Agents exchangein both algorithms their locally optimal bases with neighbors, andthus the information available to an agent at a specific instant aredual. Thus, the two algorithms realize the same trajectories�[i]

B and✓ [i]B and are dual to each other. ⇤

6. Application to the multi-agent assignment

We motivated the formulation of distributed linear programswith the multi-agent assignment problem. Table 1 clarifies therelations between the two problem formulations. The assignmentproblem (1) is always primal degenerate, since a basis consistsof 2N � 1 columns, while only N of the corresponding primalvariables xi (representing the optimal assignment) are non-zero.As discussed in Remark 2.1, it is also often dual degenerate. Thedistributed simplex algorithm is therefore perfectly suited to solvethe distributed assignment problem. This claim is supported bythe fact that only very little data exchange between the agents isrequired.

Proposition 6.1 (Communication Requirements). At each commu-nication instant, every agent transmits at most O(N log2 N) bytes.

Table 1

The assignment problem data as a distributed linear program.

hi : Edge of Ga connecting agent i and task H: Edges of Gab: Vector of ones in R2N�1P[i]: Edges of Ga connecting agent iwith the tasksB: Spanning tree of Ga , with 2N � 1 arcs

Fig. 2. Average number of communication rounds and the 95% trust interval forrandommulti-agent assignment problems with communication according to cyclegraphs (solid) and Erdös–Rényi graphs (dashed).

Proof. The integers ci can be encodedwith 2 bytes. Then a columncanbe encodedwith 2+d 14 (log2(N)+1)ebytes. Thus, at each roundat most (2N � 1) · (2 + d 14 (log2(N) + 1)e) bytes are sent out byeach agent. ⇤

We use assignment problems to analyze the expected time com-plexity of the distributed simplex algorithm. Although our al-gorithm is shown to work in asynchronous networks, for theclarity of presentation we consider here synchronous commu-nication. The time interval between subsequent informationexchanges is called communication round. We consider randomassignment graphs Ga, generated with an edge probability 100

N2 andcost coefficients ci 2 [0, 20]. In Fig. 2, we compare two differ-ent communication schemes: an undirected cycle graph and ran-dom Erdös–Rényi graphs. For the latter, we use the probabilityp = (1 + ✏) log(N)

N , (✏ > 0), for which the resulting graph Gc isalmost surely connected. Note that the diameter of a cycle graphgrows with the number of edges, whereas the average diameter ofErdös–Rényi graphs is log(N)/ log(pN). For each configuration tensimulations are performed, and the average number of commu-nication rounds (with the corresponding 95% trust intervals) areshown in Fig. 2. For the Erdös–Rényi graphs, the number of com-munication rounds remains approximately constant as the num-ber of agents grows, whereas for the cycle graph it grows linearlywith the number of agents. This can be explainedwith the fact thatthe diameter of the cycle graph grows linearly with the number ofnodes, whereas the one of the randomgraph remains constant. Thesimulations support the following conjecture on the expected timecomplexity of the distributed simplex algorithm.

Conjecture 6.2. The average time complexity of the distributedsimplex algorithm belongs, on a fixed communication graph Gc , toO(diam(Gc)).

7. Conclusions

We have proposed the notion of Distributed Linear Programs,as an extension of linear programs to a multi-agent setup. Byutilizing a non-standard version of the classical simplex algorithm,

2304 M. Bürger et al. / Automatica 48 (2012) 2298–2304

the distributed simplex has been derived for solving DistributedLinear Programs. The multi-agent assignment problem has beenintroduced as a relevant problem class for which the algorithm isespecially well suited.

A major challenge for future research is a precise characteriza-tion of the algorithm’s complexity. As is known from centralizedsimplex algorithms, exact and meaningful statements concerningthe expected complexity are hard to obtain. The distributed setupincludes several additional challenges which will have to be ad-dressed in future research.

References

Bertsekas, D. P. (1989). The auction algorithm: a distributed relaxation method forthe assignment problem. Annals of Operations Research, 14(1–4), 105–123.

Bertsekas, D. P. (1998).Network optimization: continuous and discretemodels. AthenaScientific.

Bertsekas, D. P., & Tsitsiklis, J. N. (1997). Parallel and distributed computations:numerical methods. Belmont, Massachusetts: Athena Scientific.

Bolognani, S., & Zampieri, S. (2010). Distributed Quasi-Newton method and itsapplication to the optimal reactive power flow problem. In Proceedings ofNECSYS 2010 Annecy, France. September.

Brunet, L., Choi, H. -L., & How, J. P. (2008). Consensus-based auction approachesfor decentralized task assignment. In AIAA guidance, navigation and controlconference and exhibit Honolulu, Hawaii. August.

Burkard, R. (2002). Selected topics on assignment problems. Discrete AppliedMathematics, 123, 257–302.

Castañón, D. A., & Wu, C. (2003). Distributed algorithms for dynamic reassignment.In IEEE conference on decision and controlMaui, Hawaii. December (pp. 13–18).

Dantzig, G., & Wolfe, P. (1961). The decomposition algorithm for linear programs.Econometrica, 29(4), 767–778.

Dutta, H., & Kargupta, H. (2008). Distributed linear programming and resourcemanagement for data mining in distributed environments. In IEEE internationalconference on data mining (pp. 543–552).

Fukuda, K., Lüthi, H.-J., & Namiki, M. (1997). The existence of a short sequence ofadmissible pivots to an optimal basis in LP and LCP. International Transactions inOperational Research, 4(4), 273–284.

Gärtner, B., & Welzl, E. (1996). Linear programming-randomization and abstractframeworks. In Lecture notes in computer science: Vol. 1046. Symposium ontheoretical aspects of computer science (pp. 669–687). Springer (Chapter).

Hall, J., &McKinnon, K. (1998). ASYNPLEX, an asynchronous parallel revised simplexalgorithms. Annals of Operations Research, 81(24), 27–50.

Jones, C., Kerrigan, E., & Maciejowski, J. (2007). Lexicographic perturbation formultiparametric linear programming with applications to control. Automatica,43(10), 1808–1816.

Luenberger, D. G. (1973). Introduction to linear and nonlinear programming. Addison-Wesley Publishing Company.

Moore, B. J., & Passino, K. M. (2007). Distributed task assignment for mobile agents.IEEE Transactions on Automatic Control, 52(4), 749–753.

Nedic, A., Ozdaglar, A., & Parrilo, P. A. (2010). Constrained consensus andoptimization in multi-agent networks. IEEE Transactions on Automatic Control,55(4), 922–938.

Notarstefano, G., & Bullo, F. (2011). Distributed abstract optimization via constraintsconsensus: theory and applications. IEEE Transactions on Automatic Control,56(10), 2247–2261.

Smith, S. L., & Bullo, F. (2009). Monotonic target assignment for robotic networks.IEEE Transactions on Automatic Control, 54(9), 2042–2057.

Yarmish, G., & Slyke, R. (2009). A distributed, scalable simplex method. Journal ofSupercomputing , 49(3), 373–381.

Zavlanos,M.M., Spesivtsev, L., & Pappas, G. J. (2008). A distributed auction algorithmfor the assignment problem. In IEEE conference on decision and control Cancun,Mexico. December (pp. 1212–1217).

Zhu, M., & Martínez, S. (2012). On distributed convex optimzation underinequality and equality constraints via primal–dual subgradient methods. IEEETransactions on Automatic Control, 57(1), 151–164.

Mathias Bürger received his Diploma degree in Engineer-ing Cybernetics from the University of Stuttgart in 2009.He is currently working towards his Ph.D. degree at theUniversity of Stuttgart. Hewas a visiting student at Univer-sity of Toronto and a visiting scholar at Queen’s University,Kingston, ON, and at University of California at Santa Bar-bara. His research interests include distributed optimiza-tion and dynamical network analysis.

Giuseppe Notarstefano has been ‘‘Ricercatore’’ (AssistantProfessor) at the University of Lecce (Universit delSalento), Italy, since February 2007. He received the Laureadegree ‘‘summa cum laude’’ in Electronics Engineeringfrom the University of Pisa, Italy, in 2003 and the Ph.D.degree in Automation and Operation Research from theUniversity of Padova, Italy, in April 2007. He was a visitingscholar at the University of Stuttgart (October 2009), atthe University of California Santa Barbara (April 2009 andMarch–September 2005) and at the University of ColoradoBoulder (April–May 2006). His research interests include

distributed optimization andmotion coordination inmulti-agent networks, appliednonlinear optimal control, and dynamics, control and trajectory optimization ofautonomous vehicles.

Francesco Bullo is a Professor with the Center for Control,Dynamical Systems and Computation at UC Santa Barbara.His research interest include: multi-agent networks withapplication to robotic coordination, distributed computingand power networks. Other areas are vehicle routing,geometric control, and motion planning. He is thecoauthor of ‘‘Geometric Control of Mechanical Systems’’(Springer, 2004, with Andrew Lewis) and ‘‘DistributedControl of Robotic Networks’’ (Princeton, 2009, with JorgeCortes and Sonia Martinez). He is an IEEE Fellow, recipientof the 2003 ONR Young Investigator Award, the 2008 IEEE

CSM Outstanding Paper Award and the 2010 Hugo Schuck Award.

Frank Allgöwer is the director of the Institute for Sys-tems Theory and Automatic Control at the University ofStuttgart. He studied Engineering Cybernetics and AppliedMathematics in Stuttgart and at UCLA respectively andreceived his Ph.D. from the University of Stuttgart. Priorto his present appointment he held a professorship inElectrical Engineering at ETH Zurich. He received severalrecognitions for his work including the prestigious Got-tfried–Wilhelm–Leibniz prize of theDeutsche Forschungs-gemeinschaft. Hismain areas of interest are in cooperativecontrol, predictive control and systems biology.