410 likes | 480 Views
When might markets be self-converging? A local, quickly convergent tatonnement algorithm. Richard Cole (joint work with Lisa Fleischer).
E N D
When might markets be self-converging? A local, quickly convergent tatonnement algorithm Richard Cole (joint work with Lisa Fleischer)
... it seems likely that if the concept of the competitive equilibrium is to be useful in economic analysis, we need a mechanism for explaining how agents in the economy may act to generate competitive prices. Sean Crockett, Stephen Spear, Shyam Sunder A simple decentralized institution for learning competitive equilibrium November 2002
Tatonnement Prices adjust as follows: Excess supply: prices decrease Excess demand: prices increase (1874, Elements of Pure Economics) Leon Walrus, 1834-1910
Problem definition Goods g1, g2, …, gn Prices p1, p2, …, pn Agents a1, a2, …, am Utilities u1, u2, …, um uj gives agent aj’s preferences wij: initial allocation of gi to aj; wi = ∑jwij = 1, by assumption xij(p,wj,uj): demand of aj for good gi; xi= ∑jxij, demand for gi Problem: Find prices p such that xi ≤ wi for all i.
A differential formulation Samuelson, 1947 zi = xi - 1,the excess demand. Theorem: [Arrow, Block, Hurwitz, 1959; Nikaido, Uzawa, 1960] Assuming Gross Substitutes, the above differential equation converges to an equilibrium price
Discrete price updates Value of λi matters. Uzawa: there exist λi for which convergence occurs with the update rule: pi← pi + λzi Large λi can lead to cyclic or chaotic behavior (e.g. J.K. Goeree et al. J. of Economic Behavior & Org., 1998)
Our model At each time step • An arbitrary subset of the prices is updated • The agents recalculate their demands thereby yielding a new total demand for each good
Complexity Model Rounds (from asynchronous distributed computing) • A round is the minimal time interval in which every price updates at least once b-bounded asynchronicity • In each round any price updates at most b times p2 p1 P1 p1 p2 p2 p2 Round 1 Round 2
Our goals A price update procedure, with one instance per price, satisfying: • Local • The instances are independent • Each instance uses limited "local" information • The procedure is simple • It is asynchronous • It yields quick convergence
Recent Work (in Computer Science) Many P-time algorithms for finding exact and approximate equilibria for restricted markets and hardness results for other markets X. Deng, C.H. Papdimitriou, M. Safra, On the complexity of equilibria, STOC 02. N.R. Devanur, C.H. Papadimitriou, A. Saberi, V. V. Vazirani, Market equilibrium via a primal-dual-type algorithm, FOCS 02. N.R. Devanur, V. V. Vazirani, The spending constraint model for market equilibrium: algorithm, existnece and uniqueness results, STOC 04. R. Garg and S. Kapoor, Auction algorithms for market equilibrium, STOC 04. B. Codenotti, S. Pemmaraju, K. Varadarajan, On the polynomial time computation of equilibria for certain exchange econmies, SODA 05.
Recent tatonnement algorithms S. Crockett, S. Spear, S. Sundar, A simple decentralized institution for learning competitive equilibrium, Technical Report, 2002. M. Kitti, An iterative tatonnement process, Unpublished manuscript, 2004. B. Codenotti, B. McCune, K. Varadarajan. Market equilibrium via the excess demand function, STOC 05. They are non-local algorithms. Also, there is no complexity analysis in the first two.
Reminder: Our Goal A local price update procedure with fast asynchronous convergence. To the best of our knowledge, no prior results of this type.
How to measure convergence Seek prices p such that: p* denotes the equilibrium solution
Usual approach uj(Actual) ≥uj(Opt)/(1 + ε) for all j Difficulty: in our setting, consider only cummulative demand; no allocation of supply shortfall or excess. Further, no direct knowledge of utility functions.
Further standard definitions Homogeneity (of degree 0): demand at prices p and λp, λ≠ 0, is the same for all goods. Normalize: Choose one good, the numeraire, to have price 1. We call this good money. Write g$, p$.
Standard utility functions Cobb-Douglas Each agent ai spends preset fractions of wealth on each good: fraction αij on good j. Yielded by utility πj (xij)αij or by ∑jαij log xij
Standard utility functions CES (Constant Elasticity of Substitution) For each agent the fractional rate of change of demand with respect to the fractional rate of change in the price is constant, i.e. Yielded by utility function [∑j (bijxij)ρ]1/ρ Only consider ρ s.t. 0 < ρ < 1.
Standard utility functions Weak Gross Substitutes If price pi increases then xjl stays the same or increases for j≠ i, xil stays the same or decreases, and something changes. Could also view as a market condition xj stays the same or increases for j≠ i, xi stays the same or decreases, and something changes.
Our price update rule p′i← pi(1 + λ min{1, zi}) zi = xi – 1, the excess demand By contrast, Uzawa used the rule p′i← pi + λ zi
Our results Cobb-Douglas Utilities: Take λ = 1. Initial prices pI, final prices pF. Converge in:
Our Results CES Utilities: Let ρ = maxiρi Take λ ≤ 4(1-ρ). Initial prices pI, final prices pF. Converge in:
Our results GS with the wealth effect (parameter β≤ 1) and bounded (s ≥ 1) elasticity of demand. For CES, β = 1, s = 1/(1 - ρ); for Cobb-Douglas, β = 1, s = 1. Take λ ≤ 1/(4s); Initial prices pI, final prices pF. Converge in:
Bounded Elasticity of Demand Halve the price: demands increase by at most 2s.
Wealth Effect There is a parameter β, 0 < β ≤ 1, with the following property: Suppose the wealth of bj increases from w to w′, with no change in prices. Let xij, x′ij be the corresponding demands. Then: Double the wealth: demand for each good increases by at least 2β.
What if λ is not known? Have a second algorithm, in which each price setter gradually reduces its λ. Assuming b-bounded asynchronicity, converge in:
p2 z1 = 0 X z2 = 0 p1 What is α? Running example: Cobb-Douglas utilities, 2 goods plus money. P
p2 z1 = 0 X z2 = 0 p1 “correct” adjustment for p1
p2 p1 What if the cone is narrow? It takes lots of steps to halve p1 – p1*, p2 – p2*
What determines the cone’s width? The convergence parameter α; what is it? Roughly: minimum (over all goods) of fraction of spending on that good provided by money at equilibrium Formally: Claim: The parameter α in the complexity is tight.
Elements of the analysis WLOG let 1 = argminipi/pi*. Then: • If p1≥ p1*, then p′i ≥ pi* for all i. • If p1 < p1*, then Or δ′ ≤ δ[1 – α(1 – δ)] where δ = (p1* - p1)/p1* And analogously for maxj pj/pj*.
Reason for the wealth effect At prices pi*/f, for f > 1, i ≠ $, want all zi to be substantial and certainly not negative. Wealth effect yields: xi ≥ xi*(1 + θ(αβ)) = 1 + θ(αβ) Otherwise, one low price, p1*/2 say, may induce a very low price, pn*/cn for some constant c > 1. An analogous claim holds at prices f pi*, for f > 1.
λ unknown Keep separate λi for each price updater. Initially, λi = 1. After 4h updates to pi, λi set to 1/2h. Once all λi ≤ λ, then prices improve. Analysis largely as before except have to undo damage done by λi when too large.
Analysis, λ unknown Mega-round: maximal collection of rounds in which smallest λi unchanged Analysis idea: • Progress doubles in successive mega-rounds • Successive mega-rounds comprise 4 times as many rounds
Result, λ unknown Converge in:
Conclusions Theorem: There is a simple, local, asynchronous, quickly convergent price setting algorithm, assuming a bound on the elasticity of demand is known to each price setter. This algorithm works in GS markets with a wealth effect. Observation: The rate of convergence depends on the desire for money at equilibrium. Parameters: α and s are tight for this algorithm. Open Question: Is β tight? Open Question: Are these parameters tight in any local, asynchronous algorithm?
Conclusions Theorem: Even if the bound s is not known, there is a fairly quickly convergent algorithm. It is not as natural (would really want more adaptive control of λ). Open Question: Devise natural conditions allowing adaptive control of λ.
Ongoing and Future Work • Algorithms for indivisible markets (Cole and Rastogi) • Also, how well can one do? • More realistic dynamic setting