The Complexity of Resource Allocation and Price Mechanisms under Bounded Rationality

Author(s): Eric J. Friedman and Shmuel S. Oren

Reviewed work(s):
Source: Economic Theory, Vol. 6, No. 2 (Jul., 1995), pp. 225-250
Published by: Springer
Stable URL: http://www.jstor.org/stable/25054874 .
Accessed: 13/09/2012 15:38
Your use of the JSTOR archive indicates your acceptance of the Terms & Conditions of Use, available at .
http://www.jstor.org/page/info/about/policies/terms.jsp

.
JSTOR is a not-for-profit service that helps scholars, researchers, and students discover, use, and build upon a wide range of
content in a trusted digital archive. We use information technology and tools to increase productivity and facilitate new forms
of scholarship. For more information about JSTOR, please contact support@jstor.org.

Springer is collaborating with JSTOR to digitize, preserve and extend access to Economic Theory.

http://www.jstor.org

Econ. Theory

( 1995)

6,225-250

"Pi-?

Economic
Theory
?

Springer-Verlag

1995

The complexity of resource allocation and price

mechanisms
under bounded rationality*
Eric J. Friedman1
1
2

The Fuqua
Department

Received:

School

and Shmuel S. Oren2

of Business,

Duke

NC 27708-0120,
Durham,
University,
of California,
Berkeley, CA 94720, USA

of IEOR, University

June

14, 1993; revised

version March

USA

15, 1994

the complexity
Summary. We develop a framework for designing and evaluating
of mechanisms
that allocate resources in a distributed setting to agents or processors
with bounded computational
and describe
ability. We discuss several mechanisms
the construction of efficient price based mechanisms,
which exploit the decentralized
are polynomial
in the number of
aspects of the problem. These price mechanisms
resources, precision of the solution, and the logarithm of the number of agents.

1 Introduction
In this paper we consider the problem of allocating resources among a large group
of processors (or agents) in a distributed setting in order tomaximize
the total social
welfare of an economy. It can also be interpreted as maximizing
total value or profit
in an organization. We provide a framework for studying such mechanisms,
which
we then use to evaluate
several different ones. Our goal is to design efficient
mechanisms

that can compute

reasonable

allocations

in a distributed

rapidly

setting.
The design of mechanisms
for the allocation of scarce resources among a large
a
is
of
fundamental
group
processors
[1, 10, 14]. This
topic inmodern economics
resources may
is
also
in
of
distributed
where
great importance
problem
computing,
refer to CPU time, network bandwidth, and data storage. In fact much recent work
has involved the application of economic ideas to problems in distributed computing.
(See e.g. [5,9, 15, 17,33,32,36].)
was instituted by Reiter
The formal study of'efficiency'
for different mechanisms
a
on informationally
and
has
literature
and Hurwicz
[12, 24]
large
produced
most
efficient mechanisms.
of
these
consider
mechanisms
which
However,
analyses
at equilibrium
find optimal or Pareto efficient allocations
The
[13].
incorporation
in a limited manner [23]. However,
of dynamic elements has only been attempted
the time required
*

We

been

thank Thomas
supported

find a good

to actually
Marschak

by National

and

Science

(or optimal)

allocation

a anonymous
referee for helpful
Foundation
Grant
IRI-8902813.

has not previously

suggestions.

This

research

was

226

E. J. Friedman

and S. S. Oren

been studied. Furthermore,

the complexity of a mechanism
has been defined as the
at
not
of messages
the
effort or total
required
equilibrium,
computational

number
number

of messages
required overall. We believe that the total time and effort
an
to
allocation should be considered when designing mechanisms,
compute
required
as these directly determine how well they function.
Most of the work in this field has implicitly assumed that the processors have
unlimited computational
ability, since they are required to exactly solve difficult
This viewpoint
is certainly unrealistic and
problems instantaneously.
are not
been questioned;
in an economy
typically, the processors
Such limitations have been
infinitely wise, neither is the designer of the mechanism.
referred to as 'bounded rationality' [37, 31].
Several approaches have attempted to account for the decision maker's bounded

optimization
has recently

rationality.
perform
consider

Simon [37] considers 'satisficing' mechanisms,

where mechanisms must
in an informally defined satisfactory manner. Mount
and Reiter [25]
are variants of finite
the design of mechanisms
when the participants

automata.

in an organization
Recently, Radner [29] has analyzed information processing
from a computational
is very similar to ours. However,
which
he
viewpoint
considers the problem of designing an efficient organizational
structure, where we
assume that the structure is predetermined
and concentrate on the protocols within
the

structure.

In this paper we consider a very natural model of 'finite

as 'processors' where each one has a finite
the participants
and employ concepts
traditionally used in the context of
For our definition of'processor'
combinatorial
optimization.

rationality'. We model
'speed of computation'

complexity
theory for
we use the recent idea
over the real numbers' as discussed
in [3, 22, 2]. Our 'processors'
of'computation
can manipulate
in unit time: addition,
real numbers and do the following operations
subtraction, multiplication,
division, and comparison. This model of computation
It is also, perhaps, a more realistic model of
is both elegant and useful analytically.
most of
numerical analysis. Nonetheless,
the workings of modern
and
computers
our discussion and results are also valid in standard models of binary computation,
such as Turing machines, with only slight modifications.
We consider the problem of constructing mechanisms which compute allocations
to be 'good', in the sense of social utility,1 but not 'perfect', in
that are guaranteed
a reasonable amount of time. The most important aspect of these mechanisms
is
that they scale well with the number of processors. That is, even if the number of
processors

is very large our mechanism

will still operate

in a reasonable

amount

of

time.2

a specific pareto optimal allocation.

In
that by optimizing
social utility we are in effect choosing
Note
as
this problem
is strictly harder than finding a pareto optimal allocation,
the case of a single resource,
it does not
in the case with two or more resources,
is parteto optimal. However,
any feasible allocation
seem that finding a pareto optimal solution, which is pareto superior to an initial endowment
is necessarily
easier than the problem we consider.
2
Similar ideas can be found inMarschak
but allows

processors

to use

[21]. He explicitly
infinite computation.

considers

the running

time of a mechanism,

Resource

allocation

mechanisms

227

are scarce. The case of a single resource

Previous
results for such mechanisms
has been well studied, and several polynomial
algorithms exist [15,8]. For multiple
resources Nemirovsky
and Yudin [26] provide the framework for constructing
such
but do not take full advantage
of the structures
inherent in the
mechanisms,
of a mechanism
for a generalization
problem. In [7] we describe the construction
of the multi-resource
allocation problem. However, none of these methods provide
a decentralized mechanism
resources that converges rapidly
for allocating multiple
the number of processors is large. Our goal is to construct such a mechanism.
In the next section we formally define our model,
and some measures
of
and efficiency
We
then consider quantity
for mechanisms.
based
complexity
mechanisms.
In the context of mathematical
these are often denoted
programming
These are only discussed
primal algorithms. We describe two such mechanisms.
neither of these
briefly as they have been well treated elsewhere [7, 26]. However,
mechanisms
satisfies our definition
of efficiency, which we denote polynomial
when

our reliance on the theory of computational

in order to emphasize
as they do not
complexity. This is a standard problem with primal algorithms
appear amenable to distributed
implementation.
Our main focus is on price-based mechanisms
and the construction of polynomial
efficient mechanisms
using prices. These can be interpreted as finite versions of
are naturally implemented in a distributed
primal-dual algorithms. These mechanisms
efficient

system, as primal-dual algorithms typically distribute well. For example Arrow and
Hurwicz use a primal dual method
for constructing
in
decentralized mechanisms
are
as
structure
These
efficient
take
of
the
very
[1].
they
advantage
algorithms
inherent in resource allocation problems.3 For example the price mechanism
for a
resource
our
to
is
the
distributed
single
only polynomial-efficient
algorithm
resources
we
two
For
is
it
the
know
which
knowledge.
only algorithm
exploits the
structure of this problem and is the only polynomial-efficient
serial or parallel
algorithm known to us. For more than two resources we conjecture that the same
is true.

we note

can be seen as extensions of a theory of

in [7] which is based on the work of
polynomial-efficient
expounded
optimization
and
should
be contrasted
the standard
Yudin
This
with
[26].
Nemirovsky
in
In
those
results
nonlinear
results, the speed of
asymptotic
programming.
a
is
in
small
of
the
solution. Also, the
convergence
guaranteed
neighborhood
on
relies
the
very strongly
analytic properties of the functions
theory
asymptotic
are
based on convexity properties of
results
being optimized. Polynomial-efficient
the functions, but they are global and guarantee that the (approximate)
solution of
the problem will be found in a specified finite time.
The specific result of this paper is that the polynomial-efficient
theory can be
to
to
with
in
order
reduce
the
number of
applied
problems
special structure,
Finally,

that these mechanisms

3
the theory of mechanisms
and
The formal description
of mechanisms
reflects the interplay between
In fact many of the mechanisms
found in the economics
literature
that of mathematical
programming.
and currently many algorithms
for mathematical
have their inception
in mathematical
programming,
are using ideas from economics
for their inspiration. Our work is no exception.
programming

228

and S. S. Oren

E. J. Friedman

computations
required to find a solution. Note that we are not considering incentives
or initial endowments
of agents.
The paper is structured as follows. In section two we define a model
of
for resource allocation, both with and without a center. Then section
complexity
three presents two quantity based mechanisms,
which are modeled
after known
are efficient we are led
methods of optimization.
Since neither of these mechanisms
to the construction of new, price based, mechanisms
in section four. In the first part
of section four we construct a price mechanism
for a single resource. Although much
of this part is pedagogical,
is a significant improvement
the mechanism
constructed
over known algorithms
for the distributed allocation
of a single resource. In the
for two resources and propose
second part we construct a price based mechanism
a similar construction
for any number of resources. Since the proofs for this part
are quite involved, we present them separately in the appendix. Section five describes
to the important case of externalities and section
the extension of our mechanisms
six contains our conclusions.

2 Model
consider the problem of allocating
data for an economy is the environment
=
This
is denoted
by U
(UUU2,...,
environments. We will assume that T =

We

concave

of all C2 nondecreasing

r resources among n processors. The basic

or set of utility functions for the processors.
T is the set of possible
Un)e T, where
x
x
x
T2
Tn where each T? is the set
Tl

(utility) functions

t/f:W->

9?+ with

du?

<

l,and

dx?\
17,(0)

= 0. Note

that since l/f is concave,

the condition

that

dU,

<

dxi

1 is quite mild

and is essentially a normalization.4

it is only known to
As is typical, we assume that ?/, is private information
more
we
assume
a
i.
form
of
However,
processor
privacy than is usual. We
specific
assume that the processor has access to a utility function oracle which can be queried
and supply the processor with local information about the utility function such as
values and derivatives of t/^x,) for specific values x, provided by the processor. Each
to capture the bounded
query requires one unit of time. This is an attempt
as
of
the
manifested
by the local information
knowledge
rationality
processors'
available to it, since global information would allow it to 'smuggle' information and
for.
that would not be accounted
computation
For ease of exposition we will assume that there is 1 unit of each resource. The
set of feasible allocations
F =

is

=
(x1,...,xn)|x?G^,?x/=l,

j=\,...,r\.

|x
These

The

more

restrictions

restriction
elaborate

are easily relaxed at the cost of additional

to differentiable
proofs.

functions

is not

really necessary,

notation.

and could

be removed

at the cost of

Resource

allocation

mechanisms

Agents
Figure

The

goal

approximately

of a mechanism
maximizes

1. A central mechanism

will

be

an allocation
to rapidly compute
that
=
to
where
xeF,
U(\) subject
U(\)

the total utility5

liU^Xi).
We will consider both central and distributed mechanisms.
Central mechanisms
are very common
in economics. For motivation
consider the standard Walrasian
process consists of a center shouting prices to a large group of processors. Central
can also arise in distributed
are
mechanisms
computing when many processors
sharing

a single

resource.

center-less

However,

are

mechanisms

often

more

relevant

a large collection
of processors
(such as
computing,
or personal computers) are interconnected
on a large network. We
workstations
we design are easily implemented
show that any of the central mechanisms
in a
a
distributed
with
loss
of
setting
negligible
efficiency.
for distributed

in which

2.1 Central mechanisms

We will assume that there are many processors
interacting with a computationally
we
assume
center.
Thus
that
the
'center'
has computing speed proportional
powerful
to the number of processors,
and each processor has a unit speed of computing.
a single real number
The center communicates
with the processors by broadcasting
can respond by each one
to all the processors
The processors
simultaneously.
a
to
center.
real
number
the
sending
single
(See figure 1.)
as a vector of computer programs (or algorithms)
We define a mechanism
m

where

each mf represents

(m1,...,m?,mc)eM1

a program
x(m, U)

be the output
of mechanisms
5

that computer
(x(mu (7t),...,

Mn

Mc

i follows. Let

x(mn, Un))

m in environment U. (We will only consider

have feasible outcomes x(m,U)eF.)

of mechanism
which

the case

Note
that this socially optimal allocation
is also Pareto Efficient.
In the case of a single resource this
is inherently more difficult than the standard problem
in an exchange economy. However,
when
problem
there are two or more resources
it is not clear which problem
ismore difficult, or more relevant. This is
an important open problem.

E. J. Friedman

230
Define

the error of mechanism

e(m,U)

in environment

and S. S. Oren

to be

| (7(x(m,U)) l/(x*(U))|

where
x*(U)
So e(m, U)

argmaxxeFl/(x)

is the error of m on U. Now

e(m)

define

the error of a mechanism

to be

sup ?(m, U).

UeT

are interested

in parametrized
families of mechanisms,
{me,n,r}, where me,n,r
that for n processors and r resources has ?(me'n'r)< e for all \JeT.
communi
Our mechanism must perform three different actions: computation,
cation, and utility function evaluation. We represent the time required for each of
these operations
symbolically. Let X be the amount of time required for a single
number)
(real
by a processor and X/n for the center, / be the time for
computation
We

is a mechanism

of a number, and Q the time required for a single query of a

Note
function.
that the processors and the center can each perform a single
utility
action simultaneously.
to be the time required by that
We will denote the complexity of a mechanism
to compute an allocation. We will compare the behavior of complexities
mechanism
the communication

this time

by considering

Timenr)
where G(-) is a (symbolic)

function

OiGie,n,r))

containing

X,I,i2's

such that

Timenr)<KGie,n,r)
for

some

k and

constant

all

Thus we can compare

As in standard complexity

e, n, r.

different mechanisms

their complexities.
by comparing
an
of
[18],
algorithm will be
theory
parallel computing
a
in r, log n, and
is
if
it
bounded
deemed
by
polynomial
'polynomial-efficient'
on
used
in
the
definitions
standard
computer science (there
log (1/a). This is based
are a reasonable number of resources, a very large number of processors) and the
on e be equivalent
to an algorithm
that is at least
that the dependence
condition
linearly convergent.
2.2 Distributed

mechanisms

can easily duplicate central mechanisms

with only a slight
Distributed mechanisms
there is no center. We imagine that
loss of efficiency. In a distributed mechanism
can do one computation
in time X. We also assume that the
each processor
=
(K,E) where each
processors are connected on a network. Thus there is a graph G
two
and each edge connects
to a processor V= {1,2,...,n}
vertex corresponds
not
too
we
have
that
the
many
However,
edges,
processors
graph
require
(i, j)eE.
thus preventing everyone from talking to everyone else, which would not be realistic.
to a
is connected
is that each processor
A useful (and non-restrictive)
assumption
small number

of other processors.

Resource

allocation

231

mechanisms

001

000

010

Oil

100

101

110

111

Agents
Figure

2. Agents

organized

on a Butterfly

network

are connected via a butterly

we assume that the processors
a
is connected to four
network.6 (See figure 2.) In butterfly network each processor
in an array that (somewhat) resembles a butterfly. This network
other processors
to be performed rapidly. For example sums
allows many distributed computations
of numbers and matrix operations can be performed in (9(log k) time, where k is the
number of real numbers involved in the computation
[18].
as a distributed
can be implemented
Now note that any central mechanism
some processor
to act as the center. However,
mechanism
by simply designating
increase the complexity
by a factor of 6(n) as the processor
typically this would
For concreteness

computes more slowly than the center does, which would make any polynomial
distributed one.
into a polynomial-inefficient
efficient central mechanism
This can be avoided by exploiting the power of distributed computations
by the
in a
which we describe can be implemented
network. All of the mechanisms
is increased by a
the complexity
distributed manner. In each of these mechanisms
and information
factor of log n in the number computations
not effect the polynomial-efficiency
of any of the mechanisms.

3 Quantity

exchanges.

This does

mechanisms

space and have the property

operate on the allocation
Quantity based mechanisms
is always feasible.
the intermediate allocation
that (after a period of 'initialization')
must be terminated before its completion,
it will still
if the mechanism
Therefore
a
allocation.
feasible
(and reasonably good)
supply
based
The only quantity
however, have shortcomings.
mechanisms,
that we are aware of fall into two
with finite polynomial-efficiency
each of
and 'descent' methods,
classes. These are 'generalized bisection' methods,
which has its own shortcomings.
These

mechanisms

6
Actually

any expander

graph will

suffice.

(See [18].)

232

E. J. Friedman

and S. S. Oren

bisection methods which are represented by the ellipsoid mechanism,7

do not distribute well, and use very little of the processors' computing power.
Gradient methods as represented by the mirror descent mechanism
[26], can be
distributed effciently. However
in log 1/e as they converge
they are not polynomial
Generalized

sublinearly.
This can be seen in the following
and Yudin [26].
Nemirovsky
1 A mechanism

Theorem

theorems

which

based on the ellipsoid method

are based

on

the work

can be constructed

of

which has

complexity

= o(rV
T{mEn^(eUipsoid))

+ Xo%lh + / + q
J

log(i7i/e) x(\

the resource allocation problem.

The proof is omitted
for brevity. It is a straightforward
of the
application
in
that
described
and
Yudin
call
this
[26, 28]. (Note
algorithm
Nemorovsky
center
the
modified
method
of
of
algorithm
gravities.)

for

2 A mechanism
which has complexity

Theorem

based on the method

of mirror descent

+ Z+
fl])

nm^mdM^^^^l+^
for

the resource allocation

The proof is omitted

can be constructed

problem.
for brevity.

It is a straightforward
of the
application
algorithm described in [26].
do not satisfy our definition of polynomial-efficiency.
Thus, primal mechanism
is not truly distributed and
The ellipsoid mechanism
fails because the computation
share of the work. The Mirror Descent
the center must do a disproportionate
on s, i.e. 0(\/e2).
also fails due to its poor dependence
Mechanism
Even for the case of one resource, primal algorithms with known bounds on
their complexity
[15, 8] fail our criteria of polynomial-efficiency
poorly. In the next section we describe a primal-dual approach
weaknesses
of primal mechanisms.

as they distribute
the
that overcomes

4 Price mechanisms
is based on the idea of a Walrasian
idea of a price mechanism
process, which
in detail in [40]. Thus, our process is based on the idea of a center
a sequence of prices, and processors picking a consumption
bundle
announcing

The

is described

The ellipsoid method was developed

by Nemirovsky
It ismost well known from its use by Khachian
[16]
However,
programming

purpose was for convex programming.

it may
not seem to be of practical
value; however,
that increase the efficiency
In fact, recent modifications

its original
it does

programming
found useful

[4].

[26] based on an idea of Levin [19].

of linear programming.
the polynomiality
for linear
it is useful theoretically
While

and Yudin
to prove

applications.

(See [39, 34].)

actually be useful for convex

have
of the ellipsoid method

Resource

allocation

233

mechanisms

until a feasible allocation

px,. This process continues
is reached.
The importance of this process is demonstrated
by Hurwicz [11]. He shows that
this process defines an optimal mechanism,
in the sense of having the minimal
a Pareto optimal
which
message
space of any static mechanism
implements
that maximizes

U^x-)

this mechanism
is not stable [35]. A modification
allocation. However,
of it based
on the 'Global Newton Method'
a
is
but
stable,
[38]
space.
larger message
requires
assume that processors
can provide their exact optimal con
These mechanisms
are able to instantly
sumption bundle for a given set of prices. Thus processors
a
the
of
difficult optimization problem, while any such computation
compute
optimum
requires an arbitrarily large number of computational
steps. The issue of accuracy
and computation
in this situation has been neglected
in the
ability of processors
literature.
In this section we show how to construct finite 'computational' mechanisms
are polynomial-efficient
based on theWalrasian mechanism. These mechanisms
and
naturally

4.1 One

distributed.

resource

In this section we present a price based algorithm for allocating a single resource.
The algorithm we present
is not the simplest possible, but it is the one most
are extendible to
amenable to generalization. Most of the ideas in its construction
a basis for
the multi-resource
problem. Thus, our goal here is to provide
other price based mechanisms.
constructing
This mechanism
operates in two stages. (Recall that we are trying to maximize
L/(x) over all feasible allocations,
given a prespecified amount of the resource.) In
the first stage the center announces a price and the processors compute a resource
that approximately maximizes
utilization
Liix^p)

UiiXi)

piXi

\/n)

to a given accuracy. This is done using a finite accuracy

to locate the zero of the derivative

version of a binary

search

L'iixi,p)=U'iixi)-p.

UjiX,) -pKj

Xj(lOUj)
Figure
x(high)

can result from a single

3. Multiple
allocations
is of the same value to consumer
i

K,

Kj(high)

price. Note

any allocation

between

x(low)

and

234

E. J. Friedman

and S. S. Oren

Using this information the center computes a new price and the process
until the center has found a price p that approximately minimizes
L(\,p)

continues

YaLi(xi,p).
i

the current allocation may not be feasible for two reasons. First, even
However,
was
if the price
the correct price p*, the resulting allocation might not be feasible if
the processor's
utility function was flat at this price, and its marginal
utility
choices all with
constant, thus allowing for a wide choice of possible consumption
is that the price p may be
the same net utility. (See figure 3.) Another problem
effects.
arbitrarily far from p* due to inter-processor
This problem is remedied in stage 2. Basically, the center asks the processors for
their maximum
and minimum
choices x, that are reasonably good
consumption
(within ? of optimal), given the price p, which the processors compute approximately
using a finite accuracy binary search. By noting that a feasible allocation must occur
in the interval between these
for some x with the consumption
by each processor
two points, we see that some convex combination
of these points must give a feasible
x is then used as the allocation. While
this allocation
allocation. This combination
?
x* ||may be quite
may be arbitrarily different from the optimal allocation
( ||x
?
U(x)\ as it is the convex
|
large) it is still an accurate one in the sense of U(x*)
and convex combinations
of two other good allocations
combination
preserve the
of solutions.
the center
the interplay between the processors and the center. Essentially
allocation by asking questions of the processors,
is computing a good approximate
answers. Thus there are two levels of computation
who are computing approximate
accuracy
Note

and two levels of approximation.

Price mechanism
Center's

Stage

for one resource

program?m*'"'1

(price)

1:

1. Let Pi = 0, ph = 1, and s = e?n.

2. Repeat Nc = [log(l/?)]
times.
a
of L(x(p),p) where
search
for the minimum
binary
(Perform
the
computed
approximately
by
processors.)
=
(a) Letpm
(pl + ph)/2
=
(b) Let p pm.
i: transmit pm + ?/2 to processor
i.
For
all
(c)
=
i.
i:
For
all
from
receive
+
/.+
processor
e/2)
(d)
Li(x*,pm
?
i.
to
i:
all
For
transmit
pm ?/2
processor
(e)
=
i.
(f) For all i: receive 17 L1(x79pm + e/2) from processor
=
/?
(g) Compute
?,/*
2'.
(h) If|/+-r|<?
goto'Stage
=
>
Else
if
/"
let
/+
ph pm.
(i)
=
(j) Else let Pi pm.
3. Continue.

x(p)

is

Resource

allocation

235

mechanisms

Stage 2:
1. For all i: transmit p to processor
i.
2. For all i: receive xf from processor
i.
3. Compute
maximum
and minimum
s? =
(The
?/xi?.
are

that

Lete'

for combining

x+ and x~.)

iprice)

program?m*'"'1

Stage 1:
1. Receive p.
2. Let Xj = 0 and xh =
3.

amounts

e-accurate.)

4. Let a = (s+ - l)/(s+ - s"). (The coefficient

5. For all i: transmit a to processor
i.
Processor's

consumption

1.

?2.

4. Repeat Na = flog(l/?')l
times.
(Perform a binary search to find the optimal
=
(a) Let xm
(x, + xh)/2.
=
(b) Letvm
U'iixm).
=
xm.
(c) Ift;m<pletxz
=
Else
let
xh
xm.
(d)
5. Continue.
6. Transmit L,(xm, p) to the center.
7. Go to 1.
Stage 2:
1. Receive p from center.
2. Do for w= ?1.
= 0 and
=
xh
(a) Let xl

consumption

at price p.)

1.

(b) Setf=Li(xl>P).
(c) Repeat [log(s)] times.
value of x?
(Do a binary search to find the maximum
(resp. minimum)
such that \LiiXi,p)
L(x,,p)| < e.)
i. Let xm = (x, + xh)/2.
ii. Let/m = Li(xm,p)andi;wl = (;;.(xJ.
iii. If |fm? lm |< ? let x, = xm if w = + 1 otherwise let xfc= xm.
iv. Else if vm< p then let xz = xm.
v.

let xh =

Else

xm.

3. Continue.

4. Transmit

to center.

x1

Receive

a from

6. Compute

x,

5.

Theorem

3 The

center.

axf+ + (1 + a)xf". (This is the allocation

i.)

1 resource price mechanism m?'"'l iprice) has complexity

=
T(m<*1)

?((iog"Y[X

It is easy to see that stage 1 dominates

performs log(l/e) iterations, and each iteration

Proof:

to processor

+ / + 12]Y
stage 1 the center
stage 2. During
of a sum,
the computation

requires

236

E. J. Friedman

and S. S. Oren

a few simple computations,

to compute their own
and two calls to the processors
optimization problem. During these calls each processor performs log(l/e') iterations,
and each iteration requires one call to the oracle and several basic computations.
This shows that the complexity
is as stated.
To prove that the algorithm

computes

L(x,p)

a correct solution consider

the Lagrangian

YjUi(Xi)-p'(YjXi-l)

and the dual function

= max
X L(x,p).

F(p)

[30] we know

By the duality theory of convex programming

then
function and if p* = argminpF(p)
x* =

argmaxx

so Xi(p) = argmax^.LiXf, p).

Note that the Lipschitz constant
A (F) = max
by the envelope theorem [40].
Now we prove the theorem
Lemma

1 Stage

Ui(Xi)

of F(p)

p(Xi

is separable

in x and

\/n)

is

dF(p) dL(x,p)
dp
dp
through

is a convex

L(x,p*).

=
Define x(p)
argmaxx L(x,p) so x*
x(p*). The Lagrangian
=
can be written as L
where
?. Lx
=

Li(Xi, p)

that F(p)

5>i-i

<n

two lemmas.

1 computes a p such that

\F(P)-F(p*)\<e.
that the processors
Proof: Notice
simply perform a binary search for the xf that
is the condition
for optimality.
Thus the x, that the
satisfies U'i(Xi) = p, which
processor computes, which we denote xf(p), is within e' of the optimal x?(p) which

implies that U^x^p)) iswithin s' of Ut(xf(p)).

that are
center is performing
binary search on F(p) using solutions
in total
to
to
accurate
and
ne'-accurate
be
sf
in
each
thus
coordinate
guaranteed
as
we
derivative
of
that
the
the
Note
need
sign
only
gradients.
using approximate
is close to
this inaccuracy is not important except when the computed derivative
zero. Thus, if the loop terminates normally then we know that this has not occurred
if at some iteration the center finds
and the solution must be accurate to ?.However,
The

a derivative
that is close to zero it immediately halts. This is correct since for this
to occur the derivative at this point must be less than e. This implies that either pm
is within ? of p* or that all three, pm and p? are approximately
equal. This also
no
matter
how
far pm is from
solution
?
the
within
of
that
is
optimal
F(pm)
implies
s
assume
then
+
For
that
p*>pm
p*.
example

F(Pm+ ?)<(l-?)F(Pm) + ?F(p*)

Resource

allocation

by convexity.

237

mechanisms

Therefore

F(pm+ ?) F(pm)< ?(F(p*) F(pJ)

and since

?
\F{pm+ e) F(pm)\ < ? we see that
O

0>F(p*)-F(pm)>-?/n>-e.
Lemma

2 Stage 2 computes an e-accurate, feasible

Proof: In stage two the processors

are solutions of

compute

solution.

an approximation

of x.+ and xf which

- ?
s.t. Lt(xi9P) > L^p)
argmax^.dxi)
ifwe can show that s+ > 1 and s~ < 1 then 0 < a < 1 and
that is accurate to ?.Now
of x*. Now as l^x1,^) ? Fip)\ < 2ns we
the allocation x? is a convex combination
?
see that |L(x, p) Fip)) < 2ne as L(x, p) is concave in x and thus L(x, p) > min L(x ?, p)
x? =

by concavity.
From this we

immediately

see that

=
|L(x,P) L(x*,p*)| < 3ne
\Lix,P) Fip*)\
and as both x and x* are feasible

this implies that

\Uix)-Uix*)\<3ne<e
thus showing that the solution is sufficiently accurate.
Now we must show that s+ > 1 and s" < 1. If the center
?
this implies that
small derivative then \p p*\<e

in stage 1 never saw a

\Lix*,p*)-Fix*,p)\<ne
as the Lipschitz constant of L(x, p) is less than n. Now as L(tf, p) < L(x(^), p) then
this implies that xf is an ? accurate solution to the processor's
stage 2 problem.
Thus xf~ < xf < x* implying that s+ > 1 and s~ < 1.
if the center terminated stage 1 due to a small derivative then we know
However,
that

\dF(P)\
< ?, but we

also know

that

dp

dFiP)
.

=*(?)-1.

dp
Now
if we consider x' = xip)/s(p)
Thus we see that \sip)\ < ? where sip) =
Y,ixi(P)=
we see that
1 and |x?. xt(P)\ < 2e. thus
\L(x',p) Ux,p)\ < 2ne for ? < 1/2,
?.x;
so xf~ < x\ <
O
the proof of the lemma.
x?+, completing
Combining

4.2 Two or more

the two lemmas completes

the proof of the theorem.

resources

for two or more resources follows the basic

The construction
of a price mechanism
for a single resource case. Stage 1 is the same as previously
ideas of the mechanism
but with two differences. In stage 1 the center computes the derivative using finite

238

E. J. Friedman

and S. S. Oren

of two nearby prices. In higher dimensions

this idea must be used to
an
more
of
the
much
difficult and we must
compute
approximation
gradient. This is
a
an
settle for
of computing
randomized method
that has only a
approximation

differences

small chance of failure [26]. The second difference is that in the price mechanism
for a single resource we used a finite accuracy variant of the bisection method
for
several purposes since all searches were one dimensional.
In this case we must do
similar searches in two or more dimensions. Therefore we must replace the simple
bisection method with an ellipsoidal algorithm for convex programming.
This is
the same algorithm used for the ellipsoid mechanism,
but in this case it operates on
the price space, which
is much
smaller (dimension
r) than the primal space
(dimension nr) on which the ellipsoid mechanism
operates.
The construction
than in the simple case.
of stage 2 ismuch more complicated
to construct two solutions who's convex hull
In one dimension
it is straightforward
contains a feasible solution. In higher dimensions
this ismuch more difficult. For
the case of two resources we have constructed a method which solves this problem.
We believe that a generalization
of the method should work for an arbitrary number
of resources but have no proof of this conjecture.
we describe
In the following discussion
of a price based
the construction
over
0 < x < 1. As the
for two or more resources which maximizes
mechanism
l/(x)
are
1
resources
not
two
for
for
than
the general case,
for
any simpler
stage
proofs
we will give them for the case of an arbitrary number of resources. However
for
on
a
we
resources
case
to
two
2
comment
the
and
stage
only briefly
specialize
possible extension to cases with more resources at the end.
In stage 1 the mechanism
computes a p that is ? accurate
where
F(p),

for the minimum

?
?
=
F(p) = max L(x, p) max l/(x) Pi ? xf 1 J
using

e3-approximate

solutions

Figure

by the processors

4. Geometry

to evaluate F(p).

of stage 2 algorithm

of

Resource

allocation

239

mechanisms

Stage 2 iteratively

computes

a set of solutions

to

?
max c1"x s.t. L(x,
| ?
|
p) L(x, p) <
who's

convex

a feasible

hull contains

solution (approximately).
This is done by
a
or restrict
which
contain
feasible
either
solution
repeatedly constructing
simplices
the solution by pushing a face of the simplex up towards the solution. (See figure 4.)
This is continued until either a feasible solution is found (by being contained in the
convex hull of a simplex) or a face of the simplex is close enough to a feasible solution
that we can just 'round' the solution to feasibility with only a small loss in accuracy.
to the problem with an arbitrary number of
This idea seems to generalize
resources. Again in this case we can use simplices to trap a feasible solution against
the face of a simplex. Unfortunately,
this does not guarantee that a straightforward
we
will
believe
that by using several such simplices
work.
However,
rounding
we
can
to allow for a
'trap' the feasible solution,
simultaneously
successfully
to
succeed.
rounding step
As the mechanism
for two or more resources is significantly more involved than
one
that for
and less
resource, we will describe the programs more descriptively

formally than in the previous sections.

Note that this mechanism
has a parameter ? which must be chosen in advance.
This is the probability
that the mechanism will fail, due to 'unlucky' approximations
for the gradient of F(p). The running time only depends weakly, (9(log I/o), on the
choice of ?.

The price mechanism

Center's

Stage

for two resources

program?m*"''(price)

1:

1. Construct

the

x=l/2

ellipsoid

1 =(1,1,...,

where

1)

and

p at random

from

B-Diaa(7?.7-}

2. Let e= e/4.
times.
3. Repeat Nc = [4r2 log(l/?)]
an
Construct
gradient
approximate
(a)
the box K = {p| ||p-p||i

<

T} where
r

at p by choosing
T = ?6--.
Now
12/rr

U(x + Tei)-U(x)
-e?

c=l

where

et is the unit vector

let

in the i'th direction,

and t =-?-.

Se3

576n7r4log(l/8)
(b) compute
method.
4.

Continue.

a new p and B using

a finite precision

variant of the ellipsoid

240

E. J. Friedman

and S. S. Oren

=
Stage 2: (For r 2.) (Initialize.)
1. Letc.Ml^c^-l^.
2. For all i: transmit ch and c, to the processors.
3. For all i: receive sh and Sj from the processors, where
v such that \\st ? sh)= 0 and (0, l)v = 1.
4. Compute
5. Letv = v/||v||2.
=
6. Ifvtsi<ethencm
(0,l)t.
7. Else if vfs, > ? then cm= (0, - l)f.
8. Else Goto ROUND.
9. Let d = c,?. (This will define the outward direction.)

s=

xx?e9?2.

?"=

10. Repeat 161og(l/e) times. (Trap the feasible solution.)

(a) For all i: transmit cw to all processors.
(b) For all i: receive sTOfrom all processors.
(c) If 1 is in the convex hull of s^s^s,, then goto FOUND.
that is feasible.)
(We have found a solution
?
=
= 1.
v
such
that
(d) Compute
sm) 0 and d*v
v^s,
=
Letv
(e)
v/||v||2._
?< vf(sj - 1 )< 0 then set sh= sm and goto ROUND.
(f) If
that is nearly feasible.)
(We have found a solution
- 1< 0
=
Else
if
then
ch cm and goto CONT.
(g)
)
v^s,
?
=
= 1.
v
that
such
(h) Compute
sm) 0 and dtv
v^s,,
=
Letv
(i)
v/||v||2._
- 1 < 0
? < y\sh
then set s{ = sm and goto ROUND.
)
(j) If
=
(k) Else let Cj cm.
=
(1) CONT: Let cm (c/+ c,)/||c/ + cj|2.
a new c that is 'midway' between
the two old c's.)
(This computes
11. ROUND: Compute 0 < X< 1 such that ||As, 4- (1- X)sh ||2= vtsl.
12. Transmit X, v^st, ct, ch to all processors.
13. STOP.
14. FOUND:
15. Transmit

=
Xh Xm,Xh such that Xtst + XmsmH-Xhsh
XhXm,Xh and c/5cm,ch to all processors.
Compute

1.

16. STOP.
Processor's

program?m\,n,riprice)

1:

Stage

1. Receive

p.

2. Construct

the ellipsoid

/ 2

x? =1/2

and Bf = Diagl ?,

2
?-,...,

Xy/r yjr

Jin

=
3. Repeat JVC
times.
[32r2 log(nr/(??))l
bundle for price p.)
consumption
(Compute an e-accurate
the gradient at x,.
(a) Compute
(b) Compute a new x{ and B using the ellipsoid method for solving L^x,, p).
=
(c) Let lmax max[/m?x, Lt{xh p)].
4.

Transmit

5. Goto

lmax.

1.

Resource

allocation

241

mechanisms

Stage 2:
1. Receive

c from center.

2. Construct

the ellipsoid

x,

/ 2

1/2 and Bf = DiagI ?-,

2
??,...,

\y/r yfr

3. Repeat Nc = [4r2 log(n/?3)] times.

the largest cfxf which
is an e-accurate
(Compute
for price p.)
=
(a) If Li(Xi, p) is sufficiently good then use v c.
=
v
(b) Else let
VLi(xi,p).
a new xt and B using v.
(c) Compute
4.

Transmit

5. Go

Jr/
bundle

consumption

x,.

to 1.

(Round x, to get a feasible solution.)

Receive X, \^sh eh eh from the center.
=
where xf(c) is computed as in the
xf
(Axf(C|)+ (1 X)Xi{c^\9
Compute
above loop.
STOP.
FOUND:
of xf(cz), xf(cm), and xf(ch).)
(Form xt as a convex combination
Receive Xh Xm, Xh and ch cm, eh from the center.
=
+ Amx,(cJ + Afcx?(cfc).
x? ^(c,)
Compute
STOP.

6. ROUND:
7.
8.
9.
10.
11.
12.
13.

Theorem4

For

any Se(0,e/n)

the two resource

price mechanism

ment(price)

has

complexity

=
TM

+ log(n/e))
+ / + ? log(n/8)]
log
^)[*(1

and will produce an e-accurate

solution with probability

greater

than 1? S.

Proof: The proof is given in the appendix.

case easily
resources
For multiple
the main
ideas for the two resources
we
have not completed
the construction
and proof for stage
generalize. However,
2 and leave this for future work.
Conjecture
complexity

1 For

any Se(0,e/n)

T=e[r*[ log
^

the r resource

price mechanism

m?n'r(price)

has

XI 1+ 1(^i/? + L + r* iog(n/e) )+ Ir2+ flr2 log(n/e)

n
n

and will produce an e-accurate

solution with probability

greater

than 1?

<5.

Proof (partial): The complexity

is computed assuming that stage 1 dominates
stage
2. The correctness of stage 1 is shown in the proof for the two resources case. The
of stage 2 is as yet incomplete, However, we believe that a method
construction
O
similar to that for two resources should work.

242

E. J. Friedman

Thus we have constructed

which

should be extendible

5 Resource

allocation

a polynomial-efficient
mechanism
to more than two resources.

and S. S. Oren

for two resources,

with externalities

In many instances the utility a processor derives from a certain bundle of resources
is dependent on the resources used by the other processors. Two classic examples
as the
of this are pollution and congestion. These are both negative externalities,
increased total use of resources reduces the processors derived utility.
are also possible.
Positive
externalities
For example
the usefulness
of a
network may depend on the number of people using it, assuming
communication
that it is operating below capacity. In this case ifmany people use the network then
more people are reachable on the network thus increasing its value. (See e.g. [27].)
in this paper we will only consider negative externalities, as they are the
However,
common in resource allocation and distributed computing.
To account for externalities, we modify our formulation
slightly, and assume
negative externalities of a simple and common form. We allow the utility functions
to depend on X? (A1,..., Xr)where Xj =
?"= Axj. So
n

most

U(x,X)=YUi(xi,X).
?=1

in X. Since A is a
decreasing
require that (7(x, X) is concave and monotonically
we
can
be less restrictive about the definition of X, by viewing
negative externality,
as
it
just another variable subject to Xj > E"= xx{, as the optimal solution will always
occur when the constraint is binding.
We can modify both the ellipsoid and descent mechanisms
quite simply, to solve
?
the resource allocation with externalities. We note that the transformation X= 1 X
us
to rewrite
allows

We

F =
jx|0<x,0<!,

X x/ + 2J'<ll

and note that F is equivalent to F with the addition of r new variables. Thus this
new problem is almost identical structurally to the problem without externalities.
allows them to solve the new problem
A slight modification
of these mechanisms
with negligible
loss of efficiency.
that solves the resource
In fact, any mechanism
(including the price mechanism)
can
to
solve the problem with externalities. Let Tie, r, n)
be used
allocation problem
mechanism
that solves the
be the time required by an arbitrary polynomial-efficient
resource allocation problem without externalities. Note that this time is unchanged
ifwe solve the generalized problem, but fix the externality effect to a certain level,
say X0 < 1. Letting
ViX)

maxUix,X)\X
xeF

X0

we can apply a modified

version of the ellipsoid method
us to show:
This
is
allows
that Vi)
convex.)

to maximize

ViX). (Note

Resource

allocation

243

mechanisms

5 Let men,r be an polynomial-efficient

mechanism for allocating
without externalities. Then there exists a related mechanism mEe'";rwhich
in
problem with externalities

Theorem

=
^externalities^ ^ ") ^

log(l/e)(T(?,

resources
solves the

r, n) + r))

where T(e, r, n) is the running time of m?'nr.

which can
Proof: There exists a modified
version of the ellipsoid mechanism
and 2r+ 1
iterations
maximize
V(X) over {X\0<Xj<
1/e)
only
log
using
(9(r2
1}
function values of V(X) with only 0(r2) computations
per iteration.
0(e4)-accurate
This is shown in [26]. Allowing
the center to use the algorithm shows that
Textenu,meJ<K:n

= r3
log(l/e)[T(?3,

r, n) + r]

to be polynomial-efficient
the mechanism
is assumed
it must have a
in
time
which
is
in
Therefore
the
e4
the
running
log 1/e.
polynomial
complexity can
be replaced by e as this can only change the running time by a multiplicative
= 3
D
constant, since log e"3
log e'1.
Thus externalities do not increase themechanism's
dependence on n significantly
and

or

since

decrease

its convergence

rate.

6 Conclusions
We have described a general framework for constructing and comparing mechanisms
a
resource allocation
for distributed
under bounded
rationality, and developed
rigorous computational model of resource allocation with realistic processors. This
are given
is in contrast to the large body of economic work where processors
unbounded
is much more
computational
ability. Also our measure of complexity
relevant than the standard definitions of complexity,
such as the size of message
this model we have still been able to design polynomial-efficient8
space. Using
for resource allocation and compute their efficiency.
mechanisms
Another major contribution
of our work is explicitly considering mechanisms
with a large number of processors. Many of the mechanisms
in the literature either
implicitly or explicitly apply to a very small group of processors, often two or three.
In contrast, we are interested inmechanisms
that apply to large or very large groups
this is an important distinction, as allocating
of processors. For resource allocation
resources
to a small group of processors
is relatively easy, and the differences
is probably unimportant.
between different mechanisms
to economic
Thus our major contribution
theory comes from raising these two
a methods
to
and number of processors,
and by developing
issues, computation
design mechanisms

in this framework.

are nearly optimal,

In fact, these mechanisms
in the sense that it is impossible
lower complexity.
This is discussed
in detail in [6].
significantly

have

for any mechanism

to

244

E. J. Friedman

A Appendix:

Proof

of Theorem

and S. S. Oren

we
In this section we give the proof of Theorem 4. For stage 1 of the mechanism
an
resources
as
the
number
is
for
of
this
cleaner
give
proof
arbitrary
notationally
and requires no extra effort. For stage 2 we explicitly consider the case of two
resources. In this part of the proof the argument requires this restriction. However,
we believe that this should generalize in a natural manner.
A.1

Stage

the basic concepts required by the proof and set some of the
[20] allows us to rewrite the
Duality
theory of convex programming
? 1.
Then let
in the following manner. Define s(x) = ?.x?

First we describe
notation.
problem

L(x,p)=i/(x)-pts(x)
then define
F(p)
which

is a convex

= max
X L(x, p)

function of p [20] and define x(p) to be the allocation

that achieves

the maximum.

over p of L(p) is
Now the basic theory of convex duality says that the minimum
is
if
the
to
maximum
of
the
the
allocation
Also,
p*
price that achieves
problem.
equal
then x(p*) = x* is the optimal allocation.
the maximum
for the allocation problem.
Using this we discover a natural distributed method
Define
L?(xi,p)=C/?(x)-pt(xi-l/n)
so that L(x, p) =
Define
?"= lLf(xf, p).
each processor to solve its own

Ff(p) similarly. Then

given a p we can allow

maxL^p).
Xi
can solve the low dimensional
Then a central processor
problem of finding the
of F(p).
minimum
is that of approximating
The first major difficulty which we must overcome
value
of F(p). Deterministically
the
functional
gradients with only information about
can
as
where the value of the
'kinks'
have many
the function
this is very difficult
if we choose the places to evaluate the
gradient can change abruptly. However,
we
a
can
of the gradient with
useful approximation
function at random, then
get
a
small number of query points.
only
Lemma 3 For any <5e(0,e) the procedure for approximating gradients
?
with probability greater than 1 a where a = <5/(4r2log 1/e).
Proof:

See [26].

is ?-accurate

Lemma 4 For any ?e(0, ?) the ellipsoid method

less than d.

in stage one will fail with probability

Resource

allocation

245

mechanisms

of error at each iteration is less than a. As there are

probability
r2 log(l/?) iterations, the probability of having a failure at any stage during the entire
= <5. O
process is less than r2 log(l/?)a
in the previous section, we can
the gradient computed by the method
Using
to
still
the
slightly
produce an ?-accurate answer. An
modify
ellipsoid algorithm
can
in
of
this
be
found
[28].
elementary description
Thus ifwe compute the values of F(p) to accuracy ?3 then the ellipsoid method
?
described above computes an ?-accurate solution p,x such that |F(p) F(p*)| <e
?
and |L(x(p), p) L(x, p)| < ?. Thus stage one can compute an ?-approximation
p to
to the actual value of F(p).
of F(p) and also an ?-approximation
the minimum
Thus we have shown:
The

Proof:

5 For any ?, stage

Lemma

1 produces

a p and x such that

\Fip)-Fif>*)\<e
and

|L(x,p)-F(p)|<^
and therefore

|F(p*)-L(x,p)|<2?
for ? <

1/2, with probability

greater

?
than 1

<5.

The first statement follows from the argument above on the accuracy of the
for computing
gradients. The
algorithm
ellipsoid method with the randomized
of x(p), and the third
second from the accuracy of the processor's own computation
from combining
the first two. O

Proof:

A.2

Stage 2
a feasible solution

In this section we construct

?2-accurate

G =

Gvx

combination

of several

of

solutions

maxc^x
X
where

as the convex

Gn

s.t. xeG

and

Gi={x|L(x?,p)-L(x,p)<4?}.
is computed using the ellipsoid method
by the individual
n
into
is
independent pieces.
separable
problem

This

Theorem

6 The computation

as the

of
max rfxt
X

to accuracy

processors

?2 can be accomplished

s.t. x^Gi

in r2 log(r/2?3)

iterations of the ellipsoid method.

Proof: Note
that Gf must contain the hypersphere
constant of L^x^p) is less than 1. This hypersphere

of radius ? as the Lipschitz

must contain a cube of side

E. J. Friedman

246

and S. S. Oren

and thus has volume greater than

The ellipsoid method
requires
2?/y/r
(2?/s/r)r.
an
convex
a
to
e-accurate
solution
in
feasible
compute
steps
region
r2log(l/(K1/re)
of volume V. O
Now we show that there exists a feasible solution in G. This will follow from a
sequence

of lemmas.
6 Given p is an ?2 accurate

Lemma

solution

there exists

of F(p),

a p' such that

\\p-pf\\2<?and\\W(p')\\2<?.
Proof:

Consider

the path generated

by

VF(y(t))

dy(t)

dt

s.t.

\\W(y(t))\

y(0)

which is a path from p to p* where t is the arc length of the path from y(0) to y(t).
Note that y (I) = p* where / is the length of the path y.
Now

=
F(p)-F(p*)= flVF(y(t)y^dt
f ||VF(7(t))\\2dt
dt
Jo
Jo
is just the line integral of VF.
?
F(p*) < e2. Thus
By assumption F(p)

which

f
as the integrand
Now assume

Jo

the following must

hold

l|VF(y(x))||2dy<?2

is non-negative.
that the theorem

is false. This

that for all x < ? we must

implies

?
have VF(y(x))
||
||2> ?as theEuclidean distance ||y(0) y(?) ||2 is less than thedistance
along

y. Since

Wmn2??<6
f

minJVF(y(x)

0<X<?

Jo

this implies that

Jo
f1

However,

the gradient

7 The feasibility

Lemma
Proof:

the theorem.

proving

This

follows

of F is related to feasibility.
? 1=
vector, s(p)
VF(p).

from the well know envelope

theorem,

dF(p) dF(p)

dp
Using
problem.

this we

|VF(y(x))||2dy>e:

show

dp

that a feasible

s(p)-l.

solution

exists

for the above

optimization

Resource

allocation

247

mechanisms

8 Given p is an e2 accurate solution

?
|L(x?, p) L(x? p)| < 4? and xf is feasible.

Lemma

of F(p),

there exists

an x? such that

?
From the previous
lemma there exists a p' such that ||s(p')
=
x
that is feasible and noting that
letting xj
xjip')/sjip') gives an

Proof:

1 ||2< e then

Hx-x(p')||2<2?
implies that
|L(xf(p'),p/)-L(x?,p)|<2?
by the Lipschitz
p we know that

constant

of L?. Now

by the Lipschitz

constant

of Ft for changing

|J\<P)-JW)|<?.
these inequalities produces the required result.
O
Combining
Now that we have shown that a G contains at least one feasible solution we will
describe how to construct one of these.

A.3 Constructing
The easiest way

a feasible

solution

to understand

the stage 2 algorithm

is to consider

the map

defined by
sf(0)

argmaxx.(cos0,

sin?^x,

s.t. xeG

and s(0) =
Note that in the mechanism we work directly with c = (cos 0, sin 0)
Xis;(f3).
instead of 0. For the purposes of the proof it ismuch clearer to work in 0 directly.
The mechanism
works in the following manner. The feasible point 1 must lie
on one side of the line between sz and sh.We choose 0m such that sm is on the same
side of the line that 1 is. Now
these three points create three possible regions in
can
1
lie.
which
(See figure 4.) If the point lies in the convex hull of s/5 sh, sTO(region I)
then we stop. Also if the point lies close to one of the lines sjs^ or sfcsm then we also
if the point lies in one of the remaining regions (regions II or III)
the two points that define that region to be our new 0, and 0h and
continue the process.
In order to prove that the mechanism
constructs a feasible solution we note that
Stage 2 actually performs a binary search in 0, and the only ways it can halt are:
stop. However
then we choose

1. A feasible solution x is found as the convex combination

2. A solution x with ||s(x) ? 1 ||2 is the convex combination
3.

of 3 points xh xm, xh.

of two points xh xh.

0l-0h<2n/e.

of
the following
lemma shows that the convex combination
gives a feasible solution that is ?-accurate.
?
Lemma 9 Let u,v,w
that
all satisfy
{resp. v,w). Assume
|L(u,p) F(p)| <4?
<
x = Xuu+ Xvv+ Xwwwith 0 < Xu, Xv, Xwand Xu+ Xv+ Xw= ?. Then L(x,
4?.
\
p) F(p) |
In the first case

Xj, xm, xh which

248

E. J. Friedman

si

sh
Figure

Proof:

By convexity

and S. S. Oren

5. Accuracy

of stage 2

of L we have that L(x, p) < max [L(u, p), L(v, p), L(w, p)]. However

by definition F(p) > L(x, p). O

lemma we see that for case 2 we can simply round the solution

From the previous

to feasibility.
10 In case

Lemma

two the allocation

defined

=
by xj
xj/sj(x)

satisfies

|L(x,p)

F(p)|<2e.
? x
? 1 < e.
that x, is feasible. Also
Thus by the
||x'
||2< e as ||s(x)
||2
we
L
O
the
result.
of
desired
get
Lipschitz continuity
Now we will show that case 3 is actually equivalent to case 2 as |0,? 9h\ < 2ne
of x(0?) and
implies that there exists a solution x which is the convex combination

Proof:

Note

x(??)and||s(x)-T||2<e.
Lemma 11 Assume that the center's stage 2 algorithm received the exact solution
?
then 1 must be within ? of the line s?s?.
s(0) at each iteration. Then if \9l 9h\<e
Proof: This follows from elementary geometry and the fact that the feasible solution
1must be contained
in the region bounded by s?s?~by construction. Also we know
that c(9l)ifsl > c(9?f 1 and c(0m)fsm > c^)1" 1 as these (shsh) are the respective
maxima of their respective c's. This region forms a triangle with angle a = n ? ? as
?=\9h-9l\.(Seengure5.)
Since we know that ||Sj? sh \\2< 2 the height of the triangle must be less than 2
sin e/2 which is less than e. Thus as the point 1 is contained within this triangle, we
see that the distance from 1 to s^ must be less than e. O
the center does not receive exact solutions from the processors. The
However,
solutions from the processors are only accurate to ?2. In fact the solutions s(0) can
as the next lemma shows,
be arbitrarily far from the true solutions s(0). However,
these solutions are actually close to the real solution for a slightly different 9. Thus
we can imagine that the values of 9 ave uncertain. However,
this does not effect the
binary search if these errors in 9 are less than e.
?
12 Assume
Then
that Ic^^s
s(0))| <e2.
<
s
e.
2ne
and
2
||
\9-9'\<
s(0') ||
?
Proof: As |c(0)f(s
s(0))| < e2 we see that there exists
Let y(x) be the boundary of the feasible region with
assume that y is parametrized
by arc length.
now
show that there exists a ff such that &
We will
|

Lemma

Combining

these inequalities

produces

the theorem.

there exists

a 9' such

that

a ? such that ||s ? s(?) ||2< ?.

=
=
s(0) and y(t)
s(f) and
y(0)
9 <
\ ewhile

||s(0')

s(f) ||2< ?.

Resource

First note
Note

249

mechanisms

allocation

that at s(0) the normal

to ymust

point

in the direction

defined

by 0.

that
r*(?)

c(0)t(s(0)-s(jS))=

Jo

r*(?)

tan(0(u)-0)dt/<

Jo

2/*(0(ii) 0)du

where x(j?) is the smallest x such that 0(x) < ?.

?
Now assume the lemma is false and all 0(x) for |x x(i)|
therefore

|0(x)

satisfy

0| > ?,

c(0)t(s(0(x))-s(0))>?2
However

by the previous equation.

O
proving the lemma.
Thus

the algorithm works

the fact that s is ?2-accurate

this contradicts

even with

the inexact replies given by the processors.

D

References
1. Arrow,
Essays

K., Hurwicz,
in economics

in resource allocation.
and computation
In: Pfouts, R. (ed.)
Hill: University
of North Carolina
1960
Press,
over the reals (or an arbitrary
of computation
and complexity
ring).

L.: Decentralization

and econometrics.

Chapel

2. Blum, L.: Lectures on a theory

Technical
International
Report TR-89-065,

Computer

Science

Institute,

CA, December

Perkeley,

1989
over the real numbers:
3. Blum, L., Shub, M,
Smale, S.: On a theory of computation
Bull. ACM 21, 1-46 (1988)
recursive functions,
and universal machines.
4. Ecker, J. G., Kupfershmid,
for nonlinear
J.: The ellipsoid algorithm
programming.

JVP-completeness,
Math.

Prog.

27,

83-106(1983)
5. Ferguson,
D. W., Nikolau,
C, Yemini, Y.: Microeconomic
of the 8th International
buted computer
systems. Proceedings
1988
Systems,

algorithms
Conference

for load balancing

in distri
on Distributed
Computing

resources
In:
in parallel: upper and lower bounds.
E. J.: The complexity
of allocating
in numerical
Scientific
1993
P. (ed.) Complexity
optimization.
Singapore: World
with
for convex
combinatorial
7. Friedman,
E. J.: A strongly
programs
algorithm
polynomial
Technical
constraints
and resource allocation.
report UCB/ERL/IGCT
M92/6,
Interdisciplinary

6. Friedman,
Pardalos,

on Coordination
Electronics
of California,
Research
Laboratory,
Theory,
University
1992
Berkeley, CA 94720, January
for the allocation
and other nonlinear
D. S.: Lower
and upper bounds
8. Hochbaum,
problem
and Industrial Engineering
School of Business Administration
optimization
problems. Manuscript,
Group

and Operations
Research,
1990
December

University

of California,

Berkeley,

CA

94720.

September

1989, Revised

1988
Amsterdam:
North Holland
9. Huberman,
B.: The ecology of computation.
Am. Econ. Rev. 1-30 (1973)
for resource allocation.
10. Hurwicz,
L.: The design of mechanisms
and efficiency
in resource allocation mechanism.
L.: On informational
decentralization
11. Hurwicz,
Association
economics. Washington
D.C.: Mathematical
in mathematical
Reiter, S. (ed.) Studies
America

1986

12. Hurwicz,
L.: On
and organization.

informationally
Minneapolis:
the dimensional

decentralized
University

C. B., Radner,
systems. In:McGuire,
of Minnesota
Press 1986

R. (ed.) Decision

decentralized
of informationally
pareto satisfactory
requirements
L. (ed.) Studies
in resource allocation
In: Arrow, K. J., Hurwicz,
processes.
processes.
Press 1977
New York: Cambridge
Cambridge,
University
for resource
dimensional
T.: Discrete
allocation mechanisms:
14. Hurwicz,
L., Marschak,
requirements
are unbounded.
J. Complexity
when the desired outcomes
allocation mechanisms
1,264-303
(1985)
13. Hurwicz,

adjustment

L.: On

In:
of

250

and S. S. Oren

E. J. Friedman

15. Ibaraki, T., Katoh, K: Resource

16. Khachian,
L. G.: A polynomial

allocation

problems:
algorithmic
for linear programming.

algorithm

MIT Press 1988

approaches.
Sov. Math. Doklady
20, 191-4

(1979)
to optimal
resource allocation
in distributed
J. F., Simha, R.: A microeconomic
approach
systems. IEEE Trans. Comp. 38, 705-16
(1989)
to parallel algorithms
1991
18. Leighton,
F. T.: Introduction
and architectures.
Morgan-Kaufman
convex functions.
Sov. Maths.
19. Levin, A. Yu.: On an algorithm
for minimizing
1,286-90
(1965)
2nd edn. Reading, Massachusetts:
Addison
20. Luenberger,
D. G.: Linear and nonlinear
programming,
17. Kurose,

computer

Wesley Publishing Company 1984

In: Arrow,
design.
York. North-Holland

21. Marschak,
T. A.: Organizational
economics.
New
mathematical
22. Megiddo,

N.: Towards

a genuinely

polynomial

M. D.

K. J., Intrilligator,
1986

algorithm

(eds.) Handbook

for linear programming.

Siam

of

J. Comp.

12, 347-59 (1983)

of a locally stable dynamic
K., Reiter, S.: The existence
process with a statically minimal
and economic
incentives,
T., Radner, R., Reiter, S. (eds.) Information,
message
space. In: Groves,
of Minnesota
Press 1987
mechanisms:
essays in honor of Leonid Hurwicz. Minneapolis:
University

23. Mount,

size of message
spaces. J. Econ. Theory 8,161-192
(1974)
1990. Discussion
with
human
of
K., Reiter,
agents
Paper No. 890.
computing
Northwestern
for Mathematical
Graduate
School of Management,
Center
J.L. Kellogg
Studies,
Ilinois 60208
Evanston,
University,
New
in optimization.
26. Nemirovsky,
A. S., Yudin, D. B.: Problem
and method
efficiency
complexity

24. Mount,
25. Mount,

S.: The

K., Reiter,

informational

S.: A model

York:Wiley 1983
27. Oren,

S. S., Smith,

S.: Critical

mass

and

tariffs in electronics

communication

markets.

J. Econ.

Bell

12,467-487(1981)
K.: Combinatorial
C. H., Steiglitz,
optimization:
Inc. 1982
Cliffs, New Jersey: Prentice-Hall,
Englewood
information
of decentralized
29. Radner, R.: The organization
processing.
28. Papadimitriou,

algorithms

and

Econometrica

complexity.

61,1109-1146

(1993)
R. T.: Convex
30. Rockafellar,
E.: Do
31. Russell, S., Wefald,
32. Sanders,
networks.

B.: An

incentive

Press 1970
New Jersey: Princeton
University
analysis. Princeton,
1991
Boston: MIT Press,
the right thing: studies in limited rationality.
for rate allocation
in computer
flow control
algorithm
compatible

IEEE Trans.

(1988)
Comp. 37,1062-72
33. Sanders, B.: A private good/public
queue. IEEE Trans.
good for optimal flow control of an m/m/1
Autom. Contr. 30,1143-5
(1985)
for
for the transistor sizing problem
34. Sapetnekar,
S., Rao, V., Vaidya, P., Kang, S.: An exact solution
cmos circuits using convex optimization.
1992
Mimeo
35. Scarf, H.: Some

examples

of global

instability

of the competitive

equilibria.

Int. Econ.

Rev.

1,157-72

(1960)
with selfish users. In: King, P. J. B., Mitrani,
allocations
36. Shenker, S.: Efficient network
I., Pooley,
1990
R. J. (eds.) Performance
'90, pp. 279-285. New York: North-Holland
and
In: McGuire,
C. B., Radner, R. (eds.) Decision
of bounded
37. Simon, H. A.: Theories
rationality.
Press 1986
of Minnesota
University
Minneapolis:
organization.
38. Smale,

S.: A convergent

process

of price

adjustment

and global

newton

methods.

J. Math.

Econ.

3,107-20(1976)
convex functions over convex sets. In: 30th Annual
P. M.: A new algorithm
for minimizing
1989
on the Foundations
of Computer
IEEE, October
Science, pp. 332-337.
Symposium
W.
W.
1978
York:
New
40. Var?an, H. R.: Microeconomic
Norton,
analysis.
39. Vaidya,