MIT OpenCourseWareLecture 11: Algorithmic Game Theory
MIT OpenCourseWare
Introduction and Lecture Roadmap 0:01
Samuel Bruce, a graduate student working with Professor Townsend, introduces the lecture as an effort to bring computer science and economics together through algorithmic game theory and coordinated equilibria. He outlines the plan: starting with Dubey's limit order market mechanism meant for blockchain implementation, then discussing the difficulty of computing Nash equilibria, then covering correlated and coarse correlated equilibria as more tractable alternatives, and finally looking at machine learning algorithms that could make finding these equilibria more efficient.
Dubey's Limit Order Market 2:00
The market has n players and k goods, where each player holds an endowment and a utility function. In each time period a player submits a strategy made of four values, meaning they will buy a certain quantity at a certain price or lower, or sell a certain quantity at a certain price or higher. Players cannot sell more than they own, but they can borrow at no interest to buy, and if they end a period with negative credit they pay a penalty weighted by a factor called lambda. Each good trades at its own trading post, where the highest buyer is matched against the lowest seller and trades execute at the buyer's quoted price rather than at a single clearing price.
Defining Efficient and Equilibrium Outcomes 9:00
A mechanism outcome is called efficient if no group of players could have jointly deviated to reach an outcome that makes everyone at least as well off and someone strictly better off, a Pareto improvement. If this holds for every individual player acting alone, the outcome is a non-cooperative equilibrium, similar to a Nash equilibrium. If it holds for coalitions of any size, it is called a strong non-cooperative equilibrium. An equilibrium is called active if every trading post has at least two active buyers and sellers, and tight if all active traders are quoting the same price. Dubey proves that active non-cooperative equilibria, and especially tight active ones, coincide with competitive equilibria, and every tight active equilibrium is strong.
SPEEDEX and Real-World Implementation 10:30
SPEEDEX, launched in 2023, is a decentralized limit order exchange built on blockchain technology that closely follows Dubey's mechanism, though it executes trades at a single market-clearing price for each good using an iterative tatonnement process rather than at each buyer's quoted price, which Dubey's own proofs show can break the guarantee of competitive equilibria. SPEEDEX runs efficiently, with per-block runtime scaling with the square of the number of assets times the logarithm of the number of orders, so it handles many orders well since exchanges tend to have few distinct goods. Its clearing prices are consistent across currency pairs, ruling out arbitrage, and because all trades in a block settle at the same prices, it closes off front-running attacks, where a powerful node could reorder transactions it spies on to extract extra value, a practice known as miner-extractable value.
Why Finding Equilibria Is Hard 19:00
Neither Dubey nor SPEEDEX explain how players would actually converge on a non-cooperative equilibrium, since doing so requires each agent to predict everyone else's strategy across a strategy space that grows huge with many goods, prices, and quantities. Computing Nash equilibria is known to be PPAD-complete, meaning all known algorithms take exponential time, and competitive equilibria fall into the same hard complexity class for general exchange economies. The lecture explains the surrounding complexity theory, including NP, hard and complete problems, and the class TFNP of search problems guaranteed to have a solution, within which PPAD sits, defined by the problem of finding an unbalanced node in a directed graph given another one. Nash equilibria were shown to be complete for PPAD by Daskalakis, Goldberg, and Papadimitriou, confirming that no simpler algorithm can exist for the general case.
Correlated Equilibria as an Alternative 27:31
Since Nash equilibria are so hard to compute, the lecture turns to equilibrium concepts built around a central coordinator who holds a joint probability distribution over all players' strategies and privately signals each player their own strategy without revealing what others were told. A correlated equilibrium arises when every player, knowing only their own signal and the shared distribution, has no incentive to deviate from the suggested strategy, since deviating cannot yield higher expected utility. This concept requires roughly the square of the number of strategies as constraints per player, and is called correlated because knowing your own signal lets you infer something about what others were likely told, allowing coordinated group behavior that individuals might not reach on their own.
Constraints for correlated equilibrium 31:02
The lecture sets up the constraints that define a correlated equilibrium using a coordinator who draws joint strategies from a probability distribution and privately tells each player their assigned move. For each player, the expected utility of following the assigned strategy, weighted by the probability of the other player's possible signals, must be at least as good as any deviation to a different strategy. Working through a two by two example with players choosing top or bottom and left or right, the lecture shows how these weighted comparisons are built directly from the joint probabilities, and if every such constraint holds for every player, the distribution qualifies as a correlated equilibrium.
Coarse correlated equilibrium introduced 32:33
Coarse correlated equilibrium relaxes the setup further: players commit to the mechanism before learning which strategy they were assigned. Each player only needs their overall expected utility from following the distribution to beat the expected utility of switching to some fixed strategy, rather than needing to hold for every possible signal they might receive. Because the constraints no longer condition on each player's own assigned strategy, there are far fewer of them, only on the order of the number of strategies rather than strategies squared, and the same two by two example is reworked to show how these expectation-based constraints look in practice.
How the equilibrium concepts relate 36:01
Nash equilibria are a special case of correlated equilibria where the coordinator's distribution happens to make each player's strategy independent of the others, and correlated equilibria are in turn a subset of coarse correlated equilibria, since the constraints get progressively weaker. The practical gain is that once players trust the coordinator's distribution, they no longer need to guess at other players' strategies, turning an exponential strategy space into a linear constraint problem. This does require trust, but blockchain smart contracts solve that naturally because the coordinating code and its distribution are visible on-chain for anyone to verify. Because all these constraints are linear in the strategy probabilities, they can be solved efficiently with linear programming, and the same linear program can simultaneously optimize a goal such as maximizing a weighted sum of player utilities, known as the Pareto planner's problem, at no extra computational cost.
Why polynomial time matters on blockchains 41:30
Exponential-time Nash equilibrium algorithms are impractical for blockchain mechanisms because every node must independently execute every smart contract call for each new block, and platforms like Ethereum require that a contract's running time be determinable at compile time, ruling out unbounded loops or anything beyond low-degree polynomial complexity. This is why the correlated and coarse correlated equilibrium concepts, solvable by polynomial-time linear programming, are the practical targets for inducing the beneficial non-cooperative equilibria found earlier in Dubey's trading game. The catch is that the number of joint outcomes explodes quickly: a toy version of Dubey's game with two players, two goods, and prices and quantities limited to integers between 0 and 9 already produces about 10 to the 16th joint strategy outcomes, and adding a third player pushes that to roughly 10 to the 24th, making direct linear programming over joint distributions unworkable for realistic, near-continuous markets.
Moving to no-regret learning 46:03
To avoid optimizing over the entire joint probability space, the lecture introduces no-regret learning, a machine learning approach where each agent optimizes only over its own strategy rather than the joint distribution of everyone's strategies. This is an online algorithm: at each time step an agent picks an action according to an internal probability vector, submits it to the mechanism, and receives back a cost, which is just utility rescaled and inverted so that the best possible action has cost zero and the worst has cost one. Agents get no information about other players' actions or their own underlying utility function, only the resulting cost vector for every action they could have taken. Comparing such algorithms to a hypothetical perfect algorithm turns out to be meaningless, illustrated by an adversary who randomly assigns cost zero to a different action every round, which a perfect algorithm would always catch for zero total cost while any realistic algorithm accumulates cost linearly over time.
Regret and the randomized weighted majority algorithm 53:03
Since comparing to a perfect algorithm is not useful, the lecture defines regret instead, measuring an algorithm's accumulated cost against a restricted comparison agent that can only play one fixed strategy across all time steps, a notion called external regret. The randomized weighted majority algorithm minimizes this external regret, with a bound showing the gap between the algorithm and the best fixed strategy grows only as the square root of the number of time steps times the log of the number of strategies, meaning the per-step regret shrinks over time. The algorithm itself is simple: it keeps a weight for each strategy, plays strategies with probability proportional to their weight, and after seeing the full cost vector for all strategies at each step, multiplies the weight of any strategy with high cost by a factor of one minus the learning rate while leaving low-cost strategy weights unchanged, so that poorly performing strategies are gradually played less often, typically converging within hundreds to thousands of iterations. The lecture then turns back to the multiplayer economic setting, where every agent runs this same no-regret algorithm against the shared mechanism, each receiving costs for all possible actions, setting up the idea of looking at the time-average of players' strategies.
Time-Averaged Regret and Coarse Correlated Equilibrium 1:00:00
After t rounds of no-regret play, every player's regret per iteration, called epsilon, shrinks as t grows. Averaging the joint outcome distribution across all those rounds gives a coarse correlated equilibrium whose accuracy depends only on how small that regret has become. The payoff is that you no longer need to optimize over the huge joint probability space of all players at once. Each player just minimizes regret over their own strategies, and when you play everyone's learned strategies against each other, the result still lands close to the equilibrium, at far lower computational cost.
Swap Regret and Correlated Equilibrium 1:02:02
Moving from coarse correlated to correlated equilibrium requires a stronger comparison standard called swap regret, where instead of asking whether you'd have done better sticking to one fixed action the whole time, you ask whether you'd have done better swapping to a different action every time you played a given one. External regret is really just a special case of this, restricted to a fixed mapping. Swap regret algorithms exist and run in polynomial time, and time-averaging their play converges to a correlated equilibrium. A worked two-player example run for 20,000 iterations shows the raw strategy probabilities oscillating as each player exploits the other, yet the time-averaged joint probabilities settle onto the game's unique Nash equilibrium within a few thousand iterations. One cost of this approach is losing the ability to maximize a total-utility objective the way linear programming allowed.
Information Settings and Open Questions 1:07:34
Learning algorithms differ by how much cost information each player receives: full information reveals the expected cost of every strategy, partial information gives noisy costs based on others' actual play, and the multi-armed bandit setting only reveals the cost of the action actually taken. Less information means slower convergence, but full information can be too costly to compute in real settings, so the right choice depends on the mechanism being designed. These no-regret methods matter for Dubey's mechanism because they handle continuous price spaces and huge strategy sets without restriction, even under bandit-style limited information, making them promising for building a coordinator that could deploy Dubey's market onto the blockchain. Open questions include how efficient and fair these computed equilibria are, how learners can adapt to shocks in endowments or utilities, and what the best trade-off is between information richness and convergence speed.
AI-generated summary. It can be wrong or incomplete - check anything that matters against the original.
