Mas kevin b-2007


Published on

  • Be the first to comment

  • Be the first to like this

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

Mas kevin b-2007

  1. 1. M ULTIAGENT S YSTEMS Algorithmic, Game Theoretic, and Logical Foundations Yoav Shoham Stanford University˜shoham Kevin Leyton-Brown University of British Columbia˜kevinlb c all rights reserved Draft of August 27, 2007 For use with the authors’ permission only. Please do not distribute.
  2. 2. ContentsCredits and Acknowledgments ixIntroduction xi1 Distributed Problem Solving 1 1.1 Distributed constraint satisfaction 2 1.1.1 Domain-pruning algorithms 4 1.1.2 Trial-and-backtrack algorithms 8 1.2 Distributed dynamic programming for path planning 11 1.2.1 Asynchronous dynamic programming 11 1.2.2 Learning real-time A∗ 13 1.3 Negotiation, auctions and optimization 15 1.3.1 Introduction: from contract nets to auction-like optimization 15 1.3.2 The assignment problem and linear programming 19 1.3.3 The scheduling problem and integer programming 25 1.4 Action selection in multiagent MDPs 32 1.5 History and references 352 Introduction to Non-Cooperative Game Theory: Games in Normal Form 37 2.1 Self-interested agents 37 2.1.1 Example: friends and enemies 38 2.1.2 Preferences and utility 39 2.2 Games in normal form 43 2.2.1 Example: The TCP user’s game 44 2.2.2 Definition of games in normal form 45 2.2.3 More examples of normal-form games 46 2.2.4 Strategies in normal-form games 49 2.3 Solution concepts for normal-form games 50 2.3.1 Pareto optimality 50 2.3.2 Best response and Nash equilibrium 51 2.3.3 Maxmin and minmax strategies 55 2.3.4 Minimax regret 58 2.3.5 Removal of dominated strategies 60
  3. 3. ii Contents 2.3.6 Rationalizability 63 2.3.7 Correlated equilibrium 64 2.3.8 Trembling-hand perfect equilibrium 66 2.3.9 ǫ-Nash equilibrium 66 2.4 History and references 67 3 Computing Solution Concepts of Normal-Form Games 69 3.1 Computing Nash equilibria of two-player zero-sum games 69 3.2 Computing Nash equilibria of two-player general-sum games 71 3.2.1 Complexity of computing Nash equilibria 71 3.2.2 An LCP formulation and the Lemke-Howson algorithm 73 3.2.3 Searching the space of supports 79 3.3 Computing Nash equilibria of n-player general-sum games 81 3.4 Computing all Nash equilibria of general-sum games 84 3.5 Computing specific Nash equilibria of general-sum games 85 3.6 Computing maxmin and minmax strategies for two-player general-sum games 86 3.7 Removing dominated strategies 86 3.7.1 Domination by a pure strategy 87 3.7.2 Domination by a mixed strategy 88 3.7.3 Iterated dominance 89 3.8 Computing correlated equilibria of n-player normal-form games 91 3.9 History and references 92 4 Playing Games with Time: Reasoning and Computing with the Extensive Form 95 4.1 Perfect-information extensive-form games 95 4.1.1 Definition 96 4.1.2 Strategies and equilibria 96 4.1.3 Subgame-perfect equilibrium 99 4.1.4 Computing equilibria: backward induction 101 4.1.5 An example, and criticisms of backward induction 105 4.2 Imperfect-information extensive-form games 106 4.2.1 Definition 107 4.2.2 Strategies and equilibria 108 4.2.3 Computing equilibria: the sequence form 110 4.2.4 Sequential equilibrium 118 4.3 History and references 121 5 Richer Representations: Beyond the Normal and Extensive Forms 123 5.1 Repeated games 124 5.1.1 Finitely repeated games 125 5.1.2 Infinitely repeated games 125 5.1.3 “Bounded rationality”: repeated games played by automata 128 5.2 Stochastic games 134 5.2.1 Definition 134 5.2.2 Strategies and equilibria 135 c Shoham and Leyton-Brown, 2007
  4. 4. Contents iii 5.2.3 Computing equilibria 136 5.3 Bayesian games 137 5.3.1 Definition 139 5.3.2 Strategies and equilibria 142 5.3.3 Computing equilibria 144 5.3.4 Ex-post equilibria 147 5.4 Congestion games 147 5.4.1 Definition 147 5.4.2 Computing equilibria 149 5.4.3 Potential games 150 5.4.4 Nonatomic congestion games 152 5.4.5 Selfish routing and the price of anarchy 153 5.5 Computationally-motivated compact representations 158 5.5.1 The expected utility problem 158 5.5.2 Graphical games 161 5.5.3 Action-graph games 162 5.5.4 Multiagent influence diagrams 165 5.5.5 GALA 167 5.6 History and references 1686 Learning and Teaching 171 6.1 Why the subject of ‘learning’ is complex 171 6.1.1 The interaction between learning and teaching 171 6.1.2 What constitutes learning? 173 6.1.3 If learning is the answer, what is the question? 174 6.2 Fictitious play 177 6.3 Rational learning 182 6.4 Reinforcement learning 186 6.5 Learning in unknown MDPs 186 6.5.1 Reinforcement learning in zero-sum stochastic games 187 6.5.2 Beyond zero-sum stochastic games 191 6.5.3 Belief-based reinforcement learning 191 6.6 No-regret learning and universal consistency 191 6.7 Targeted learning 193 6.8 Evolutionary learning and other large-population models 194 6.8.1 The replicator dynamic 195 6.8.2 Evolutionarily stable strategies 198 6.8.3 Agent-based simulation and emergent conventions 201 6.9 History and references 2037 Communication 205 7.1 “Doing by talking” I: cheap talk 205 7.2 “Talking by doing”: signaling games 209 7.3 “Doing by talking” II: speech-act theory 211 7.3.1 Speech acts 211 7.3.2 Rules of conversation 212 Multiagent Systems, draft of August 27, 2007
  5. 5. iv Contents 7.3.3 A game theoretic view of speech acts 214 7.3.4 Applications 217 7.4 History and references 220 8 Aggregating Preferences: Social Choice 223 8.1 Introduction 223 8.1.1 Example: plurality voting 223 8.2 A formal model 224 8.2.1 Social choice functions 225 8.2.2 Social welfare functions 226 8.3 Voting 226 8.3.1 Voting methods 226 8.3.2 Voting paradoxes 228 8.4 Existence of social functions 229 8.4.1 Social welfare functions 230 8.4.2 Social choice functions 232 8.5 Ranking systems 236 8.6 History and references 239 9 Protocols for Strategic Agents: Mechanism Design 241 9.1 Introduction 241 9.1.1 Example: strategic voting 241 9.1.2 Example: selfish routing 242 9.2 Mechanism design with unrestricted preferences 243 9.2.1 Implementation 243 9.2.2 The revelation principle 245 9.2.3 Impossibility of general, dominant-strategy implementation 247 9.3 Quasilinear preferences 248 9.3.1 Risk attitudes 249 9.3.2 Mechanism design in the quasilinear setting 251 9.4 Groves mechanisms 254 9.4.1 The VCG mechanism 258 9.4.2 Drawbacks of VCG 260 9.4.3 VCG and individual rationality 262 9.4.4 Weak budget balance 263 9.5 Budget balance and efficiency 264 9.5.1 Impossibility results 264 9.5.2 The AGV mechanism 265 9.6 Beyond efficiency 266 9.6.1 What else can be implemented in dominant strategies? 266 9.6.2 Tractable Groves mechanisms 268 9.7 Applications of mechanism design 270 9.8 History and references 270 10 Protocols for Multiagent Resource Allocation: Auctions 273 10.1 Single-good auctions 273 c Shoham and Leyton-Brown, 2007
  6. 6. Contents v 10.1.1 Canonical auction families 274 10.1.2 Auctions as Bayesian mechanisms 276 10.1.3 Second-price, Japanese and English auctions 277 10.1.4 First-price and Dutch auctions 279 10.1.5 Revenue equivalence 281 10.1.6 Risk attitudes 284 10.1.7 Auction variations 285 10.1.8 “Optimal” (revenue-maximizing) auctions 286 10.1.9 Collusion 288 10.1.10 Interdependent values 291 10.2 Multiunit auctions 293 10.2.1 Canonical auction families 294 10.2.2 Single-unit demand 295 10.2.3 Beyond single-unit demand 297 10.2.4 Unlimited supply 299 10.2.5 Position auctions 301 10.3 Combinatorial auctions 304 10.3.1 Simple combinatorial auction mechanisms 305 10.3.2 The winner determination problem 306 10.3.3 Expressing a bid: bidding languages 310 10.3.4 Iterative mechanisms 314 10.3.5 A tractable mechanism 316 10.4 Exchanges 318 10.4.1 Two-sided auctions 318 10.4.2 Prediction markets 319 10.5 History and references 32011 Teams of Selfish Agents: An Introduction to Coalitional Game Theory 323 11.1 Definition of coalitional games 323 11.2 Classes of coalitional games 325 11.3 Analyzing coalitional games 326 11.3.1 The core 327 11.3.2 The Shapley value 329 11.3.3 Other solution concepts 331 11.4 Computing coalitional game theory solution concepts 331 11.5 Compact representations of coalitional games 332 11.5.1 Weighted graph games 333 11.5.2 Weighted majority games 335 11.5.3 Capturing synergies: a representation for super-additive games 335 11.5.4 A decomposition approach: multi-issue representation 336 11.5.5 A logical approach: marginal contribution nets 337 11.6 History and references 33812 Logics of Knowledge and Belief 341 12.1 The partition model of knowledge 341 12.1.1 Muddy children and warring generals 341 Multiagent Systems, draft of August 27, 2007
  7. 7. vi Contents 12.1.2 Formalizing intuitions about the partition model 342 12.2 A detour to modal logic 345 12.2.1 Syntax 346 12.2.2 Semantics 346 12.2.3 Axiomatics 347 12.2.4 Modal logics with multiple modal operators 347 12.2.5 Remarks about first-order modal logic 348 12.3 S5: An axiomatic theory of the partition model 348 12.4 Common knowledge, and an application to distributed systems 351 12.5 Doing time, and an application to robotics 354 12.5.1 Termination conditions for motion planning 354 12.5.2 Coordinating robots 358 12.6 From knowledge to belief 360 12.7 Combining knowledge and belief (and revisiting knowledge) 361 12.8 History and references 366 13 Beyond Belief: Probability, Dynamics and Intention 369 13.1 Knowledge and probability 369 13.2 Dynamics of knowledge and belief 373 13.2.1 Belief revision 374 13.2.2 Beyond AGM: update, arbitration, fusion, and friends 379 13.2.3 Theories of belief change: a summary 383 13.3 Logic, games, and coalition logic 384 13.4 Towards a logic of ‘intention’ 386 13.4.1 Some pre-formal intuitions 386 13.4.2 The road to hell: elements of a formal theory of intention 388 13.4.3 Group intentions 392 13.5 History and references 393 Appendices: Technical Background 395 A Probability Theory 397 A.1 Probabilistic models 397 A.2 Axioms of probability theory 397 A.3 Marginal probabilities 398 A.4 Conditional probabilities 398 B Linear and Integer Programming 399 B.1 Linear programs 399 B.2 Integer programs 401 C Markov Decision Problems (MDPs) 403 C.1 The model 403 C.2 Solving known MDPs via value iteration 403 D Classical Logic 405 c Shoham and Leyton-Brown, 2007
  8. 8. Contents vii D.1 Propositional calculus 405 D.2 First-order logic 406Bibliography 409Index 425 Multiagent Systems, draft of August 27, 2007
  9. 9. Credits and AcknowledgmentsWe should start off by explaining the order of authorship. Yoav conceived of theproject, and started it, in late 2001, working on it alone and with several colleagues(see below). Sometime in 2004 Yoav realized he needed help if the project were everto come to conclusion, and he enlisted the help of Kevin. The result was a true partner-ship and a complete overhaul of the material. The current book is vastly different fromthe draft that existed when the partnership was formed—in depth, breadth, and form.Yoav and Kevin have made equal contributions to the book; the order of authorshipreflects the history of the book, but nothing else. In six years of book-writing we accumulated many debts. The following is our besteffort to acknowledge those. If we omit any names it is due solely to our poor memoriesand record keeping, and we apologize in advance. When the book started out, Teg Grenager served as a prolific ghost writer. Whilelittle of the original writing remains (though some does, e.g., in the section on speechacts), the project would not have gotten off the ground without him. Several past and present graduate students made substantial contributions. The ma-terial on coalitional games was written by Sam Ieong, with minimal editing on ourpart. Some of the material on computing solution concepts is based on writing byRyan Porter, who also wrote much of the material on bounded rationality. The mate-rial on multiagent learning is based in part on joint work with Rob Powers, who alsocontributed text. The material on graphical games is based on writing by Albert Jiang,who also contributed to the proof of the minmax theorem. Many colleagues across the world generously gave us comments on drafts, or pro-vided counsel otherwise. Felix Brandt and Vince Conitzer deserve special mention fortheir particularly detailed and insightful comments. Other colleagues to whom we areindebted include Alon Altman, Krzysztof Apt, Ronen Brafman, Yiling Chen, Nando deFreitas, Joe Halpern, Jason Hartline, Jean-Jacques Herings, Bobby Kleinberg, DaphneKoller, David Parkes, Baharak Rastegari, Tuomas Sandholm, Peter Stone, Moshe Ten-nenholtz, Nikos Vlasis, Mike Wellman, and Mike Wooldridge. Several of our colleagues generously contributed material to the book, in addition tolending their insight. They include Geoff Gordon (Matlab code to generate the saddlepoint figure for zero-sum games), Carlos Guestrin (on action selection in distributedMDPs, and a sensor-nets figure), Michael Littman (on subgame perfection), Chris-tos Papadimitriou (on the Lemke-Howson algorithm, taken from his chapter in [Nisanet al., 2007]), Marc Pauly (on coalition logic), and Christian Shelton (on computingNash equilibria for n-person games).
  10. 10. x Credits and Acknowledgments Several people provided critical editorial and production assistance of various kinds. Chris Manning was kind enough to let us use the LTEX macros from his own book, A and Ben Galin added a few miracles of his own. (Ben also composed several of the examples, found some bugs, drew many figures, and more generally for two years served as an intelligent jack of all trades on this project.) David Thompson overhauled our figures, code formatting and index, and also gave some feedback on drafts. Erik Zawadzki helped with the bibliography and with some figures. Maia Shoham helped with some historical notes and bibliography entries, as well as with some copy-editing. We thank all these friends and colleagues. Their input has contributed to a better book, but of course they are not to be held accountable for any remaining shortcomings. We claim sole credit for those. We also wish to thank [[[publisher]]] for agreeing to publish the book, for their pa- tience and conscientious production process, and for their enlightened online-publishing policy which has enabled us to provide the broadest possible access to the book. Last, and certainly not the least, we thank our families [[[...]]] c Shoham and Leyton-Brown, 2007
  11. 11. IntroductionImagine a personal software agent engaging in electronic commerce on your behalf.Say the task of this agent is to track goods available for sale in various online venuesover time, and to purchase some of them on your behalf for an attractive price. In orderto be successful, your agent will need to embody your preferences for products, yourbudget, and in general your knowledge about the environment in which it will operate.Moreover, the agent will need to embody your knowledge of other similar agents withwhich it will interact (for example, agents who might compete with it in an auction, oragents representing store owners)—including their own preferences and knowledge. Acollection of such agents forms a multiagent system. The goal of this book is to bringunder one roof a variety of ideas and techniques that provide foundations for modeling,reasoning about, and building multiagent systems. Somewhat strangely for a book that purports to be rigorous, we will not give a pre-cise definition of a multiagent system. The reason is that many competing, mutuallyinconsistent answers have been offered in the past. Indeed, even the seemingly sim-pler question—What is a (single) agent?—has resisted a definitive answer. For ourpurposes, the following loose definition will suffice: Multiagent systems are those sys-tems that include multiple autonomous entities with either diverging information ordiverging interests, or both.Scope of the bookThe motivation for studying multiagent systems often stems from the interest in artifi-cial (software or hardware) agents, for example software agents living on the Internet.Indeed, the Internet can be viewed as the ultimate platform for interaction among self-interested, distributed computational entities. Such agents can be trading agents of thesort discussed above, “interface agents” that facilitate the interaction between the userand various computational resources (including other interface agents), game-playingagents that assist (or replace) a human player in a multi-player game, or autonomousrobots in a multi-robot setting. However, while the material is written by computerscientists with computational sensibilities, it is quite interdisciplinary and the mate-rial is in general fairly abstract. Many of the ideas apply to—and indeed often takenfrom—inquiries about human individuals and institutions. The material spans disciplines as diverse as computer science (including artificialintelligence, distributed systems, and algorithms), economics, operations research, an-alytic philosophy and linguistics. The technical material includes logic, probability
  12. 12. xii Introduction theory, game theory, and optimization. Each of the topics covered easily supports multiple independent books and courses, and this book does not aim to replace them. Rather, the goal has been to gather the most important elements from each discipline, and weave them together into a balanced and accurate introduction to this broad field. The intended reader is a advanced undergraduate (prototypically, but not necessarily, in computer science), or a graduate student making a first foray into the area. Since the umbrella of multiagent systems is so broad, the questions of what to in- clude in any book on the topic and how to organize the selected material are crucial. To begin with, this book concentrates on foundational topics rather than surface ap- plications. Although we will occasionally make reference to real-world applications, we will do so primarily to clarify the concepts involved; this is despite the practical motivations professed above. And so this is the wrong text for the reader interested in a practical guide into building this or that sort of software. The emphasis is rather on important concepts and the essential mathematics behind them. The intention is to delve in enough detail into each topic to be able to tackle some technical material, and then to point the reader in the right directions for further education on particular topics. The decision was thus to include predominantly established, rigorous material that is likely to withstand the test of time. This still leaves vast material from which to choose. In understanding the selection made here, it is useful to keep in mind the keywords in the book’s (rather long) subtitle: coordination, competition, algorithms, game theory, and logic. These terms will help frame the chapters overview which comes next. Overview of the chapters Starting with issues of coordination, we begin in Chapter 1 with distributed prob- lem solving. In these multi-agent settings there is no question of agents’ individual preferences; there is some global problem to be solved, but for one reason or another it is either necessary or advantageous to distribute the task among multiple agents, whose actions may require coordination. The chapter thus is strongly algorithmic. Specifically, we look at four algorithmic methods: distributed constraint satisfaction, distributed dynamic programming, auction-like optimization procedures of linear- and integer-programming, and action selection in distributed MDPs. We then begin to embrace issues of competition as well as coordination. While the area of multi-agent systems is not synonymous with game theory, there is no question that game theory is a key tool to master within the field, and so we devote several chap- ters to it. Chapters 2, 4 and 5 constitute a crash course in non-cooperative game theory (they cover, respectively, the normal form, the extensive form, and a host of other game representations). In these chapters, as in others which draw on game theory, we culled the material that in our judgment is needed in order to be a knowledgeable consumer of modern-day game theory. Unlike traditional game theory texts, we include also dis- cussion of algorithmic considerations. In the context of the normal-form representation that material is sufficiently substantial to warrant its own chapter, Chapter 3. We then switch to two specialized topics in multi-agent systems. In Chapter 6 we cover multi-agent learning. The topic is interesting for several reasons. First, it is a key facet of multi-agent systems. Second, the very problems addressed in the area c Shoham and Leyton-Brown, 2007
  13. 13. xiiiare diverse and sometimes ill understood. Finally, the techniques used, which drawequally on computer science and game theory (as well as some other disciplines), arenot straightforward extensions of learning in the single-agent case. In Chapter 7 we cover another element unique to multi-agent systems, communi-cation. We cover communication in a game theoretic setting, as well as in cooperativesettings traditionally considered by linguists and philosophers (except that we see thatthere too a game theoretic perspective can creep in). Next is a three-chapter sequence that might be called “protocols for groups.” Chap-ters 8 covers social-choice theory, including voting methods. This is a non-strategictheory, in that it assumes that the preferences of agents are known, and the only ques-tion is how to aggregate them properly. Chapter 9 covers mechanism design, whichlooks at how such preferences can be aggregated by a central designer even withoutthe cooperation of the agents involved. Finally, Chapter 10 looks at the special caseof auctions. Chapter 11 covers coalitional game theory, in recent times somewhat neglectedwithin game theory and certainly under-appreciated in computer science. The material in Chapters 1–11 is mostly Bayesian and/or algorithmic in nature.And thus the tools used in them include probability theory, utility theory, algorithms,Markov Decision Problems (MDPs), and linear/integer programming. We concludewith two chapters on logical theories in multi-agent systems. In Chapter 12 we covermodal logic of knowledge and belief. This material hails from philosophy and com-puter science, but it turns out to dovetail very nicely with the discussion of Bayesiangames in Chapter 5. Finally, in Chapter 13 we extend the discussion in severaldirections—we discuss how beliefs change over time, on logical models of games, andhow one might begin to use logic to model motivational attitudes (such as ‘intention’)in addition to the informational ones (knowledge, belief).Required backgroundThe book is rigorous, and requires mathematical thinking, but only basic specific back-ground knowledge. In much of the book we assume knowledge of basic computerscience (algorithms, complexity) and basic probability theory. In more specific partswe assume familiarity with Markov Decision Problems (MDPs), mathematical pro-gramming (specifically, linear and integer programming), and classical logic. All ofthese (except basic computer science) are covered briefly in appendices, but those aremeant as refreshers and to establish notation, not as a substitute for background inthose subjects (this is true in particular of probability theory). However, above all, aprerequisite is a capacity for clear thinking.How to teach (and learn) from this bookThere is partial dependence among the thirteen chapters. To understand them, it isuseful to think of the book as consisting of the following “blocks”: Block 1, Chapter 1: Distributed problem solving Multiagent Systems, draft of August 27, 2007
  14. 14. xiv Introduction Block 2, Chapters 2–5: Non-cooperative game theory Block 3, Chapter 6: Learning Block 4, Chapter 7: Communication Block 5, Chapters 8–10: Protocols for groups Block 6, Chapter 11: Coalitional game theory Block 7, Chapters 12–13: Logical theories Within every block there is a sequential dependence. Among the blocks, however, there is only one strong dependence: Blocks 3, 4 and 5 each depend on some ele- ments of non-cooperative game theory, and thus on block 2 (though none require the entire block). Otherwise there are some interesting local pairwise connections between blocks, but none that require that both blocks be covered, whether sequentially or in parallel. Given this weak dependence among the chapters, there are many ways to craft a course out of the material, depending on the background of the students, their interests, and the time available. Here are two examples: • A format Yoav has used in a course consisting of up to twenty 75-minute lectures is as follows: 3 lectures on Chapter 1, 4 on Chapters 2–5, 3 on the material from Chap- ter 6, 3 on Chapters 8–10, 1 on Chapter 11, 3 on the material from Chapters 12–13, and 1 on Chapter 7. The experienced instructor will recognize that adding up these days easily brings you to a total of 20. This structure is appropriate for students interested in a broad, yet technical introduction to the area. • Kevin teaches a course consisting of 23 lectures which goes into more detail but which concentrates on individual, strategic theories. Specifically, he structures his course as follows: 1 lecture introduction, 3 based on Chapters 2, 1 on Chapter 3, 2 on 4, 2 on 5, 2 on Chapter 8, 5 on Chapter 9, 5 on Chapter 10 and 2 on Chapter 1. Many other formats are possible, and the book’s website contains additional re- sources for instructors. On pronouns and gender We use the male form throughout the book. We debated this between us, not being happy with any of the alternatives. In the end the “standard” male convention won over the newer, reverse female convention. We hope the reader is not offended, and if she is, that she forgives us. c Shoham and Leyton-Brown, 2007
  15. 15. 1 Distributed Problem Solving In this chapter we discuss cooperative situations, in which the agents collaborate to achieve a common goal. This goal can be viewed as the shared goal of the agents, or alternatively as the goal of a central designer who is designing the various agents. Of course, if such a designer exists, a natural question is why it matters that there exist multiple agents; they can be viewed merely as end sensors and effectors for executing the plan devised by the designer. However, there exist situations in which a problem needs to be solved in a distributed fashion, either because a central controller is not feasible or because one wants to make good use of the distributed resources. A good example is provided by sensor networks. Such networks consist of multiple process- sensor networks ing units, each with very local sensor capabilities, limited processing power, limited power supply, and limited communication bandwidth. Despite these limitations, these networks aim to provide some global service. Figure 1.1 shows an example of a fielded sensor network for monitoring environmental quantities like humidity, temperature and pressure in an office environment. Each sensor can monitor only its local area, and similarly can communicate only with other sensors in its local vicinity. The question is what algorithm the individual sensors should run so that the center can still piece together a reliable global picture. Distributed algorithms have been studied widely in computer science. We will con- centrate on distributed problem solving algorithms of the sort studied in Artificial In- telligence. Specifically, we will consider four families of techniques, and associated sample problems. They are, in order: • Distributed constraint satisfaction algorithms. • Distributed dynamic programming (as applied to path planning problems). • Auction-like optimization algorithms (as applied to matching and scheduling prob- lems). • Distributed solutions to Markov Decision Problems (MDPs). Later in the book we will encounter two additional examples of distributed problem solving. In Chapter 6 we will will encounter a family of techniques that involve learn- ing, some of them targeted at purely cooperative situations. We delay the discussion
  16. 16. 2 1 Distributed Problem Solving QUIET PHONE LAB SERVER Figure 1.1 Part of a real sensor network used for indoor environmental monitoring. to that chapter since it requires some discussion of non-cooperative game theory (dis- cussed in Chapter 2) as well as general discussion of multiagent learning (discussed earlier in Chapter 6). In addition, in Chapter 12, we will see an application of logics of knowledge to distributed control in the context of robotics. That material too must be postponed, since it relies on the preceding material in Chapter 12. 1.1 Distributed constraint satisfaction constraint A constraint satisfaction problem (CSP) is defined by a set of variables, domains for satisfaction each of the variables, and constraints on the values that the variables might take on problem (CSP) simultaneously. The role of constraint satisfaction algorithms is to assign values to the variables in a way that is consistent with all the constraints, or to determine that no such assignment exists. Constraint satisfaction techniques have been applied in diverse domains, including machine vision, natural language processing, theorem proving, planning and schedul- ing, and many more. Here is a simple example taken from the domain of sensor net- works. Figure 1.2 depicts three radar-equipped units scattered in a certain terrain. Each of the radars has a certain radius which, in combination with the obstacles in the envi- ronment, gives rise to a particular coverage area for each unit. As seen in the figure, some of the coverage areas overlap. We consider a very specific problem in this setting. c Shoham and Leyton-Brown, 2007
  17. 17. 1.1 Distributed constraint satisfaction 3Suppose that each unit can choose one of three possible radar frequencies. All of thefrequencies work equally well, so long as that no two radars with overlapping coveragearea use the same frequency. The question is which algorithms the units should employto select this frequency, assuming that the frequencies cannot be assigned centrally. Figure 1.2 A simple sensor net problem As is the case for many other CSPs, the essence of this problem can be captured asa graph coloring problem. Figure 1.3 shows such a graph, corresponding to the sensornetwork CSP above. The nodes represent the individual units, the different frequenciesare repented by ‘colors’, and two nodes are connected by an undirected edge iff thecoverage areas of the corresponding radars overlap. The goal of graph coloring is tochoose one color for each node so that no two adjacent nodes have the same color. {red, blue, green} X1 ƒ ƒ = ƒ= ƒ ƒ ƒ ƒ X2 X3 = {red, blue, green} {red, blue, green} Figure 1.3 A graph coloring problem equivalent to the sensor net problem of Figure 1.2 Formally speaking, a CSP consists of a finite set of variables X = {X1 , . . . , Xn }, Multiagent Systems, draft of August 27, 2007
  18. 18. 4 1 Distributed Problem Solving a domain Di for each variable Xi , and a set of constraints {C1 , . . . , Cm }. Although in general CSPs allows infinite domains, we will assume here that all the domains are finite. In the graph coloring example above there were three variables, and they all had the same domain—{red, green, blue}. Each constraint is a predicate on some subset of the variables, say Xi1 , . . . , Xij ; the predicate defines a relation which is a subset of the Cartesian product Di1 × . . . × Dij . Each such constraint restricts the values that may be simultaneously assigned to the variables participating in the constraint. In this chapter we will restrict the discussion to binary constraints, each of which constrains exactly two variables. For example, in the map coloring case, each “not equal” constraint applied to two nodes. Given a subset S of the variables, an instantiation of S is an assignment of a unique domain value for each variable in S; it is legal if it does not violate any constraint that mentions only variables in S. A solution to a network is a legal instantiation of all variables. Typical tasks associated with constraint networks are to determine whether a solution exists, to find one or all solutions, to determine whether a legal instantiation of some of the variables can be extended to a solution, and so on. We will concentrate on the most common task, which is finding one solution to a CSP—or proving that none exist. In a distributed CSP, each variable is owned by a different agent. The goal is still to find a global variable assignment that meets the constraints, but each agent decides on the value of his own variable with relative autonomy. While it does not have a global view, each agent can communicate with its neighbors in the constraint graph. A distributed algorithm for solving a CSP has each agent engage in some protocol that combines local computation with communication with its neighbors. A good algorithm ensures that such a process terminates with a legal solution (or with a realization that no legal solution exists), and does so quickly. We will discuss two types of algorithm. Algorithms of the first kind embody a least- commitment approach, and attempt to rule out impossible variable values without los- ing any possible solutions. Algorithms of the second kind embody a more adventurous spirit and select tentative variable values, backtracking when those choices prove un- successful. In both cases we assume that the communication between neighboring nodes is perfect, but nothing about its timing; messages can take more or less time without rhyme or reason. We do assume however that if node i sends multiple mes- sages to node j, those messages arrive in the order in which they were sent. 1.1.1 Domain-pruning algorithms Under domain-pruning algorithms nodes communicate with their neighbors in order to eliminate values from their domains. We will consider two such algorithms. In filtering the first, the filtering algorithm, each node communicates its domain to its neighbors, algorithm eliminates from its domain the values that are not consistent with the values received from the neighbors, and the process repeats. Specifically, each node xi with domain Di repeatedly executes the procedure Revise(xi , xj ) for each neighbor xj : arc consistency The process, known also under the general term arc consistency, terminates when no further elimination takes place, or when one of the domains becomes empty (in which case the problem has no solution). If the process terminates with one value in each c Shoham and Leyton-Brown, 2007
  19. 19. 1.1 Distributed constraint satisfaction 5 procedure Revise(xi , xj ) forall vi ∈ Di do if there is no value vj ∈ Dj such that vi is consistent with vj then delete vi from Didomain, that set of values constitutes a solution. If it terminates with multiple values ineach domain the result is inconclusive; the problem might or might not have a solution. Clearly the algorithm is guaranteed to terminate, and furthermore it is sound (in thatif it announced a solution, or announced that no solution exists, it is correct), but it isnot complete (that is, it may fail to pronounce a verdict). Consider, for example, thefamily of very simple graph coloring problems shown in Figure 1.4 (note that problem(d) is identical to the problem in Figure 1.3).
  20. 20. {red} {red} X1 X1 ƒ ƒ = ƒ = = ƒ =(a) ƒ (b) ƒ
  21. 21. ƒ ƒ ƒ ƒ X2 X3 X2 X3{red, blue} = {red, blue, green} {red, blue} = {red, blue}
  22. 22. {red, blue} {red, blue, green} X1 X1 ƒ ƒ = ƒ = = ƒ =(c) ƒ (d) ƒ
  23. 23. ƒ ƒ ƒ ƒ X2 X3 X2 X3{red, blue} = {red, blue} {red, blue, green} = {red, blue, green} Figure 1.4 A family of graph coloring problems In this family of CSPs the three variables (i.e., nodes) are fixed, as are the ‘not-equal’ constraints between them. What are not fixed are the domains of the variables.Consider the four instances of Figure 1.4: (a) Initially, as the nodes communicate to one another, only x1 ’s messages result in any change. Specifically, when either x2 or x3 receive x1 ’s message they remove red from their domains, ending up with D2 = {blue} and D3 = {blue, green}. Multiagent Systems, draft of August 27, 2007
  24. 24. 6 1 Distributed Problem Solving Then, when x2 communicates his new domain to x3 , x3 further reduces his do- main to {green}. At this point no further changes take place, and the algorithm terminates with a correct solution. (b) The algorithm starts as before, but once x2 and x3 receive x1 ’s message they each reduce their domain to {blue}. Now, when they update each other on their new domain, they each reduce their domain to {}, the empty set. At this point the algorithm terminates, and correctly announces that no solution exists. (c) In this case the initial set of messages yield no reduction in any domain. The algorithm terminates, but all the nodes have multiple values remaining. And so the algorithm is not able to show that the problem is over-constrained and has no solution. (d) Filtering can also fail when a solution exists. For similar reasons as in instance (c), the algorithm is unable to show that in this case the problem does have a solution. In general, filtering is a very weak method, and at best is used as a pre-processing step for more sophisticated methods. The algorithm is based directly on the notion of unit resolution unit resolution from propositional logic. Unit resolution is the following inference rule A1 ¬(A1 ∧ A2 ∧ . . . ∧ An ) ¬(A2 ∧ . . . ∧ An ) To see how the filtering algorithm corresponds to unit resolution, we must first write the constraints as forbidden value combinations, called nogoods. For example, the constraint that x1 and x2 cannot both take the value “red” would give rise to the propo- sitional sentence ¬(x1 = red ∧ x2 = red), which we write as the nogood {x1 , x2 }. In instance (b) from Figure 1.4 agent X2 updated his domain based on agent X1 ’s announcement that x1 = red and the nogood {x1 = red, x2 = red}: x1 = red ¬(x1 = red ∧ x2 = red) ¬(x2 = red) Unit resolution is a weak inference rule, and so it is not surprising that the filtering hyper-resolution algorithm is weak as well. Hyper-resolution is a generalization of unit resolution, and has the following form: A1 ∨ A2 ∨ . . . ∨ Am ¬(A1 ∧ A1,1 ∧ A1,2 ∧ . . .) ¬(A2 ∧ A2,1 ∧ A2,2 ∧ . . .) . . . ¬(Am ∧ Am,1 ∧ Am,2 ∧ . . .) ¬(A1,1 ∧ . . . ∧ A2,1 ∧ . . . ∧ Am,1 ∧ . . .) c Shoham and Leyton-Brown, 2007
  25. 25. 1.1 Distributed constraint satisfaction 7 Hyper-resolution is both sound and complete for propositional logic, and indeed itgives rise to a complete distributed CSP algorithm. In this algorithm, each agent repeat-edly generates new constraints for its neighbors, notifies them of these new constraints,and prunes its own domain based on new constraints passed to it by its neighbors.Specifically, it executes the following algorithm, where N Gi is the set of all nogoods ∗of which agent i is aware, and N Gj is a set of new nogoods communicated from agentj to agent i: procedure ReviseHR(N Gi , N G∗ ) j repeat N Gi ← N Gi N G∗ j let N G∗ denote the set of new nogoods that i can derive from N Gi and its i domain using hyper-resolution if N G∗ is nonempty then i N Gi ← N Gi N G∗ i send the nogoods N G∗ to all neighbors of i i if {} ∈ N G∗ then i stop until there is no change in your set of nogoods N Gi The algorithm is guaranteed to converge, in the sense that after sending and receivinga finite number of messages each agent will stop sending messages and generatingnogoods. Furthermore, the algorithm is complete. The problem has a solution iff, uponcompletion, no agent has generated the empty nogood (obviously every superset of anogood is also forbidden, and thus if a node ever generates an empty nogood then theproblem has no solution). Consider again instance (c) of the CSP problem in Figure 1.4. In contrast to thefiltering algorithm, the hyper-resolution-based algorithm proceeds as follows. Initially,x1 maintains four nogoods –{x1 = red, x2 = red}, {x1 = red, x3 = red},{x1 = blue, x2 = blue}, {x1 = blue, x3 = blue} – which are derived directly fromthe constraints involving x1 . Furthermore, x1 must adopt one of the values in its do-main, so x1 = red ∨ x1 = blue. Using hyper-resolution, x1 can reason: x1 = red ∨ x1 = blue ¬(x1 = red ∧ x2 = red) ¬(x1 = blue ∧ x3 = blue) ¬(x2 = red ∧ x3 = blue) Thus x1 constructs the new nogood {x2 = red, x3 = blue}; in a similar way it canalso construct the nogood {x2 = blue, x3 = red}. x1 then sends both nogoods toits neighbors x2 and x3 . Using its domain, an existing nogood and one of these newnogoods, x2 can reason: x2 = red ∨ x2 = blue ¬(x2 = red ∧ x3 = blue) Multiagent Systems, draft of August 27, 2007
  26. 26. 8 1 Distributed Problem Solving ¬(x2 = blue ∧ x3 = blue) ¬(x3 = blue) Using the other new nogood from x1 , x2 can also construct the nogood {x3 = red}. These two singleton nogoods are communicated to x3 , and allow it to generate the empty nogood. This proves that the problem does not have a solution. This example, while demonstrating the greater power of the hyper-resolution-based algorithm relative to the filtering algorithm, also exposes its weakness; the number of nogoods generated grows to be unmanageably large. (Indeed, we only described the minimal number of nogoods needed to derive the empty nogood; many others would be created as all the agents processed each others’ messages in parallel. Can you find an example?) Thus, the situation in which we find ourselves is that we have one algo- rithm that is too weak, and another that is impractical. The problem lies in the least- commitment nature of these algorithms; they are restricted to removing only provably impossible value combinations. The alternative to such ‘safe’ procedures is to explore a subset of the space, making tentative value selections for variables, and backtracking when necessary. This is the topic of the next section. However, the algorithms covered in this section are not irrelevant; the filtering algorithm is an effective preprocessing step, and the algorithm we will discuss next is based on the hyper-resolution-based algorithm. 1.1.2 Trial-and-backtrack algorithms A straightforward centralized trial-and-error solution to a CSP is first to order the vari- ables (for example, alphabetically). Then, given the ordering x1 , x2 , . . . , xn invoke the procedure ChooseValue(x1 , {}). The procedure ChooseValue is defined recur- sively as follows, where {v1 , v2 , . . . , vi−1 } is the set of values assigned to variables x1 , . . . , xi−1 . procedure ChooseValue(xi , {v1 , v2 , . . . , vi−1 }) vi ← value from the domain of xi that is consistent with {v1 , v2 , vi−1 } if no such value exists then backtrack1 else if i = n then stop else ChooseValue(xi+1 , {v1 , v2 , . . . , vi }) choronological This exhaustive search of the space of assignments has the advantage of complete- backtracking ness. But it is only “distributable” in the uninteresting sense that the different agents execute sequentially, mimicking the execution of a centralized algorithm. The question 1. There are various ways to implement the backtracking in this procedure. The most straightforward way is to undo the choice made thus far in reverse chronological order, a procedure known as chronological backtracking. It is well known that more sophisticated backtracking procedures can be more efficient, but that does not concern us here. c Shoham and Leyton-Brown, 2007
  27. 27. 1.1 Distributed constraint satisfaction 9is whether there exists an algorithm that allows the agents to execute in parallel andasynchronously, and still guarantee soundness and completeness. Consider the following naive procedure, executed by all agents in parallel and asyn-chronously: select a value from your domain repeat if your current value is consistent with the current values of your neighbors, or if none of the values in your domain are consistent with them then do nothing else select one a value in your domain that is consistent with those of your neighbors and notify your neighbors of your new value until there is no change in your value Clearly when the algorithm terminates, either the current values constitute a solution,or no solution exists. The problem is of course that this procedure may never terminate.First, this procedure has no way of proving that no solution exists: it provides no meansfor reducing the size of an agent’s domain. Second, even if there is a solution, we maykeep selecting wrong values from domains without ever reaching it. (For example,consider example (d) from Figure 1.4: if every agent cycles sequentially between red,green and blue, the algorithm will never terminate.) This problem is less severe thanthe first, however, since it can be largely overcome through randomization. Overall, the problem with this algorithm is essentially that, since the agents areexecuting asynchronously and with partial knowledge of the state of other agents,agents make choices based on stale information; what one agent may consider a con-sistent choice may not actually be consistent given that other agents have changed theirchoices. This suggests that good algorithms are likely to be somewhat more involved.Indeed it is the case that distributed backtracking algorithms do tend to be relativelycomplex. Here is an example that is still fairly simple, and which combines elements of boththe standard sequential algorithm and naive asynchronous procedure above. From thesequential algorithm we borrow the idea to order the agents sequentially (for example,again alphabetically by name; more on that later). As in the naive algorithm, we willhave agents execute in parallel and asynchronously. However, both the choice of valuesand the communication will be guided by the ordering on the agents. Each agent willat all times maintain a local view. This local view consists of this agent’s view of thechoice of variable values by the other agents. This view will be based on messagesreceived from other agents (and in general will be out of date, as discussed above). The messages among agents are as follows:• When an agent selects a new value, it communicates the value to all its neighbors who are lower in the ordering; they incorporate it into their local views.• When an agent discovers that none of the values in his domain are consistent with his local view he generates a new nogood using the hyper-resolution rule, and com- Multiagent Systems, draft of August 27, 2007
  28. 28. 10 1 Distributed Problem Solving municates this nogood to the lowest ranked among the neighbors occurring in the nogood. Because of its reliance on building up a set of nogoods, we can see that this algorithm resembles a greedy version of the hyper-resolution algorithm. In the latter, all possible nogoods are generated by any given node, and communicated to all neighbors, even though the vast majority of those are not useful. Here, agents make tentative choices of a value or their variables, only generate nogoods that incorporate values already generated by the agents above them in the order, and only communicate each new nogood to one agent. Before we give the exact algorithm, here is an example of its operation. Consider again the instance (c) of the CSP in Figure 1.4, and assume the agents are ordered alphabetically, x1 , x2 , x3 . They initially select values at random; suppose they all select blue. x1 notifies x2 and x3 of its choice, and x2 notifies x3 . x2 ’s local view is thus {x1 = blue}, and x3 ’s local view is {x1 = blue, x2 = blue}. x2 and x3 must check for consistency of their local views with their own values. x2 detects the conflict, changes its own value to red, and notifies x3 . In the meantime x3 also checks for consistency, and similarly changes its value to red; it, however, notifies no one. Then x3 receives second message arrives from x2 , and updates its local view to {x1 = blue, x2 = red}. At this point it cannot find a value from its domain consistent with its local view, and, using hyper resolution, generates the nogood {x1 = blue, x2 = red}. It communicates this nogood to x2 , the lowest ranked agent participating in the nogood. x2 now cannot find a value consistent with its local view, generates the nogood {x1 = blue}, and communicates it to x1 . x1 detects the inconsistency with its current value, changes its value to red, and communicates the new value to x2 and x3 . The process now continues as before; x2 changes its value back to blue, x3 finds no consistent value and generates the nogood {x1 = red, x2 = blue}, and then x2 generates the nogood {x1 = red}. At this point x1 has the nogood {x1 = blue} as well as the nogood {x1 = red}, and using hyper-resolution generates the nogood {}, and the algorithm terminates having determined that the problem has no solution. The precise algorithm performed by agent xi is as follows. when received (new val, (xj , dj )) do add (xj , dj ) to local view check local view when received (nogood, nogood) do record nogood as new constraint forall (xk , dk ) ∈ nogood, if xk is not a neighbor of xi do add xk to list of neighbors add (xk , dk ) to local view request xk to add xi as a neighbor check local view Note that the algorithm has one more wrinkle that was not mentioned thus far, having to do with adding new links between nodes. Consider for example a slightly modified example, shown in Figure 1.5. c Shoham and Leyton-Brown, 2007
  29. 29. 1.2 Distributed dynamic programming for path planning 11 procedure check local view when local view and current value are not consistent do if no value in Di is consistent with local view then resolve a new nogood using hyper-resolution rule send the nogood to the lowest priority process in the nogood when an empty nogood is found do broadcast to other processes that there is no solution terminate this algorithm else select d ∈ Di where local view and d are consistent current value ← d send (new val, (xi , d)) to neighbors As in the previous example, here too x3 generates the nogood {x1 = blue, x2 = red}, and notifies x2 . x2 is not able to regain consistency itself by changing its own value. However, x1 is not a neighbor of x2 , and so x2 doesn’t have the value x1 = blue in its local view, and is not able to send the nogood {x1 = blue} to x1 . So x2 sends a request to x1 to add x2 to its list of neighbors, and to send x2 its current value. From there onwards the algorithm proceeds as before. 1.2 Distributed dynamic programming for path planning Like graph coloring, path planning constitutes another common abstract problem solv- ing framework. A path-planning problem consists of a weighted directed graph with a set of n nodes N , directed links L, a weight function w : L → R+ , and two nodes s, t ∈ N . The goal is to find a directed path from s to t of minimal total weight. More generally, we consider a set of goal nodes T ⊂ N , and are interested in the shortest path from s to any of the goal nodes t ∈ T . This abstract framework applies in many domains. Certainly it applies when there is some concrete network at hand (for example, a transportation or telecommunication network). But it also applies in more roundabout ways. For example, in a planning problem the nodes can be states of the world, the arcs actions available to the agent, and the weights the cost (or, alternatively, time) of each action.1.2.1 Asynchronous dynamic programming Path planning is a well-studied problem in computer science and operations research. We will be interested in distributed solutions, in which each node performs a local computation, with access only to the state of its neighbors. Underlying our solutions will be the principle of optimality: if node x lies on a shortest path from s to t, then the principle of portion of the path from s to x (or, respectively, from x to t) must also be the shortest optimality paths between s and x (resp., x and t). This allows an incremental divide-and-conquer procedure, also known as dynamic programming. dynamic programming Multiagent Systems, draft of August 27, 2007
  30. 30. 12 1 Distributed Problem Solving X1 X2 {1, 2} {2} d = =   dd    (new val,(X1 , 1)) d d    (new val,(X2 , 2)) dd ‚ X    © 3 local view {1, 2} {(X1 , 1), (X2 , 2)} (a) add neighbor request X1 E X2 {1, 2} new link {2} d = =   local view d    d    {(X1 , 1)} d    X3 (nogood,{(X1 , 1), (X2 , 2)}) {1, 2} (b) (nogood,{(X1 , 1)}) X1 E X2 {1, 2} {2} d = =   d   d   d   X3 {1, 2} (c) Figure 1.5 Asynchronous backtracking with dynamic link addition c Shoham and Leyton-Brown, 2007
  31. 31. 1.2 Distributed dynamic programming for path planning 13 Let us represent the shortest distance from any node i to the goal t as h∗ (i). Thus the shortest distance from i to t via a node j neighboring i is given by f ∗ (i, j) = w(i, j) + h∗ (j), and h∗ (i) = minj f ∗ (i, j). Based on these facts, the A SYNCH DP asynchronous algorithm has each node repeatedly perform the following procedure. In this procedure, dynamic given in Figure 1.8, each node i maintains a variable h(i), which is an estimate of h∗ (i). programming procedure A SYNCH DP (node i) if i is a goal node then set h(i) to 0 else initialize h(i) arbitrarily (for example, to ∞ or 0) repeat forall neighbors j do f (j) ← w(i, j) + h(j) h(i) ← minj f (j) Figure 1.6 The asynchronous dynamic programming algorithm. Figure 1.7 shows this algorithm in action. The h values are initialized to ∞, and incrementally decrease to their correct values. The figure shows three iterations; note that after the first iteration, not all finite h values are correct; in particular, the value 3 in node d still overestimates the true distance, which is corrected in the next iteration. One can prove that the A SYNCH DP procedure is guaranteed to converge to the true values, that is, h will converge to h∗ . Specifically, convergence will require one step for each node in the shortest path, meaning that in the worst case convergence will require n iterations. However, for realistic problems this is of little comfort. Not only can convergence be slow, but this procedure assumes a process (or agent) for each node. In typical search spaces one cannot effectively enumerate all nodes, let alone allocate them each a process (for example, chess has approximately 10120 board positions, while there are fewer than 1081 atoms in the universe and there have only been 1026 nanoseconds since the Big Bang). So to be practical we turn to heuristic versions of the procedure, which require a smaller number of agents. Let us start by considering the opposite extreme in which we have only one agent.1.2.2 Learning real-time A∗ In the learning real-time A∗ , or LRTA∗ algorithm, the agent starts at a given node, learning performs an operation similar to that of the asynchronous dynamic programming, and real-time A∗ then moves to the neighboring node with the shortest estimated distance to the goal, (LRTA∗ ) and repeats. The procedure is as follows: As above, we assume that the set of nodes is finite, and that all weights w(i, j) are positive and finite. Note that this procedure uses a given heuristic function h(·) that serves as the initial value for each newly encountered node. For our purposes it is not important what the precise function is. However, to guarantee certain properties of LRTA∗ , we must assume that h is admissible. This means that h never overestimates admissible the distance to the goal, that is, h(i) ≤ h∗ (i). Because weights are non-negative we can Multiagent Systems, draft of August 27, 2007
  32. 32. 14 1 Distributed Problem Solving i E ci ∞ 2 ∞ a 1    d   T 1 i ‚ i ∞    d 0 2  d s 1 1 t d         ‚ i i 3d c 3 d   E d   b ∞ 2 ∞ (i) i E ci ∞ 2 1 a 1    d   T 1 si ‚ i ∞    d 0 2  d 1 1 t d         d i i 3d c 3 ‚   E d   b 2 ∞ 3 (ii) i E ci 3 2 1 a 1    d   T 1 si ‚ i ∞    d 0 2  d 1 1 t d         d i i 3d c 3 ‚   E d  b 2 3 2 (iii) Figure 1.7 Asynchronous dynamic programming in action procedure LRTA∗ i ← s // the start node while i is not a goal node do foreach neighbor j do f (j) ← w(i, j) + h(j) i′ ← arg minj f (j)// breaking ties at random h(i) ← max(h(i), f (i′ )) i ← i′ Figure 1.8 The learning real-time A∗ algorithm. c Shoham and Leyton-Brown, 2007
  33. 33. 1.3 Negotiation, auctions and optimization 15 ensure admissibility by setting h(i) = 0 for all i, although less conservative admissible heuristic functions (built using knowledge of the problem domain) can speed up the convergence to the optimal solution. Finally, we must assume that there exists some path from every node in the graph to a goal node. With these assumptions, LRTA∗ has the following properties: • the h-values never decrease, and remain admissible. • LRTA∗ terminates; the complete execution from the start node to termination at the goal node is called a trial. • If LRTA∗ is repeated while maintaining the h-values from one trial to the next, it eventually discovers the shortest path from the start to a goal node. • If LRTA∗ find the same path on two sequential trials, the shortest path has been found. (However, this path may also be found in one or more previous trials before it is found twice in a row. Do you see why?) Figure 1.9 shows four trials of LRTA∗ . (Do you see why admissibility of the heuristic is necessary?) LRTA∗ is a centralized procedure. However, we note that rather than have a single agent execute this procedure, one can have multiple agents execute it. The properties of the algorithm (call it LRTA∗ (n), with n agents) are not altered, but the convergence to the shortest path can be sped up dramatically. First, if the agents each break ties differently, some will reach the goal much faster than others. Furthermore, if they all have access to a shared h-value table, the learning of one agent can teach the others. Specifically, after every round and for every i, h(i) = maxj hj (i), where hj (i) is agent j’s updated value for h(i). Figure 1.10 shows an execution of LRTA∗ (2), that is, LRTA∗ with two agents, starting from the same initial state as in Figure 1.9. (The hollow arrows show paths traversed by a single agent, while the dark arrows show paths traversed by both agents.) 1.3 Negotiation, auctions and optimization1.3.1 Introduction: from contract nets to auction-like optimization In this section we consider distributed problem solving that has a certain economic flavor. In this introductory subsection we will informally give the general philosophy and background; in the next two sections we will be more precise. Contract nets were one of the earliest proposals for such an economic approach. contract nets Contract nets are not a specific algorithm, but a framework, a protocol for implementing specific algorithms. In a contract net the global problem is broken down into subtasks, and those are distributed among a set of agents. Each agent has different capabilities; for each agent i there is a function ci such that for any set of tasks T , ci (T ) is the cost for agent i to achieve all the tasks in T . Each agent starts out with some initial set of tasks, but in general this assignment is not optimal, in the sense that the sum of all agents’ costs is not minimal. The agents then enter into a negotiation process which improves Multiagent Systems, draft of August 27, 2007
  34. 34. 16 1 Distributed Problem Solving i E ci 0 3 0 a 2    d   T 1 si d i 0    d 0 2  ‚ 2 3 t d         d i i 2d c 5 ‚   E d  b 3 0 0 initial state i E ci i E ci 2 3 1 4 3 1 a a 2          d     T 1 2        d   T 1     d   d si d i si 2   2    d 0 d‚ 4   2    d i d 0 d‚ 2   3 t 2 3 t       d     d   2d c         d i i d i i 5 2d c 5 ‚     E d   ‚   E d   b b 3 3 2 0 2 0 first trial second trial i E ci i E ci 4 3 1 4 3 1 a a 2    dd   T 1 2      d   d   T 1 d   d si d i si 4  2    d 0 d‚ 5  2    dd i d 0 ‚ 2 3 t 2   3 t d   d     d   d     2d c     2d c     d i d d   i d i d   d   i 5 5 ‚ E d   ‚ E d   b b 3 3 3 4 3 4 third trial forth trial Figure 1.9 Four trials of LRTA∗ on the assignment, and hopefully culminates in an optimal assignment, that is, one with anytime minimal cost. Furthermore, the process can have a so-called anytime property; even if property it is interrupted prior to achieving optimality, it can achieve significant improvements over the initial allocation. The negotiation consists of agents repeatedly contracting out assignments among themselves, each contract involving the exchange of tasks as well as money. The ques- tion is how the bidding process takes place, and what contracts hold based on this bidding. The general contract net protocol is open on these issues. One particular approach has each agent bid for each set of tasks the agent’s marginal cost for the task, that is, the agent’s additional cost for adding that task to its current set. The tasks are allocated to the highest bidders, and the process repeats. It can be shown that there always exist a sequence of contracts that result in the optimal allocation. If c Shoham and Leyton-Brown, 2007
  35. 35. 1.3 Negotiation, auctions and optimization 17 i E ci i E ci 2 3 1 4 3 1agenta a agenta a 2         d     T 1 2       d   T 1   d d si d i si2    2    d 0 d d‚ 4    2    d dd i d 0 ‚ 2   3 t 2 3 t d     d   d     d   2d c   d   d     ‚ i i agentb ‚ i i d   d   5 2d c d d   5agentb b E d  b E d  3 3 2 0 3 4 first trial second trial i E ci 4 3 1 a 2      d     T 1   dsi5  2    dd i d 0 ‚ 2   3 t d     d     2d c   d   d i d   d   i 5 ‚ E d   b 3 3 4 third trial Figure 1.10 Three trials of LRTA∗ (2) one is restricted to basic contract types in which one agent contracts a single task to another agent, and receives from him some money in return, then in general achieving optimality requires in general that agents enter into “money-losing” contracts in the process. However, there exist more complex contracts—which involve contracting for a bundle of tasks (“cluster contracts”), or a swap of tasks among two agents (“swap cluster contracts contracts”), or simultaneous transfers among many agents (“multiagent contracts”)— swap contracts whose combination allows for a sequence of contracts that are not money losing and which culminate in the optimal solution. multiagent At this point several questions may naturally occur to the reader: contracts • We start with some global problem to be solved, but then speak about minimizing the total cost to the agents. What is the connection between the two? • When exactly do agents make offers, and what is the precise method by which the contracts are decided on? • Since we are in a cooperative setting, why does it matter whether agents “lose money” or not on a given contract? We will provide an answer to the first question in the next section. We will see that, in in certain settings (specifically, those of linear programming and integer programming), finding an optimal solution is closely related to the individual utilities of the agents. Regarding the second question, indeed one can provide several instantiation of even the specific, marginal-cost version of the contract net protocol. In the next two sec- Multiagent Systems, draft of August 27, 2007