1. New Results on Computing in Games Tuomas Sandholm Carnegie Mellon University Computer Science Department Joint work with Vincent Conitzer

2. Interplay of computing & incentives Computational complexity of –Executing a mechanism (rules of the game) Determining the winners in –Voting [Bartholdi, Tovey, Trick 89] –Combinatorial auctions [Sandholm AIJ-02, …] –Executing a strategy How should computationally bounded agents play strategically? –Limits on memory [Rubinstein, Papadimitriou, Kalai, Gilboa, …] –Costly or limited computing [Sandholm ICMAS-96, IJEC-00; Larson&Sandholm AIJ-01, AAMAS-02, TARK-01, AGENTS-01 workshop, …] –Manipulating a mechanism (by determining a beneficial insincere revelation) –Determining which agents’ preferences should be elicited –Determining how to play (finding the game’s equilibrium) –Finding a payoff division (e.g., according to the core) –Designing a mechanism {

3. Complexity of Manipulating Elections with Few Candidates [Conitzer & S., National Conference on Artificial Intelligence (AAAI), 2002]

4. Voting Agents may have conflicting preferences In aggregate, must choose one from a set of candidates –Deciding on a president/leader/coordinator/representative –Joint plans –Allocations of tasks/resources –… Voting is most general preference aggregation method –Applicable to any preference aggregation setting –No side payments Voting can be done without side payments Side payments are not always technically possible or politically viable Side payments from a finite set -> could be incorporated into candidates

5. Manipulation in voting A voter is said to manipulate when it does not rank the candidates truthfully Example (in plurality voting) –Voter A prefers Nader to Gore to Bush –But Nader is extremely unlikely to win –So, voter A votes for Gore Why is manipulation bad? –Voting protocol is designed to maximize social welfare => Manipulation will cause a suboptimal outcome to be chosen –If protocol relies on manipulation to choose right outcome, there exists another nonmanipulable protocol that chooses same outcome (Revelation Principle)

6. Common voting protocols Plurality (candidate with most votes wins) Single Transferable Vote (STV) –Each round, candidate with fewest votes drops out –When your candidate drops out, your vote transfers to your next most preferred (remaining) candidate –Now A can safely vote for Nader, then let the vote transfer to Gore –Supporting a candidate may hurt that candidate! Supporting a weaker opponent instead can cause a tougher opponent to be eliminated Borda –Every voter ranks all candidates –0 points for the bottom candidate, 1 for the second-to-last, … Copeland –Every voter ranks all candidates –From this, pairwise elections between candidates are simulated –Candidate with most pairwise victories wins Maximin –Candidate with best score in its worst pairwise election wins Approval –Every voter either approves or disapproves each candidate –Candidate with most approvals wins

7. Manipulation of voting protocols Seminal impossibility result [Gibbard-Satterthwaite]: all nondictatorial voting protocols with >2 candidates are manipulable Software agents may manipulate more than humans in practice –Humans might not consider the option of manipulation –Many humans insufficiently understand (the manipulability of) protocols –Manipulation algorithms may be too tedious to run by hand –For software agents, voting algorithms must be coded explicitly Rational strategic algorithms are preferred The voting algorithm needs to be coded only once Software agents are good at running algorithms Idea: Use computational complexity as the barrier to manipulation

8. Prior research Individually manipulating Second-order Copeland is NP-complete [Bartholdi, Tovey, Trick 1989] –Somewhat contrived result relying on tie-breaking Individually manipulating STV is NP-complete [Bartholdi, Orlin 1991] Those results rely on the number of candidates (m) being unbounded We designed a recursive algorithm for individually manipulating STV with O(m^1.62) calls (and usually much fewer) –Not too complex for realistic numbers of candidates

9. Manipulation complexity with few candidates Ideally, would like complexity results for constant number of candidates But then manipulator can simply evaluate each possible vote –assuming the others’ votes are known Even for coalitions, only polynomially many effectively different votes However, if we place weights on votes, complexity may return… Unweighted voters Weighted voters Individual manipulation Coalitional manipulation Can be hard easy Constant #candidates Unbounded #candidates Can be hard Can be hard Can be hard Potentially hard Unweighted voters Weighted voters

10. Why study weighted coalitional manipulation? In large elections, usually impossible to manipulate individually Many real world elections have weights –E.g. electoral college –Weights more likely with heterogeneous software agents Weighted coalitional manipulation is more realistic than assuming unbounded #candidates We also derive other individual/unweighted results from results in this setting

11. Constructive manipulation A coalition wants a certain candidate p to win Thrm.NP-complete for Borda, STV, Copeland, Maximin –For 3, 3, 4, 4 candidates respectively Proof sketch for Borda: –p is trailing the two other candidates, who are tied –Naturally, colluders give p their first vote –But must carefully divide their second votes across other candidates –This is basically doing PARTITION

12. Destructive manipulation A coalition wants a certain candidate h to not win Thrm. Easy for Borda, Copeland, Maximin, even with unbounded numbers of candidates –The algorithm relies on these methods being score-based and monotonic (more support always helps) Thrm. NP-complete for STV (even with 4 candidates) –Proof reduces constructive STV to destructive STV Sometimes, to get a candidate to not win, the coalition needs to get a specific other candidate to the final round

13. Randomization can be used to make manipulation hard Consider the Cup protocol: –Candidates play an elimination tournament based on pairwise elections Given the schedule (leaf labels), any type of manipulation is easy even with unbounded #candidates –For each node in tree, can build the set of candidates that would reach this node for some vote by the coalition (from bottom up) Manipulating a subtree only requires commitment on the order of candidates in that subtree Idea: randomize (uniformly) over schedules after votes received Theorem. Manipulating Randomized Cup is NP-complete –Proof is complex & uses 7 candidates a b b c b d c

14. Uncertainty about others’ votes Even individual weighted manipulation can be hard So far we assumed that manipulator(s) know the others’ votes –Unrealistic -> drop this assumption Theorem. Whenever constructive coalitional manipulation is hard under certainty, individual manipulation is hard under uncertainty –Holds even when manipulator’s vote is worthless i.e. we just wish to evaluate an election –Even with very limited kinds of uncertainty Independence All votes either completely known or not at all –Proof sketch. When manipulator’s vote is worthless, it is difficult to figure out if a certain candidate has a chance of winning, because this requires a constructive vote by the unknown voters

15. Uncertainty about others’ votes Even individual unweighted manipulation can be hard Let’s drop the assumption of independence between voters –Usually votes are highly correlated –Identical software agents will vote identically Theorem. Whenever evaluating an election is hard with independent weighted voters, it is hard with correlated unweighted voters –Even with very limited kinds of correlation Perfect correlation or independence –Proof sketch. Just replace a vote of weight k by k unweighted, perfectly correlated voters So, –because evaluation with independent weighted voters is hard for Borda, Copeland, Maximin and STV, –evaluation is hard for those protocols even for (correlated) unweighted voters

16. What do our results suggest? All of the protocols we discussed are computationally more manipulation-proof than Plurality Among these, STV seems inherently least manipulable Randomizing the protocol can make manipulation hard Manipulation is computationally difficult because usually there is uncertainty about others’ votes

17. Critique NP-hardness is a worst-case measure –It may not prevent all (or even most) instances from being manipulable Future research –Average-case complexity –Cryptographic manipulation-proofness

18. Vote Elicitation: Complexity and Strategy-Proofness [Conitzer & S., National Conference on Artificial Intelligence (AAAI), 2002]

19. Vote elicitation Eliciting votes selectively can allow election to be terminated early –But the outcome of the election should be unchanged Why minimize preference revelation? –Costly for agents to compute their preferences –Communicating preferences causes overhead Traveling to the voting booth Network traffic –Less revelation is desirable due to privacy reasons

20. Vote elicitation … In deciding which votes to elicit, the most effective elicitation schemes make use of –Suspicions about how the agents will vote Can come from –Votes in previous elections –Understanding the relationship between candidates & voters In a 2-candidate election, if the elicitor knows beforehand who will vote for the winner, it can simply elicit enough of these –Elicitation results so far

21. Impediments to effective elicitation Computational complexity issues –How hard to know if elicitation can be terminated? –How hard to decide which votes to elicit? Strategic issues –Does elicitation introduce (additional) opportunities for manipulating the election?

22. Hardness of terminating elicitation How hard is it to know if we are done? Theorem. For the STV protocol, it is NP-complete! –NP-complete even if only one voter remains to be elicited –When voters are weighted, NP-complete even with only 4 candidates –Proof idea. Reductions are from problems on manipulating elections Intuition: we can terminate if and only if the remaining candidates cannot “conspire” to make the leader lose Theorem. In all score-based, monotone protocols, terminating elicitation is easy (even with weighted voters) –A protocol is monotone if more support never hurts a candidate –Plurality, Borda, Copeland, Maximin, Approval satisfy these conditions –Proof sketch. For each nonleading candidate, check if it would win if all remaining voters supported it most, and the leader least

23. Hardness of deciding whom to elicit Theorem. PSPACE-hard (for Approval) –Proof. Long reduction from STOCHASTIC-SAT Theorem. NP-complete even with perfect suspicions about how voters will vote –Holds for all of the protocols except Plurality For Plurality, elicit voters voting for the winner first Then, going through the remaining candidates in a round-robin manner, elicit a vote for that candidate (if possible) –Proofs. Reductions from EXACT-COVER-BY-3-SETS If each losing candidate needs exactly one more “bad” vote to be eliminated, and each vote is “bad” for exactly 3 candidates, we should try to “cover” the candidates exactly with these 3-sets Or, a vote may be “good” for 3 losing candidates, and it may be necessary to avoid eliciting more than one more “good” vote per losing candidate to terminate quickly

24. Hardness of deciding whom to elicit: Varying weights & elicitation costs Voters may be weighted Also, cost of eliciting a voter may vary across voters Theorem. With both of these, effective elicitation is NP-complete for all protocols, even with only 2 candidates –even if voter’s elicitation cost can only be 0 or equal to weight –All voting protocols coincide with 2 candidates Theorem. If only weights or costs vary across voters, deciding whom to elicit is easy –for any constant number of candidates

25. Coarse & fine elicitation Two types of vote elicitation –Coarse elicitation: Whoever is elicited, reveals her complete vote –Fine elicitation: Some voters reveal their votes partially E.g., no need to rank candidate x because it has already lost Coarse elicitation reduces the traveling costs to the voting booth & effort of determining one’s preferences Fine elicitation further reduces effort of determining one’s preferences

26. Strategic issues in coarse elicitation Theorem. Even if the following all hold –Voters are unweighted & elicitation costs are uniform –Truthful voting is a Bayes-Nash equilibrium without elicitation –Our (coarse) elicitation policy is optimized to finish ASAP on average –An agent learns nothing about the other agents votes when elicited, except how many other agents were elicited before it An agent could infer this from the time at which it is elicited then it is possible that with elicitation –Truthful voting is no longer a Bayes-Nash equilibrium –Agents condition how they vote on when they are elicited Theorem. If we can prevent an agent from learning how many other agents have been elicited so far, the set of Bayes-Nash equilibria does not change with elicitation

27. Strategic issues in fine elicitation Theorem. Even if the following all hold –Voters are unweighted & elicitation costs are uniform –Truthful voting is a Bayes-Nash equilibrium without elicitation –Our (fine) elicitation policy is optimized to finish ASAP on average then it is possible that with elicitation –Truthful voting is no longer a Bayes-Nash equilibrium –Agents condition how they vote on the order of queries to them I.e., fine elicitation introduces strategic issues even when nothing is learned about how many agents were elicited before –Voter can condition on the order of queries to it Theorem. If –order of queries to an agent depends only on answers that it gave to previous queries (but not other agents’ answers), and –nothing can be inferred about how many agents were elicited so far then the set of Bayes-Nash equilibria does not change with elicitation

28. Conclusions on vote elicitation Elicitation is an avenue for reducing burden imposed by voting However, optimal elicitation suffers from –Computational complexity issues Hardness of terminating Hardness of deciding whom to elicit –Strategic issues Elicitation may lead to more opportunities for manipulation Future research –Designing elicitation policies that choose right outcome with high probability –Designing new voting protocols that combine Computational ease of elicitation (such as in Plurality) More expressive votes (such as in the other protocols) –Designing elicitation schemes that avoid revealing information that leads to additional manipulation opportunities

29. Complexity Results about Nash Equilibria [Conitzer & S., CMU Computer Science Department technical report, 2002]

30. Complexity of equilibrium concepts from noncooperative game theory Solutions are less useful if they cannot be determined –So, their computational complexity is important Early research studied complexity of board games –E.g. chess, Go –Complexity results here usually depend on structure of game (allowing for concise representation) –Usually zero-sum, alternating move Real-world strategic settings are much richer –Concise representation for all games is impossible –Not necessarily zero-sum/alternating move –Sophisticated agents need to be able to deal with such games…

31. Complexity of Nash equilibria Game theory defines –General representations of games –Solution concepts for these games Most central is Nash equilibrium Any finite game has a mixed-strategy Nash equilibrium [Nash 1950] Complexity of finding a mixed-strategy Nash equilibrium? –Still an open question! –“Together with factoring … the most important concrete open question on the boundary of P today” [Papadimitriou 2001] We solved several related questions…

32. A useful reduction (SAT -> game) Theorem. SAT-solutions correspond to mixed-strategy equilibria of the following game (each agent randomizes uniformly on support) SAT Formula:(x 1 or -x 2 ) and (-x 1 or x 2 ) Solutions: x 1 =true, x 2 =true x 1 =false,x 2 =false Game: x1x1 x2x2 +x 1 -x 1 +x 2 -x 2 (x 1 or -x 2 )(-x 1 or x 2 )default x1x1 -2,-2 0,-2 2,-2 -2,-2 -2,1 x2x2 -2,-2 2,-2 0,-2 -2,-2 -2,1 +x 1 -2,0-2,21,1-2,-21,1 -2,0-2,2-2,1 -x 1 -2,0-2,2-2,-21,1 -2,2-2,0-2,1 +x 2 -2,2-2,01,1 -2,-2-2,2-2,0-2,1 -x 2 -2,2-2,01,1 -2,-21,1-2,0-2,2-2,1 (x 1 or -x 2 ) -2,-2 0,-22,-2 0,-2-2,-2 -2,1 (-x 1 or x 2 ) -2,-2 2,-20,-2 2,-2-2,-2 -2,1 default 1,-2 0,0 Proof sketch: – Playing opposite literals (with any probability) is unstable – If you play literals (with probabilities), you should make sure that for any clause, the probability of the literal being in that clause is high enough, and for any variable, the probability that the literal corresponds to that variable is high enough (otherwise the other player will play this clause/variable and hurt you) – So equilibria where both randomize over literals can only occur when both randomize over same SAT solution – These are the only “good” equilibria

33. Complexity of mixed-strategy Nash equilibria with certain properties This reduction implies that there is an equilibrium where players get expected utility 1 each iff the SAT formula is satisfiable –Any reasonable objective would prefer such equilibria to 0-payoff equilibrium Corollary. Deciding whether a “good” equilibrium exists is NP-hard: –1. equilibrium with high social welfare –2. Pareto-optimal equilibrium –3. equilibrium with high utility for a given player i –4. equilibrium with high minimal utility Also NP-hard (from the same reduction): –5. Does more than one equilibrium exists? –6. Is a given strategy ever played in any equilibrium? –7. Is there an equilibrium where a given strategy is never played? (5) & weaker versions of (4), (6), (7) were known [Gilboa, Zemel GEB-89] All these hold even for symmetric, 2-player games

34. Counting the number of mixed-strategy Nash equilibria Why count equilibria? If we cannot even count the equilibria, there is little hope of getting a good overview of the overall strategic structure of the game Unfortunately, our reduction implies: –Corollary. Counting Nash equilibria is #P-hard! Proof. #SAT is #P-hard, and the number of equilibria is 1 + #SAT –Corollary. Counting connected sets of equilibria is just as hard Proof. In our game, each equilibrium is alone in its connected set –These results hold even for symmetric, 2-player games

35. Complexity of Bayes-Nash equilibria Players have private information about their preferences (types) Finding pure-strategy equilibria –Easy for normal form games (simply check all combinations of strategies) –Now strategy may depend on type -> too many combinations to check Pure strategy equilibria are desirable –Avoids randomization over strategies between which players are indifferent Theorem. Deciding whether a pure-strategy Bayes-Nash equilibrium exists is NP-complete –Proof sketch. (easy to make symmetric) Each of player 1’s strategies, even if played with low probability, makes some of player 2’s strategies unappealing to player 2 With these, player 1 wants to “cover” all of player 2’s strategies that are bad for player 1. But player 1 can only play so many strategies (one for each type) This is SET-COVER

36. Complexity of Nash equilibria in stochastic (Markov) games We now shift attention to games with multiple stages Some NP-hardness results have already been shown here Ours is the first PSPACE-hardness result (to our knowledge) We focus on Markov games –At each stage, the game is in a certain state –State transition probabilities depend on current state & players’ current actions –State affects the payoffs that players receive PSPACE-hardness results from e.g. Go do not carry over –Go has an exponential number of states –For general representation, we need to specify states explicitly

37. Complexity of Nash equilibria in stochastic (Markov) games… Strategy spaces here are rich (agents can condition on past events) –So maybe high-complexity results are not surprising … High-complexity even when players cannot condition on anything! –No feedback from the game: the players are playing “blindly” Theorem. Even under this restriction, deciding whether a pure- strategy Nash equilibrium exists is PSPACE-hard –even if game is 2-player, symmetric, and transition process is deterministic –Proof sketch. Reduction is from PERIODIC-SAT, where an infinitely repeating formula must be satisfied [Orlin, 81] Theorem. NP-hard even if game has a finite number of stages

38. Conclusions on complexity of noncooperative equilibrium concepts Complexity results on game-theoretic concepts are crucial –Analyzing the concepts’ computational feasibility –Coding strategic software agents Many complexity questions in game theory remain open –How hard is it to construct a Nash equilibrium? –What about other concepts from game theory? –Are there representations of strategic situations that make strategic analysis easier? For what restricted classes of games is strategic analysis easier? –What are useful and computable partial characterizations of a game’s strategic structure?

39. Complexity of Determining Nonemptiness of the Core [Conitzer & S., CMU Computer Science Department technical report, 2002]

40. Complexity in cooperative game theory Cooperative game theory studies stable coalition formation Coalitions between agents are useful because –Coalitions can achieve things an individual cannot –Coalitions can be more efficient than individuals However, coalitions must be strategically stable –No subcoalition could do better by breaking off We study the computational complexity of finding stable outcomes –To this end, we define a sensible, concise representation of coalitional situations

41. Characteristic function games Each subset of agents has a set of utility possibility vectors, indicating what they can do as a coalition –A utility possibility vector gives a utility for each agent –If utilities are transferable, the set of possibility vectors is given by the maximum attainable total utility (value) for the coalition Superadditivity means two disjoint coalitions can always do at least as well together as separately –Any concatenation of possibility vectors is a possibility vector –For transferable utility: two coalitions can always get the sum of their values together A possibility vector for the grand coalition is in the core if –No subset of agents has a utility possibility vector that is strictly better for all of them –For transferable utility: no subset has a value strictly greater than the sum of the utilities given to agents in that subset

42. Representation of characteristic function games Generally, the length of the representation is exponential in the number of agents However, usually characteristic games have some special structure allowing for more concise representation –The complexity of finding stable outcomes has already been studied for certain graph games [Faigle et al. 94, Deng and Papadimitriou 94] Our representation captures any superadditive game We only specify utility possibility vectors that cannot be derived from superadditivity –I.e. we specify where there is synergy This is effective for checking if an outcome is in the core –Only need to check for deviation by the (specified) synergistic coalitions

43. Deciding whether the core is nonempty is hard Given our representation, deciding whether the core is nonempty is NP-complete –Both with and without transferable utility Sketch of the reduction (with transferable utility): –Reduction from EXACT-COVER-BY-3-SETS –(Some) agents correspond to the elements of the 3-sets –For each 3-set, there is a coalition of the agents in the 3-set with value 3 –The other agents and coalitions involving them are chosen so that: There is an outcome in the core if and only if the 3-set agents can guarantee themselves utility 1 each But this is possible if and only if there is an exact cover

44. With grand coalition outcomes, the problem is tractable The difficulty in the instance we reduced to was that even collaborative optimization was hard –It was hard just to determine what the grand coalition could do What if we know what the grand coalition can do? –I.e. the collaborative optimization has already been done The problem becomes tractable! –Without transferable utility: just check for every grand coalition possibility vector if any coalition blocks it –With transferable utility: use linear programming to divide the value across the agents in a stable way Thus, in these cases, the only hardness came from the collaborative optimization problem

45. Hybrid games remain hard However, if the game is hybrid, solving the collaborative optimization problem is not enough –A game is hybrid if only some coalitions can transfer utility Consider the case where only the grand coalition can transfer utility –Realistic if the market institution that enforces payments collapses upon deviation by agents In this case, determining nonemptiness of the core is hard even if we are given the value for the grand coalition –Reduction from VERTEX-COVER –Sketch of proof: Any two vertices connected by an edge can deviate to get utility 1 each So, need to give at least one of the vertices on each edge utility 1 Requiring stability elsewhere limits the amount of utility available But this is just VERTEX-COVER!

46. Conclusion Strategically stable coalition formation is a key problem for self-interested agents Determining the existence of stable solutions can be NP- complete –Oftentimes just the collaborative optimization problem by itself is hard –However, for hybrid games, determining whether there is an outcome in the core is hard even after the collaborative optimization phase Future research includes investigating: –Complexity issues for more restricted classes of games –The complexity of other solution concepts –The effect of complexity issues in determining the synergies between agents E.g. when routing problems need to be solved to determine the synergies

47. Complexity of Mechanism Design [Conitzer & S., UAI-02 & new draft]

48. Automated mechanism design Mechanism design = designing rules of game so that a good outcome happens although agents play strategically Idea: Solve mechanism design as an optimization problem automatically –Inputs: outcomes, type space, prior, designer’s objective –Output: optimal mechanism –Creating a mechanism for the specific setting (instance) at hand rather than a class of settings –Advantages: Can circumvent impossibility results Can be used even in settings that do not satisfy the assumptions of canonical mechanisms (e.g. quasilinear utility functions) Can lead to a greater value of the mechanism designer’s objective (or stronger notions of nonmanipulability) than canonical mechanisms Often designer has info about agents - silly to ignore General preferences Quasilinear prefs

49. Mechanism design In multiagent systems, agents may have conflicting preferences over different outcomes that can be chosen Preference aggregation works as follows: –The agents report their preferences (types); –Then, the preference aggregator chooses an outcome on the basis of the reported types. Unfortunately, naïve preference aggregation leads to false revelations (manipulation) –E.g. claiming that an outcome is extremely valuable to you though in reality you only prefer it slightly Mechanism design is the study of selecting outcome functions which aggregate the preferences in a desirable way while avoiding manipulation

50. Why restrict attention to nonmanipulable mechanisms? It is conceivable that there exists a mechanism that –Is manipulable, but –Leads to more desirable outcomes that any nonmanipulable mechanism, even when taking manipulation into account The Revelation Principle states this never happens: equally good nonmanipulable mechanisms can easily be found –Take a manipulable mechanism –From this, construct a new mechanism with an interface layer between the agents and the old mechanism An agents reports its type to the interface layer The interface layer (mis)reports the type strategically to the old mechanism, acting on the agent’s best behalf –Now the mechanism is nonmanipulable but gives the same outcomes

51. Computational mechanism design Mechanism design has traditionally focused on finding general mechanisms that are optimal for a large class of settings –E.g. Vickrey-Groves-Clarke mechanisms are perfect when Utility is transferable between agents (quasilinear preferences) The objective is to maximize social welfare (the sum of the agents’ utilities) Unfortunately, these general mechanisms do not cover many settings –Quasilinear preferences are quite unrealistic –Sometimes we do not wish to maximize social welfare but something else (e.g. auction revenue) This does not preclude us from finding mechanisms for specific settings that are not covered by general mechanisms –Oftentimes, we are given specific information about the possible outcomes, and the agents’ preferences In computational mechanism design, we use this information to generate an optimal mechanism on the fly

52. Advantages of computational mechanism design It can be used in settings where classical mechanisms do not apply It can outperform classical mechanisms on specific instances –Stronger concepts of nonmanipulability –More desirable outcomes It can be used to circumvent impossibility results stating there is no mechanism desirable over all preferences (such as the Gibbard- Satterthwaite theorem)

53. Requirements To do computational mechanism design, we need: –Formal definitions of the associated computational problems –Efficient algorithms for solving these problems Unfortunately, it turns out that for some computational mechanism design problems, efficient algorithms are unlikely to exist –Computational mechanism design can be NP-complete We will show how allowing for randomized mechanisms circumvents this problem

54. Defining the computational problem: Input An instance is given by –Set of possible outcomes –Set of agents For each agent –set of possible types –probability distribution over these types –utility function converting type/outcome pairs to utilities –Objective function Gives a value for each outcome for each combination of agents’ types E.g. social welfare –Restrictions on the mechanism Are side payments allowed? Is randomization over outcomes allowed? What concept of nonmanipulability is used?

55. Defining the computational problem: Output The algorithm should produce –a mechanism A mechanism maps combinations of agents’ revealed types to outcomes –Randomized mechanism maps to probability distributions over outcomes –Also specifies payments by agents (if side payments are allowed) – … which is nonmanipulable (according to the given concept) –By revelation principle, we can focus on truth-revealing direct-revelation mechanisms w.l.o.g. maximizes the expectation of the objective function

56. Single agent mechanism design Only one (type-reporting) agent All concepts of nonmanipulability coincide here –Difference in concepts of nonmanipulability comes from what agents are assumed to know about others’ types –Here there are no other agents! The (standard) social welfare function as an objective is easy here (no conflict) (Generalized) social welfare is still nontrivial –There is also an outside societal interest in the outcome –Outside society’s “type” (preferences over the outcome) is already known –We seek to maximize agent’s utility + outside societal utility This setting already highlights many computational issues

57. Summary: results on single-agent mechanism design No payments, no randomization: –NP-complete even with (generalized) social welfare (reduction from MINSAT) Payments, no randomization: –Easy with (generalized) social welfare – use VCG mechanism –NP-complete for general objective functions (reduction from INDEPENDENT-SET) No payments, randomization: –Easy trough linear programming (probabilities are variables) Payments, randomization: –Easy trough linear programming (probabilities, payments are variables)

58. Our results on the complexity of mechanism design Social welfare objective: General objective functions: payments no payments payments no payments Deterministic mechanism Randomized mechanism NP-complete (MINSAT) Polynomial time (Groves) Polynomial time (LP) These results hold even for just 2 agents Deterministic mechanism Randomized mechanism NP-complete (MINSAT) NP-complete (INDEPENDENT-SET) Polynomial time (LP) Polynomial time (LP) Polynomial time (LP)

59. More agents All the hardness results from single agent mechanism design generalize to more agents –In the reduction, simply add dummy agents with only 1 type –Even standard social welfare becomes NP-complete (without payment/randomization) Simply incorporate the “outside” component of generalized social welfare into a dummy agent Randomization still makes the problem easier –Again, we can solve the mechanism design instance with linear programming –The constraints now reflect the chosen notion of nonmanipulability (implementation in Bayes-Nash equilibrium, in dominant strategies…)

60. Conclusions on automated mechanism design We proposed an approach where mechanisms are designed on the fly for the setting at hand –Applicable in settings not covered by classical mechanisms –Can outperform classical mechanisms –Circumvents impossibility results about general mechanisms Formally defined the computational problem Analyzed its computational complexity –Various simple settings are NP-complete –Allowing for payments sometimes (not always) makes problem tractable –Allowing for randomization over outcomes always makes problem tractable Future research –What can be done with additional structure on preferences When are other representations more appropriate –What can be done with partial input? –Using mechanism design algorithms experimentally to infer general mechanisms –(Dis)proving mechanism design hypotheses by running automated mechanism design on randomly generated problem instances

61. Thank you for your attention ! Papers on these topics are available at www.cs.cmu.edu/~sandholm