CSCE 475/896

Topic Summary Assignment 5:

Distributed Rational Decision Making

Questions and Answers

October 18, 2003

Important Note: Important questions are denoted with a ‘8’ symbol.

Important Note: Most students, in their response to the stupid question, neglected to observe this. First, most students realized that the setup provided opportunities for participants to cheat—putting in less than required at the parking meters so that the group will help pay for one’s selfish scheme. But, if every participant cheats, the whole group will suffer. So, what is the correct strategy? What would you do? To benefit from the group, would you want to cheat? If not, what makes you not want to cheat? Think about this. And now, that means you are rationalizing locally to benefit from the system. If everybody does the correct thing, what do we get? We get a system with coherence. I hope you see the beauty in this stupid question. We set up a policy and let the participants (agents) make their own decisions. To benefit from the policy, the agents have to act rationally. If they do, then the system is a multiagent system with coherent behaviors.

Important Note: Most students ask about when one protocol is better than the other. Actually, the more correct question should be when one protocol is more appropriate than the other. So, here we will take a look at them. We covered six protocols: (a) voting, (b) auctions, (c) bargaining, (d) market equilibrium, (e) contract net, and (f) coalition formation. First, let us look at some distinguishing characteristics in Table 1.

Protocols	Unique Characteristics
Voting	Every agent votes on some outcome. The majority wins. The outcome binds every agent, regardless of how they voted.
Auctions	An auctioneer hosts an auction. Other agents auction. The agent with the winning bid settles the outcome with the auctioneer.
Bargaining	Two agents negotiate with each other to reach a deal.
Market Equilibrium	Many agents, acting as consumers and producers, buy and sell goods at prices they are comfortable with.
Contract Net	A contractor needs to get something done and announces a call for contracts. Other agents make offers. The contractor allocates contracts accordingly.
Coalition Formation	Each agent forms its own coalition or team to solve tasks.

Table 1 Protocols and unique characteristics.

Now, let us look at where these protocols could be more appropriate than the other in Table 2.

	Voting	Auctions	Bargaining	Market Equilibrium	Contract Net	Coalition Formation
Large # agents	Yes	Maybe		Yes
Small # agents		Yes	Yes		Yes	Yes
Result Sharing	Yes
Resource Sharing			Yes	Yes		Yes
Solution Sharing	Yes
Information Exchange			Yes		Yes	Yes
Single Event	Yes
Multiple Concurrent Events		Maybe	Maybe	Yes	Maybe	Yes
Task Allocation					Yes	Maybe
Social Simulation				Yes
Economic Simulation				Yes
Heterogeneous Agents			Yes		Yes	Yes
Homogeneous Agents	Yes	Yes	Maybe	Yes
Etc.

Table 2 Scenarios and appropriate protocols.

The above table is not strictly correct, of course. Given a situation, think about what the agents are required to do. Are the agents required to decide on the best solution and share the solution among themselves? If yes, voting is appropriate. And so on.

Q1: In the task allocation negotiation, a contractor is willing to allocate the tasks from its current task set to the contractee if it has to pay the contractee less than it saves by not handling the tasks itself. What will happen if the “cheapest” contractee happens to be the incompetent one (e.g., based on the contractor’s history)? Will the contractor still be willing to allocate the task to it? Will the contractor trade off cost for quality?

A1: Yes, now, we are in the realm of multiagent learning. We will talk about learning in multiagent systems later in Chapter 6. The idea here is that an agent learns—it can rationalize about which contractee is the “cheapest”, but it can also rationalize about which contractee is the most “reliable”. How does it know the reliability of another agent? The agent may learn this from its past interactions with that particular agent. And with this, the contractor can adjust its valuation of its contractees.

Q2: Though I understand Nash equilibrium, I do not understand why it is too weak to make sure that no subgroups of agents deviate in a coordinated manner. Furthermore, I don’t understand how Strong Nash Equilibrium can guarantee stability. Actually, from my understanding of Nash Equilibrium it seems impossible to use this to try to predict coordinated deviation.

A2: First, what is a Nash equilibrium? It is when an agent cannot deviate from its strategy (in order to gain profit) without hurting another agent. But this does not prevent forming private groups. For example, suppose there are N agents in the system. There are two particular agents, A and B. A realizes that it can obtain a higher profit (from $10 to $100) if it chooses strategy S1. But by choosing strategy S1, agent B has to suffer (from $10 to $5). So, in a way, there is a Nash equilibrium: A cannot choose another better strategy without hurting B. However, what if A tells B: “Hey, let’s form a subgroup. I will choose strategy S1 and you will suffer. But I will give you the original $15 if you agree to suffer.” A gains as a result. B gains as a result. So, the agents deviate from the equilibrium!

Now, in Strong Nash equilibrium, it says a subgroup cannot deviate from its current strategy where every member of the subgroup will receive increased payoffs. This is stronger. It says that the team itself may gain, but not all members will benefit from the deviation. As a result, those members will not want to deviate. And thus, that prevents the subgroup from deviating. This does not guarantee stability. But it does guarantee more stability.

8Q3: Why should we worry about the auctioneer being dishonest when we are dealing with agents? Can’t we just program them to always tell the truth when auctioning? … Why not just program agents to always say their truthful preferences?

A3: If we program the agents to be truth-telling, then we reduce the autonomy of these agents, and we defeat the purpose of distributed rational decision making. The key in building the best, most elegant multiagent systems is to let the agents make their own rational decisions such that the overall system behavior is coherent. Remember, sometimes we do not have control over the agents being designed and built if there are different designers and programmers. But, if we have a set of policies that every agent follows, then we may be able to guarantee some behavior.

Now, why should we worry about the auctioneer being dishonest? Suppose that there is a multiagent system with N agent. Each agent has some items to sell. Each agent has the capability to be an auctioneer. In a system like this, we can prevent the auctioneers from lying by allowing the other agents the capabilities to find out about the actual winning bids and prices. If found, the cheating auctioneer will be penalized. So, in that case, we are not forbidding an auctioneer from cheating. Why? Because we assume that each auctioneer is rational and if it cheats, it must be for a good reason. Maybe the particular auctioneer is facing bankruptcy and needs some extra money to survive. We let the auctioneer itself decide. If we program this into the auctioneer to prevent them from being dishonest, then we will take away this decision making alternative, this autonomy. What if the environment is so dynamic and unpredictable that the designer cannot come up with a correct overall strategy that he or she can directly program into the agents? In that case, we certainly cannot hard-code the agents to take away their decision making capabilities. We want them to have those capabilities and let them decide.

Remember back on the first day of the class what I said about CS, AI, and MAS? CS is about building objects to do things for us. AI is about building objects to think for us. MAS and agent technology are about building objects that perceive, think, and do things for us. We want to give agents their autonomy because the environment calls for it. If that is the case, it is often the case that we cannot simply hard-code into the agents to force them to do things or to prevent them from doing things. If it was possible, then that means it would likely too that we did not need the agents in the first place.