Nash

Equilibria

in

Graphical

Games

on

Trees

Revisited

Edith

Elkind

University

of

Warwick

Coventry,

U.K.

Leslie

Ann

Goldberg

University

of

Warwick

Coventry,

U.K.

Paul

Goldberg

University

of

Warwick

Coventry,

U.K.

ABSTRACT

Graphical

games

have

been

proposed

as

a

game-theoretic

model

of

large-scale

distributed

networks

of

non-cooperative

agents.

When

the

number

of

players

is

large,

and

the

underlying

graph

has

low

degree,

they

provide

a

concise

way

to

represent

the

players"

payoffs.

It

has

recently

been

shown

that

the

problem

of

finding

Nash

equilibria

in

a

general

graphical

game

with

two

actions

per

player

is

complete

for

the

complexity

class

PPAD,

indicating

that

it

is

unlikely

that

there

is

any

polynomial-time

algorithm

for

this

problem.

In

this

paper,

we

study

the

complexity

of

graphical

games

with

two

actions

per

player

on

bounded-degree

trees.

This

setting

was

first

considered

by

Kearns,

Littman

and

Singh,

who

proposed

a

dynamic

programming-based

algorithm

that

computes

all

Nash

equilibria

of

such

games.

The

running

time

of

their

algorithm

is

exponential,

though

approximate

equilibria

can

be

computed

efficiently.

Later,

Littman,

Kearns

and

Singh

proposed

a

modification

to

this

algorithm

that

can

find

a

single

Nash

equilibrium

in

polynomial

time.

We

show

that

this

modified

algorithm

is

incorrect

the

output

is

not

always

a

Nash

equilibrium.

We

then

propose

a

new

algorithm

that

is

based

on

the

ideas

of

Kearns

et

al.

and

computes

all

Nash

equilibria

in

quadratic

time

if

the

input

graph

is

a

path,

and

in

polynomial

time

if

it

is

an

arbitrary

graph

of

maximum

degree

Moreover,

our

algorithm

can

be

used

to

compute

Nash

equilibria

of

graphical

games

on

arbitrary

trees,

but

the

running

time

can

be

exponential,

even

when

the

tree

has

bounded

degree.

We

show

that

this

is

inevitable

any

algorithm

of

this

type

will

take

exponential

time,

even

on

bounded-degree

trees

with

pathwidth

It

is

an

open

question

whether

our

algorithm

runs

in

polynomial

time

on

graphs

with

pathwidth

but

we

show

that

finding

a

Nash

equilibrium

for

a

graphical

game

in

which

the

underlying

graph

has

maximum

degree

and

constant

pathwidth

is

PPAD-complete

(so

is

unlikely

to

be

tractable).

Categories

and

Subject

Descriptors

[Theory

of

Computation]:

Analysis

of

Algorithms

and

Problem

Complexity;

[Computer

Applications]:

Social

and

Behavioral

Sciences-economics

General

Terms

Algorithms,

Economics,

Theory

INTRODUCTION

Graphical

games

were

introduced

in

the

papers

of

Kearns

et

al.

and

Littman

et

al.

as

a

succinct

representation

of

games

with

a

large

number

of

players.

The

classical

normal

form

(or

matrix

form)

representation

has

a

size

that

is

exponential

in

the

number

of

players,

making

it

unsuitable

for

large-scale

distributed

games.

A

graphical

game

associates

each

player

with

a

vertex

of

an

underlying

graph

G,

and

the

payoff

to

that

player

is

a

function

of

the

actions

chosen

by

himself

and

his

neighbours

in

G;

if

G

has

low

degree,

this

is

a

concise

way

to

represent

a

game

with

many

players.

The

papers

give

a

dynamic-programming

algorithm

for

finding

Nash

equilibria

in

graphical

games

where

there

are

two

actions

per

player

and

G

is

a

tree.

The

first

of

these

papers

describes

a

generic

algorithm

for

this

problem

that

can

be

specialized

in

two

ways:

as

an

algorithm

that

computes

approximations

to

all

Nash

equilibria

in

time

polynomial

in

the

input

size

and

the

approximation

quality,

or

as

an

exponential-time

algorithm

that

allows

the

exact

computation

of

all

Nash

equilibria

in

G.

In

the

authors

propose

a

modification

to

the

latter

algorithm

that

aims

to

find

a

single

Nash

equilibrium

in

polynomial

time.

This

does

not

quite

work,

as

we

show

in

Section

though

it

introduces

a

useful

idea.

Background

The

generic

algorithm

of

consists

of

two

phases

which

we

will

refer

to

as

the

upstream

pass

and

the

downstream

pass;

the

former

starts

at

the

leaves

of

the

tree

and

ends

at

the

root,

while

the

latter

starts

at

the

root

and

ends

at

the

leaves.

It

is

assumed

that

each

player

has

two

pure

strategies

(actions),

which

are

denoted

by

and

it

follows

that

any

mixed

strategy

can

be

represented

as

a

single

number

x

where

x

is

the

probability

that

the

player

selects

During

the

upstream

pass,

each

vertex

V

computes

the

set

of

its

potential

best

responses

to

every

mixed

strategy

w

of

its

parent

W

a

strategy

v

is

a

potential

best

response

to

w

if

Note

that

the

terminology

upstream

and

downstream

are

reversed

in

our

trees

are

rooted

at

the

top.

there

is

a

Nash

equilibrium

in

the

graphical

game

downstream

of

V

(inclusive)

given

that

W

plays

w

(for

a

more

technical

definition,

the

reader

is

referred

to

Section

The

output

of

this

stage

can

be

viewed

as

a

(continuous)

table

T(w,

v),

where

T(w,

v)

if

and

only

if

v

is

a

potential

best

response

to

w;

we

refer

to

this

table

as

the

best

response

policy

for

V

The

generic

algorithm

does

not

address

the

problem

of

representing

the

best

response

policy;

in

fact,

the

most

important

difference

between

the

two

instantiations

of

the

generic

algorithm

described

in

is

in

their

approach

to

this

issue.

The

computation

is

performed

inductively:

the

best

response

policy

for

V

is

computed

based

on

the

best

response

policies

of

V

"s

children

Uk.

By

the

end

of

the

upstream

pass,

all

children

of

the

root

have

computed

their

best

response

policies.

In

the

beginning

of

the

downstream

pass,

the

root

selects

its

strategy

and

informs

its

children

about

its

choice.

It

also

selects

a

strategy

for

each

child.

A

necessary

and

sufficient

condition

for

the

algorithm

to

proceed

is

that

the

strategy

of

the

root

is

a

best

response

to

the

strategies

of

its

children

and,

for

each

child,

the

chosen

strategy

is

one

of

the

pre-computed

potential

best

responses

to

the

chosen

strategy

of

the

root.

The

equilibrium

then

propagates

downstream,

with

each

vertex

selecting

its

children"s

actions.

The

action

of

the

child

is

chosen

to

be

any

strategy

from

the

pre-computed

potential

best

responses

to

the

chosen

strategy

of

the

parent.

To

bound

the

running

time

of

this

algorithm,

the

paper

shows

that

any

best

response

policy

can

be

represented

as

a

union

of

an

exponential

number

of

rectangles;

the

polynomial

time

approximation

algorithm

is

obtained

by

combining

this

representation

with

a

polynomial-sized

grid.

The

main

idea

of

is

that

it

is

not

necessary

to

keep

track

of

all

rectangles

in

the

best

response

policies;

rather,

at

each

step

of

the

upstream

pass,

it

is

possible

to

select

a

polynomial-size

subset

of

the

corresponding

policy

(in

this

subset

is

called

a

breakpoint

policy),

and

still

ensure

that

the

downstream

pass

can

proceed

successfully

(a

sufficient

condition

for

this

is

that

the

subset

of

the

best

response

policy

for

V

stored

by

the

algorithm

contains

a

continuous

path

from

w

to

w

Our

Results

One

of

the

main

contributions

of

our

paper

is

to

show

that

the

algorithm

proposed

by

is

incorrect.

In

Section

we

describe

a

simple

example

for

which

the

algorithm

of

outputs

a

vector

of

strategies

that

does

not

constitute

a

Nash

equilibrium

of

the

underlying

game.

In

Sections

and

we

show

how

to

fix

the

algorithm

of

so

that

it

always

produces

correct

output.

Section

considers

the

case

in

which

the

underlying

graph

is

a

path

of

length

n.

For

this

case,

we

show

that

the

number

of

rectangles

in

each

of

the

best

response

policies

is

This

gives

us

an

algorithm

for

finding

a

Nash

equilibrium,

and

for

computing

a

representation

of

all

Nash

equilibria.

(This

algorithm

is

a

special

case

of

the

generic

algorithm

of

we

show

that

it

runs

in

polynomial

time

when

the

underlying

graph

is

a

path.)

We

can

improve

the

running

time

of

the

generic

algorithm

using

the

ideas

of

In

particular,

we

give

an

algorithm

for

finding

a

Nash

equilibrium

of

a

graphical

game

on

a

path

of

length

n.

Instead

of

storing

best

response

policies,

this

algorithm

stores

appropriately-defined

subsets,

which,

following

we

call

breakpoint

policies

(modifying

the

definition

as

necessary).

We

obtain

the

following

theorem

THEOREM

There

is

an

algorithm

that

finds

a

Nash

equilibrium

of

a

graphical

game

with

two

actions

per

player

on

an

n-vertex

path.

There

is

an

algorithm

that

computes

a

representation

of

all

Nash

equilibria

of

such

a

game.

In

Section

we

extend

the

results

of

Section

to

general

graphs,

obtaining

the

following

theorem.

THEOREM

There

is

a

polynomial-time

algorithm

that

finds

a

Nash

equilibrium

of

a

graphical

game

with

two

actions

per

player

on

a

graph

with

maximum

degree

In

Section

we

extend

our

algorithm

so

that

it

can

be

used

to

find

a

Nash

equilibrium

of

a

graphical

game

on

an

arbitrary

tree.

Even

when

the

tree

has

bounded

degree,

the

running

time

can

be

exponential.

We

show

that

this

is

inevitable

by

constructing

a

family

of

graphical

games

on

bounded-degree

trees

for

which

best

response

policies

of

some

of

the

vertices

have

exponential

size,

and

any

twopass

algorithm

(i.e.,

an

algorithm

that

is

similar

in

spirit

to

that

of

has

to

store

almost

all

points

of

the

best

response

policies.

In

particular,

we

show

the

following.

THEOREM

There

is

an

infinite

family

of

graphical

games

on

bounded-degree

trees

with

pathwidth

such

that

any

two-pass

algorithm

for

finding

Nash

equilibria

on

these

trees

requires

exponential

time

and

space.

It

is

interesting

to

note

that

the

trees

used

in

the

proof

of

Theorem

have

pathwidth

that

is,

they

are

very

close

to

being

paths.

It

is

an

open

question

whether

our

algorithm

runs

in

polynomial

time

for

graphs

of

pathwidth

This

question

can

be

viewed

as

a

generalization

of

a

very

natural

computational

geometry

problem

we

describe

it

in

more

detail

in

Section

In

Section

we

give

a

complexity-theoretic

intractability

result

for

the

problem

of

finding

a

Nash

equilibrium

of

a

graphical

game

on

a

graph

with

small

pathwidth.

We

prove

the

following

theorem.

THEOREM

Consider

the

problem

of

finding

a

Nash

equilibrium

for

a

graphical

game

in

which

the

underlying

graph

has

maximum

degree

and

pathwidth

k.

There

is

a

constant

k

such

that

this

problem

is

PPAD-complete.

Theorem

limits

the

extent

to

which

we

can

exploit

path-like

properties

of

the

underlying

graph,

in

order

to

find

Nash

equilibria.

To

prove

Theorem

we

use

recent

PPAD-completeness

results

for

games,

in

particular

the

papers

which

show

that

the

problem

of

finding

Nash

equilibria

in

graphical

games

of

degree

d

(for

d

is

computationally

equivalent

to

the

problem

of

solving

r-player

normal-form

games

(for

r

both

of

which

are

PPAD-complete.

PRELIMINARIES

AND

NOTATION

We

consider

graphical

games

in

which

the

underlying

graph

G

is

an

n-vertex

tree.

Each

vertex

has

two

actions,

which

are

denoted

by

and

A

mixed

strategy

is

given

by

a

single

number

x

which

denotes

the

probability

that

the

player

selects

action

Fur

the

purposes

of

the

algorithm,

the

tree

is

rooted

arbitrarily.

For

convenience,

we

assume

without

loss

of

generality

that

the

root

has

a

single

child,

and

that

its

payoff

is

independent

of

the

action

chosen

by

the

child.

This

can

be

achieved

by

first

choosing

an

arbitrary

root

of

the

tree,

and

then

adding

a

dummy

parent

of

this

root,

giving

the

new

parent

a

constant

payoff

function.

Given

an

edge

(V,

W

of

the

tree

G,

and

a

mixed

strategy

w

for

W

let

G(V,W

),W

=w

be

the

instance

obtained

from

G

by

deleting

all

nodes

Z

which

are

separated

from

V

by

W

(i.e.,

all

nodes

Z

such

that

the

path

from

Z

to

V

passes

through

W

and

restricting

the

instance

so

that

W

is

required

to

play

mixed

strategy

w.

Definition

Suppose

that

(V,

W

is

an

edge

of

the

tree,

that

v

is

a

mixed

strategy

for

V

and

that

w

is

a

mixed

strategy

for

W

We

say

that

v

is

a

potential

best

response

to

w

(denoted

by

v

pbrV

(w))

if

there

is

an

equilibrium

in

the

instance

G(V,W

),W

=w

in

which

V

has

mixed

strategy

v.

We

define

the

best

response

policy

for

V

given

W

as

B(W,

V

{(w,

v)

v

pbrV

(w),

w

Typically,

W

is

the

parent

of

V

and

this

is

just

referred

to

as

the

best

response

policy

for

V

The

expression

B(W,

V

)|V

=v

is

used

to

denote

the

set

B(W,

V

The

upstream

pass

of

the

generic

algorithm

of

computes

the

best

response

policy

for

V

for

every

node

V

other

than

the

root.

With

the

above

assumptions

about

the

root,

the

downstream

pass

is

straightforward:

Let

W

denote

the

root

and

V

denote

its

child.

The

root

selects

any

pair

(w,

v)

from

B(W,

V

It

decides

to

play

mixed

strategy

w

and

it

instructs

V

to

play

mixed

strategy

v.

The

remainder

of

the

downward

pass

is

recursive.

When

a

node

V

is

instructed

by

its

parent

to

adopt

mixed

strategy

v,

it

does

the

following

for

each

child

U

It

finds

a

pair

(v,

u)

B(V,

U)

(with

the

same

v

value

that

it

was

given

by

its

parent)

and

instructs

U

to

play

u.

ALGORITHM

OF

LITTMAN

ET

AL.

The

algorithm

of

is

based

on

the

following

observation:

to

compute

a

single

Nash

equilibrium

by

a

two-pass

algorithm,

it

is

not

necessary

to

construct

the

entire

best

response

policy

for

each

vertex.

As

long

as,

at

each

step

of

the

downstream

pass,

the

vertex

under

consideration

can

select

a

vector

of

strategies

for

all

its

children

so

that

each

child"s

strategy

is

a

potential

best

response

to

the

parent"s

strategy,

the

algorithm

succeeds

in

producing

a

Nash

equilibrium.

This

can

be

achieved

if,

at

the

beginning

of

the

downstream

pass,

we

have

a

data

structure

in

which

each

vertex

V

with

parent

W

stores

a

set

ˆB(W,

V

B(W,

V

(called

a

breakpoint

policy)

which

covers

every

possible

w

We

will

show

later

that

a

sufficient

condition

for

the

construction

of

such

a

data

structure

is

the

invariant

that,

at

every

level

of

the

upstream

pass,

ˆB(W,

V

contains

a

continuous

path

from

w

to

w

In

it

is

suggested

that

we

can

select

the

breakpoint

policy

in

a

particular

way.

Namely,

the

paper

uses

the

following

definition:

Definition

(cf.

A

breakpoint

policy

for

a

node

V

with

parent

W

consists

of

an

ordered

set

of

W

-breakpoints

wt

and

an

associated

set

of

V

-values

vt.

The

interpretation

is

that

for

any

w

if

w

wi

for

some

index

i

and

W

plays

w,

then

V

shall

play

vi;

and

if

w

wi

for

some

index

i,

then

V

shall

play

any

value

between

vi

and

We

say

such

a

breakpoint

policy

has

t

breakpoints.

The

paper

then

claims

that

any

vertex

V

can

compute

its

breakpoint

policy

with

respect

to

its

parent

W

given

the

breakpoint

policies

of

its

children

Uk.

The

proof

proceeds

by

ordering

the

children"s

breakpoints

(i.e.,

the

respective

values

of

v)

from

left

to

right

(it

can

be

assumed

without

loss

of

generality

that

all

these

breakpoints

are

distinct)

and

considering

them

in

turn;

each

such

point

vl

vL}

corresponds

to

a

fixed

choice

of

strategies

for

k

children

and

an

interval

of

admissible

strategies

for

one

child.

Assume

for

convenience

that

this

child

is

and

its

interval

of

admissible

strategies

at

vl

is

[a,

b];

assume

also

that

for

Uj

j

k,

their

respective

breakpoint

policies

prescribe

them

to

play

uj

in

response

to

vl.

Let

P

i

(u,

w),

i

be

the

expected

payoff

for

V

when

V

plays

i,

plays

u,

each

Uj

j

k,

plays

uj,

and

W

plays

w,

and

consider

the

set

Wl

{w

∃u

[a,

b]

s.t.

P

(u,

w)

(u,

w)};

note

that

for

any

w

Wl

we

have

vl

pbrV

(w).

V

W

Figure

LKS:

Trimming

to

find

breakpoint

policies.

The

authors

show

that

for

any

breakpoint

vl,

the

set

Wl

is

either

empty,

a

single

interval,

or

a

union

of

two

non-floating

intervals

(an

interval

is

non-floating

if

one

of

its

endpoints

is

or

moreover,

the

union

of

all

sets

Wl,

l

L,

covers

the

interval

It

follows

easily

that

one

can

cover

with

at

most

intervals,

each

of

which

is

a

subset

of

some

Wl.

The

authors

then

claim

that

any

such

cover

can

be

transformed

into

a

breakpoint

policy

for

V

Namely,

they

say

that

for

any

two

intervals

and

in

the

cover,

Any

overlap

between

and

can

be

arbitrarily

assigned

coverage

by

and

trimmed

accordingly

(cf.

p.

They

illustrate

their

approach

in

a

figure,

which

is

reproduced

as

Figure

here.

In

the

figure,

the

dashed

horizontal

lines

represent

the

breakpoints

and

the

solid

intervals

along

these

breakpoints

are

the

sets

The

thick

connected

path

is

the

corresponding

breakpoint

policy.

It

is

chosen

as

follows:

begin

on

the

left,

and

always

jump

to

the

interval

allowing

greatest

progress

to

the

right.

To

see

why

this

approach

does

not

work

in

general,

consider

a

path

of

length

consisting

of

an

indifferent

root

R,

its

child

W

W

"s

child

V

and

V

"s

child

U.

Suppose

that

U

receives

a

payoff

of

if

it

plays

differently

to

V

and

otherwise.

Thus,

if

v

denotes

the

mixed

strategy

of

V

(i.e.,

V

plays

with

probability

v),

then

the

expected

payoff

that

U

derives

from

playing

is

given

by

(U)

v

and

the

expected

payoff

that

U

derives

from

playing

is

given

by

(U)

v.

Suppose

that

V

derives

no

payoff

from

playing

(so

(V

and

that

its

payoff

matrix

for

playing

is

−9

−1

so

if

u

denotes

the

mixed

strategy

of

U

and

w

denotes

the

mixed

strategy

of

W

the

expected

payoff

that

V

derives

from

playing

is

given

by

(V

w)

Using

the

techniques

of

(or,

alternatively,

those

of

Section

it

is

not

hard

to

verify

that

the

best

response

policies

for

U

and

V

(as

in

Definition

are

given

by

the

graphs

in

Figure

The

best

response

policy

for

U

is

a

breakpoint

policy

for

U

(as

in

Definition

with

V

-breakpoints

and

with

associated

values

and

The

best

response

policy

for

V

is

not

a

breakpoint

policy

(because

of

how

the

curve

from

w

to

w

doubles

back).

The

LKS

algorithm

would

trim

to

get

a

breakpoint

policy

such

as

the

one

in

Figure

Note

that

this

breakpoint

policy

ˆB(W,

V

is

invalid

in

the

sense

that

it

does

not

satisfy

ˆB(W,

V

B(W,

V

u

v

v

w

Figure

Best

response

policies

for

U

and

V

v

w

Figure

A

trimmed

policy

for

V

The

point

is

that

the

payoff

matrix

of

W

can

now

be

chosen

to

prevent

the

LKS

algorithm

from

finding

a

Nash

equilibrium.

For

example,

suppose

the

payoffs

are

given

so

that

(W

v

and

(W

The

best

response

policy

for

W

is

a

horizontal

line

at

w

(This

is

the

value

of

w

that

allows

v

see

Figure

which

makes

(W

(W

In

the

downward

pass,

the

chosen

values

are

w

then,

from

the

trimming,

v

and

u

which

is

not

a

Nash

equilibrium

since

W

prefers

action

The

failure

of

the

algorithm

is

not

caused

by

the

fact

that

the

trimming

policy

goes

as

far

to

the

right

as

possible.

Any

other

trimming

would

be

just

as

bad.

For

example,

suppose

the

breakpoint

policy

for

V

has

v

until

some

point

w∗

and

then

jumps

to

v

The

algorithm

is

then

defeated

by

the

payoff

matrix

with

P

(W

and

(W

v)

in

which

the

best

response

policy

for

W

is

a

horizontal

line

at

w

The

algorithm

then

gives

w

v

and

u

which

is

not

a

Nash

equilibrium

since

W

prefers

action

We

conclude

that

the

LKS

algorithm

does

not

always

find

a

Nash

equilibrium.

In

Sections

and

we

show

how

to

modify

the

algorithm

so

that

it

always

finds

a

Nash

equilibrium.

For

the

modified

algorithm,

we

have

to

extend

the

definition

of

breakpoint

policy

(see

Definition

so

that

it

includes

breakpoint

policies

such

as

the

best

response

policy

for

V

in

Figure

Unfortunately,

such

a

breakpoint

policy

may

be

exponential

in

size

(see

Figure

so

the

corrected

algorithm

does

not

run

in

polynomial

time

on

all

trees.

In

the

next

section,

we

show

that

it

runs

in

polynomial

time

on

a

path.

FINDING

EQUILIBRIA

ON

A

PATH

In

this

section,

we

focus

on

the

case

when

the

underlying

graph

is

a

path,

i.e.,

its

vertex

set

is

Vn},

and

its

edge

set

is

{(Vj

j

n

We

show

that

in

this

case

the

best

response

policy

for

each

vertex

can

be

represented

as

a

union

of

a

polynomial

number

of

rectangles,

where

a

rectangle

is

defined

by

a

pair

of

closed

intervals

(IV

IU

and

consists

of

all

points

in

IV

IU

it

may

be

the

case

that

one

or

both

of

the

intervals

IV

and

IU

consists

of

a

single

point.

THEOREM

For

any

j

n,

the

set

B(Vj

can

be

represented

as

a

disjoint

union

of

at

most

(j

rectangles.

Moreover,

given

such

representation

of

B(Vj

one

can

compute

a

representation

of

Vj)

in

time

PROOF.

For

any

set

A

that

is

represented

as

a

union

of

a

finite

number

of

rectangles,

we

say

that

a

point

u

on

the

U-axis

is

a

U-event

point

of

A

if

u

or

u

or

A

contains

a

rectangle

of

the

form

IV

IU

and

u

is

an

endpoint

of

IU

V

-event

points

are

defined

similarly.

Observe

that

for

any

u

the

number

of

connected

components

of

A

is

at

most

the

number

of

V

-event

points

of

A.

We

use

induction

on

j

to

show

that

for

each

Vj

the

statement

of

the

theorem

holds

and,

additionally,

each

B(Vj

has

at

most

event

points.

To

simplify

the

base

case,

we

modify

the

graphical

game

by

appending

a

dummy

vertex

to

the

beginning

of

the

path:

the

only

neighbour

of

is

the

payoffs

of

are

always

equal

to

and

the

payoffs

of

all

other

vertices

(including

are

the

same

as

in

the

original

game.

For

j

we

have

so

the

statement

of

the

theorem

is

trivially

true.

Now,

suppose

that

j

set

V

Vj

and

let

U

and

W

be

the

vertices

that

precede

and

follow

V

respectively.

The

payoffs

to

V

are

described

by

a

matrix

P:

Pxyz

is

the

payoff

that

V

receives

when

U

plays

x,

V

plays

y,

and

W

plays

z,

where

x,

y,

z

Suppose

that

U

plays

with

probability

u

and

W

plays

with

probability

w.

Then

V

"s

expected

payoff

from

playing

is

=(1−u)(1−w)P000+(1−u)wP001+u(1−w)P100+uwP101,

while

its

expected

payoff

from

playing

is

=(1−u)(1−w)P010+(1−u)wP011+u(1−w)P110+uwP111.

If

P

V

strictly

prefers

to

play

if

V

strictly

prefers

to

play

and

if

V

is

indifferent,

i.e.,

can

play

any

(mixed)

strategy.

Since

and

are

linear

in

w

and

u,

there

exist

some

constants

and

that

depend

on

the

matrix

P,

but

not

on

u

and

w,

such

that

Depending

on

the

values

of

and

we

subdivide

the

rest

of

the

proof

into

the

following

cases.

In

this

case,

if

and

only

if

If

also

clearly,

B(W,

V

and

the

statement

of

the

theorem

is

trivially

true.

Otherwise,

the

vertex

V

is

indifferent

between

and

if

and

only

if

and

u

Let

V

{v

v

pbrU

(v)}.

By

the

inductive

hypothesis,

V

consists

of

at

most

segments

and

isolated

points.

For

any

v

V,

we

have

B(W,

V

)|V

=v

no

matter

what

W

plays,

as

long

as

U

is

playing

V

is

content

to

play

v.

On

the

other

hand,

for

any

v

V

we

have

B(W,

V

)|V

=v

when

V

plays

v,

U

can

only

respond

with

u

in

which

case

V

can

benefit

from

switching

to

one

of

the

pure

strategies.

To

complete

the

description

of

B(W,

V

it

remains

to

analyze

the

cases

v

and

v

The

vertex

V

prefers

to

play

if

and

u

or

and

u

or

and

Assume

for

now

that

the

other

two

cases

can

be

treated

similarly.

In

this

case

pbrV

(w)

for

some

w

if

and

only

if

there

exists

a

u

pbrU

such

that

u

if

no

such

u

exists,

whenever

V

plays

either

U"s

response

is

not

in

pbrU

or

V

can

improve

its

payoff

by

playing

Therefore,

either

B(W,

V

)|V

or

B(W,

V

)|V

Similarly,

B(W,

V

)|V

is

equal

to

either

or

depending

on

pbrU

Therefore,

the

set

B(W,

V

consists

of

at

most

(j

rectangles:

B(W,

V

contributes

at

most

rectangles,

and

each

of

the

sets

B(W,

V

)|V

and

B(W,

V

)|V

contributes

at

most

one

rectangle.

Similarly,

its

total

number

of

event

points

is

at

most

the

only

W

-event

points

are

and

each

V

-event

point

of

B(W,

V

is

a

V

-event

point

of

B(V,

U),

and

there

are

at

most

of

them.

for

some

α

R.

In

this

case,

V

is

indifferent

between

and

if

and

only

if

w

α,

or

and

u

Similarly

to

the

previous

case,

we

can

show

that

B(W,

V

consists

of

the

rectangle

and

at

most

rectangles

of

the

form

where

each

IV

corresponds

to

a

connected

component

of

B(V,

Furthermore,

V

prefers

to

play

if

and

w

α

or

and

w

α.

Therefore,

if

for

some

u∗

pbrU

then

B(W,

V

)|V

contains

[α,

and

if

for

some

u∗∗

pbrU

then

B(W,

V

)|V

contains

α]

if

both

u∗

and

u∗∗

exist,

B(W,

V

)|V

The

set

B(W,

V

)|V

can

be

described

in

a

similar

manner.

By

the

inductive

hypothesis,

B(V,

U)

has

at

most

event

points;

as

at

least

two

of

these

are

U-event

points,

it

has

at

most

V

-event

points.

Since

each

V

-event

point

of

B(W,

V

is

a

Vevent

point

of

B(V,

U)

and

B(W,

V

has

at

most

W

-event

points

and

α),

its

total

number

of

event

points

is

at

most

Also,

similarly

to

the

previous

case

it

follows

that

B(W,

V

consists

of

at

most

(j

rectangles.

In

this

case,

one

can

define

the

indifference

function

f(·)

as

f(u)

A(u)

B(u)

where

A(u)

and

B(u)

never

turn

into

zero

simultaneously.

Observe

that

whenever

w

f(u)

and

u,

w

V

is

indifferent

between

playing

and

For

any

A

we

define

a

function

ˆfV

by

ˆfV

(A)

{(f(u),

v)

(v,

u)

A};

note

that

ˆfV

maps

subsets

of

to

subsets

of

Sometimes

we

drop

the

subscript

V

when

it

is

clear

from

the

context.

LEMMA

For

any

(w,

v)

we

have

(w,

v)

B(W,

V

if

and

only

if

there

exists

a

u

such

that

(v,

u)

B(V,

U)

and

w

f(u).

PROOF.

Fix

an

arbitrary

v

Suppose

that

U

plays

some

u

pbrU

(v),

w

f(u)

satisfies

w

and

W

plays

w.

There

exists

a

vector

of

strategies

u,

vj

v

such

that

for

each

Vk,

k

j,

its

strategy

is

a

best

response

to

its

neighbours"

strategies.

Since

w

f(u),

V

is

indifferent

between

playing

and

in

particular,

it

can

play

v.

Therefore,

if

we

define

w,

the

vector

of

strategies

will

satisfy

the

conditions

in

the

definition

of

potential

best

response,

i.e.,

we

have

v

pbrV

(w).

Conversely,

suppose

v

pbrV

(w)

for

some

w

v

Then

there

exists

a

vector

of

strategies

vj

v,

w

such

that

for

each

Vk,

k

j,

its

strategy

is

a

best

response

to

its

neighbours"

strategies.

As

v

V

is,

in

fact,

indifferent

between

playing

and

which

is

only

possible

if

w

Choose

u

by

construction,

u

pbrU

(v).

Lemma

describes

the

situations

when

V

is

indifferent

between

playing

and

playing

However,

to

fully

characterize

B(W,

V

we

also

need

to

know

when

V

prefers

a

pure

strategy.

Define

∪u∈pbrU

where

Ru

[f(u),

if

B(u)

if

B(u)

and

∪u∈pbrU

where

Ru

[f(u),

if

B(u)

if

B(u)

LEMMA

For

any

w

we

have

(w,

if

and

only

if

pbrV

(w)

and

(w,

if

and

only

if

pbrV

(w).

PROOF.

Consider

an

arbitrary

pbrU

If

for

u

the

inequality

is

equivalent

to

w

Therefore,

when

U

plays

and

W

plays

w,

w

V

prefers

to

play

as

pbrU

(u),

it

follows

that

pbrV

(w).

The

argument

for

the

case

is

similar.

Conversely,

if

pbrV

(w)

for

some

w

there

exists

a

vector

vj

w)

such

that

for

each

Vk,

k

j,

Vk

plays

vk,

and

this

strategy

is

a

best

response

to

the

strategies

of

Vk"s

neighbours.

Note

that

for

any

such

vector

we

have

pbrU

By

way

of

contradiction,

assume

(w,

Ë

u∈pbrU

Ru.

Then

it

must

be

the

case

that

for

any

pbrU

either

w

and

or

w

and

In

both

cases,

when

V

plays

U

plays

and

V

plays

w,

the

inequality

between

and

w

is

equivalent

to

i.e.,

V

would

benefit

from

switching

to

The

argument

for

is

similar.

Together,

Lemma

and

Lemma

completely

describe

the

set

B(W,

V

we

have

B(W,

V

ˆf(B(V,

U))

It

remains

to

show

that

B(W,

V

can

be

represented

as

a

union

of

at

most

(j

rectangles,

has

at

most

event

points,

and

can

be

computed

in

time.

Set

u∗

Consider

an

arbitrary

rectangle

R

B(V,

U).

If

u∗

the

function

f(·)

is

continuous

on

and

hence

ˆf(R)

[fmin,

where

fmin

fmax

i.e.,

in

this

case

ˆf(R)

consists

of

a

single

rectangle.

Now,

suppose

that

R

is

intersected

by

the

line

as

was

noted

earlier,

there

are

at

most

such

rectangles.

Suppose

that

limu→u∗−

f(u)

as

f(·)

is

a

fractional

linear

function,

this

implies

that

limu→u∗+

f(u)

and

also

Since

f(·)

is

continuous

on

u∗

and

(u∗

it

is

easy

to

see

that

u∗

The

case

causes

no

special

problems.

For

completeness,

set

u∗

to

be

any

value

outside

of

in

this

case.

v

u

v

u*

f(a)f(b)

a

b

w

v

v

v

v

Figure

f

is

increasing

on

u∗

and

(u∗

and

i.e.,

in

this

case

ˆf(R)

consists

of

at

most

two

rectangles.

The

case

limu→u∗−

f(u)

is

similar.

As

ˆf(B(V,

U))

Ë

R⊂B(V,U)

ˆf(R),

it

follows

that

ˆf(B(V,

U))

consists

of

at

most

(j

rectangles.

Also,

it

is

easy

to

see

that

both

and

consist

of

at

most

line

segments

each.

We

conclude

that

B(W,

V

can

be

represented

as

a

union

of

at

most

(j

(j

rectangles.

Moreover,

if

v

is

a

V

-event

point

of

B(W,

V

then

v

is

a

Vevent

point

of

B(V,

U)

(this

includes

the

cases

v

and

v

as

and

are

V

-event

points

of

B(V,

U))

and

if

w

is

a

W

-event

point

of

B(W,

V

then

either

w

or

w

or

there

exists

some

u

such

that

w

f(u)

and

u

is

a

U-event

point

of

B(V,

U).

Hence,

B(W,

V

has

at

most

event

points.

The

bound

on

the

running

time

in

Theorem

follows

from

our

description

of

the

algorithm.

The

bound

on

the

overall

running

time

for

finding

a

Nash

equilibrium

(and

a

representation

of

all

Nash

equilibria)

follows.

Finding

a

Single

Nash

Equilibrium

in

Time

The

upper

bound

on

the

running

time

of

our

algorithm

is

tight,

at

least

assuming

the

straightforward

implementation,

in

which

each

Vj)

is

stored

as

a

union

of

rectangles:

it

is

not

hard

to

construct

an

example

in

which

the

size

of

Vj)

is

However,

in

some

cases

it

is

not

necessary

to

represent

all

Nash

equilibria;

rather,

the

goal

is

to

find

an

arbitrary

equilibrium

of

the

game.

In

this

section,

we

show

that

this

problem

can

be

solved

in

quadratic

time,

thus

obtaining

a

proof

of

Theorem

Our

solution

is

based

on

the

idea

of

i.e.,

working

with

subsets

of

the

best

response

policies

rather

than

the

best

response

policies

themselves;

following

we

will

refer

to

such

subsets

as

breakpoint

policies.

While

it

is

not

always

possible

to

construct

a

breakpoint

policy

as

defined

in

we

show

how

to

modify

this

definition

so

as

to

ensure

that

a

breakpoint

policy

always

exists;

moreover,

we

prove

that

for

a

path

graph,

the

breakpoint

policy

of

any

vertex

can

be

stored

in

a

data

structure

whose

size

is

linear

in

the

number

of

descendants

this

vertex

has.

Definition

A

breakpoint

policy

ˆB(V,

U)

for

a

vertex

U

whose

parent

is

V

is

a

non-self-intersecting

curve

of

the

form

Xm,

where

Xi

vi]×{ui},

Yi

{vi}×[ui,

and

ui,

vi

for

i

m.

We

say

that

a

breakpoint

policy

is

valid

if

vm

and

ˆB(V,

U)

B(V,

U).

We

will

sometimes

abuse

notation

by

referring

to

ˆB(V,

U)

as

a

collection

of

segments

Xi,

Yi

rather

than

their

union.

Note

that

we

do

not

require

that

vi

or

ui

consequently,

in

any

argument

involving

breakpoint

policies,

all

segments

are

to

be

treated

as

directed

segments.

Observe

that

any

valid

breakpoint

policy

ˆB(V,

U)

can

be

viewed

as

a

continuous

mapping

γ(t)

(γv(t),

γu(t)),

γ

where

um)

and

there

exist

some

such

that

{γ(t)

t

{γ(t)

t

As

explained

in

Section

we

can

use

a

valid

breakpoint

policy

instead

of

the

best

response

policy

during

the

downstream

pass,

and

still

guarantee

that

in

the

end,

we

will

output

a

Nash

equilibrium.

Theorem

shows

that

one

can

inductively

compute

valid

breakpoint

policies

for

all

vertices

on

the

path;

the

proof

of

this

theorem

can

be

found

in

the

full

version

of

this

paper

THEOREM

For

any

V

Vj,

one

can

find

in

polynomial

time

a

valid

breakpoint

policy

ˆB(W,

V

that

consists

of

at

most

segments.

NASH

EQUILIBRIA

ON

GRAPHS

WITH

MAXIMUM

DEGREE

In

this

section

we

show

how

the

algorithm

for

paths

can

be

applied

to

solve

a

game

on

any

graph

whose

vertices

have

degree

at

most

A

graph

having

maximum

degree

is,

of

course,

a

union

of

paths

and

cycles.

Since

each

connected

component

can

be

handled

independently,

to

obtain

a

proof

of

Theorem

we

only

need

to

show

how

to

deal

with

cycles.

Given

a

cycle

with

vertices

Vk

(in

cyclic

order),

we

make

two

separate

searches

for

a

Nash

equilibrium:

first

we

search

for

a

Nash

equilibrium

where

some

vertex

plays

a

pure

strategy,

then

we

search

for

a

fully

mixed

Nash

equilibrium,

where

all

vertices

play

mixed

strategies.

For

i

k

let

vi

denote

the

probability

that

Vi

plays

The

first

search

can

be

done

as

follows.

For

each

i

k}

and

each

b

do

the

following.

Let

P

be

the

path

Vk,

Vi)

Let

payoff

to

be

based

on

putting

vi

b

(so

it

depends

only

on

and

Apply

the

upstream

pass

to

P

Put

vi

b;

apply

the

downstream

pass

For

each

vertex,

Vj,

keep

track

of

all

possible

mixed

strategies

vj

Check

whether

has

any

responses

that

are

consistent

with

vi

b;

if

so

we

have

a

Nash

equilibrium.

(Otherwise,

there

is

no

Nash

equilibrium

of

the

desired

form.)

For

the

second

search,

note

that

if

Vi

plays

a

mixed

strategy,

then

and

satisfy

an

equation

of

the

form

Since

all

vertices

in

the

cycle

play

mixed

strategies,

we

have

Composing

the

two

linear

fractional

transforms,

we

obtain

for

some

new

constants

Choose

any

vertex

Vi.

We

can

express

vi

in

terms

of

then

etc.

and

ultimately

vi

itself

to

obtain

a

quadratic

equation

(for

vi)

that

is

simple

to

derive

from

the

payoffs

in

the

game.

If

the

equation

is

non-trivial

it

has

at

most

solutions

in

For

an

odd-length

cycle

all

other

vj

"s

are

derivable

from

those

solutions,

and

if

a

fully

mixed

Nash

equilibrium

exists,

all

the

vj

should

turn

out

to

be

real

numbers

in

the

range

For

an

even-length

cycle,

we

obtain

two

quadratic

equations,

one

for

vi

and

another

for

and

we

can

in

the

same

way

test

whether

any

solutions

to

these

yield

values

for

the

other

vj

all

of

which

lie

in

If

the

quadratic

equation

is

trivial,

there

is

potentially

a

continuum

of

fully-mixed

equilibria.

The

values

for

vi

that

may

occur

in

a

Nash

equilibrium

are

those

for

which

all

dependent

vj

values

lie

in

the

latter

condition

is

easy

to

check

by

computing

the

image

of

the

interval

under

respective

fractional

linear

transforms.

FINDING

EQUILIBRIA

ON

AN

(ARBITRARY)

TREE

For

arbitrary

trees,

the

general

structure

of

the

algorithm

remains

the

same,

i.e.,

one

can

construct

a

best

response

policy

(or,

alternatively,

a

breakpoint

policy)

for

any

vertex

based

on

the

best

response

policies

of

its

children.

We

assume

that

the

degree

of

each

vertex

is

bounded

by

a

constant

K,

i.e.,

the

payoff

matrix

for

each

vertex

is

of

size

Consider

a

vertex

V

whose

children

are

Uk

and

whose

parent

is

W

the

best

response

policy

of

each

Uj

is

B(V,

Uj).

Similarly

to

the

previous

section,

we

can

compute

V

"s

expected

payoffs

and

from

playing

or

respectively.

Namely,

when

each

of

the

Uj

plays

uj

and

W

plays

w,

we

have

uk,

w),

P

uk,

w),

where

the

functions

are

linear

in

all

of

their

arguments.

Hence,

the

inequality

can

be

rewritten

as

uk)

uk),

where

both

A(·,

and

B(·,

are

linear

in

all

of

their

arguments.

Set

u

uk)

and

define

the

indifference

function

f

as

f(u)

A(u)/B(u);

clearly,

if

each

Uj

plays

uj,

W

plays

w

and

w

f(u),

V

is

indifferent

between

playing

and

For

any

X

Xk,

where

Xi

define

ˆf(X)

{(f(u),

v)

(v,

ui)

Xi,

i

k}

Also,

set

{(w,

∃u

s.t.

ui

pbrUi

and

wB(u)

A(u)}

and

{(w,

∃u

s.t.

ui

pbrUi

and

wB(u)

A(u)}.

As

in

previous

section,

we

can

show

that

B(W,

V

is

equal

to

ˆf(B(V,

B(V,

Uk))

also,

any

path

from

w

to

w

that

is

a

subset

of

B(W,

V

constitutes

a

valid

breakpoint

policy.

Exponential

Size

Breakpoint

Policy

While

the

algorithm

of

Section

can

be

generalized

for

boundeddegree

trees,

its

running

time

is

no

longer

polynomial.

In

fact,

the

converse

is

true:

we

can

construct

a

family

of

trees

and

payoff

matrices

for

all

players

so

that

the

best

response

policies

for

some

of

the

players

consist

of

an

exponential

number

of

segments.

Moreover,

in

our

example

the

breakpoint

policies

coincide

with

the

best

response

policies,

which

means

that

even

finding

a

single

Nash

equilibrium

using

the

approach

of

is

going

to

take

exponentially

long

time.

In

fact,

a

stronger

statement

is

true:

for

any

polynomial-time

two-pass

algorithm

(defined

later)

that

works

with

subsets

of

best

response

policies

for

this

graph,

we

can

choose

the

payoffs

of

the

vertices

so

that

the

downstream

pass

of

this

algorithm

will

fail.

S

T

S

S

S

T

T

T

n

n

n

VVVVV

Figure

The

tree

Tn

that

corresponds

to

exponential-size

breakpoint

policy.

In

the

rest

of

this

subsection,

we

describe

this

construction.

Consider

the

tree

Tn

given

by

Figure

let

Vn

be

the

root

of

this

tree.

For

every

k

n,

let

the

payoffs

of

Sk

and

Tk

be

the

same

as

those

for

the

U

and

V

described

in

Section

recall

that

the

breakpoint

policies

for

U

and

V

are

shown

in

Figure

It

is

not

hard

to

see

that

the

indifference

function

for

Tk

is

given

by

f(s)

The

payoff

of

is

if

selects

the

same

action

as

and

otherwise;

best

response

policy

is

given

by

Figure

LEMMA

Fix

k

n,

and

let

u,

t,

v,

and

w

denote

the

strategies

of

Tk,

Vk,

and

respectively.

Suppose

that

Vk

prefers

playing

to

playing

if

and

only

if

w.

Then

Vk)

consists

of

at

least

segments.

Moreover,

{(v,

w)

(v,

w)

Vk),

w

and

{(v,

w)

(v,

w)

Vk),

w

PROOF.

The

proof

proceeds

by

induction

on

k.

For

k

the

statement

is

obvious.

Now,

suppose

it

is

true

for

B(Vk,

One

can

view

Vk)

as

a

union

of

seven

components:

and

five

components

that

correspond

to

the

segments

of

B(Vk,

Tk).

Let

us

examine

them

in

turn.

To

describe

note

that

f(u,

t)

is

monotone

in

t

and

u

and

satisfies

Also,

we

have

and

pbrTk

For

any

w

we

have

w

if

and

only

if

w

We

conclude

that

Similarly,

it

follows

that

Define

{(f(u,

v)

(v,

u)

B(Vk,

{(f(u,

v)

(v,

u)

B(Vk,

{(f(u,

v)

(v,

u)

B(Vk,

these

sets

correspond

to

horizontal

segments

of

B(Vk,

Tk).

It

is

easy

to

see

that

Vk).

Since

f

is

a

continuous

function,

the

number

of

segments

in

each

Si

is

at

least

the

number

of

segments

in

B(Vk,

which

is

at

least

by

induction

hypothesis.

Moreover,

as

f

is

monotone

in

u

and

all

Si,

i

are

disjoint.

Finally,

the

set

Vk)

contains

two

segments

that

correspond

to

the

vertical

segments

of

B(Vk,

Tk),

i.e.,

t),

t

and

t),

t

Clearly,

connects

and

connects

and

and

and

do

not

intersect

each

other.

We

conclude

that

Vk)

V

V

V

Figure

Breakpoint

policies

for

and

is

a

continuous

line

that

consist

of

at

least

segments

and

satisfies

the

condition

of

the

lemma.

To

complete

the

construction,

we

need

to

show

that

we

can

design

the

payoff

matrix

for

Vk

so

that

it

prefers

playing

to

playing

if

and

only

if

w.

To

this

end,

we

prove

a

more

general

statement,

namely,

that

the

indifference

function

of

a

vertex

can

be

an

arbitrary

fractional

multilinear

function

of

its

descendants"

strategies.

We

say

that

a

function

of

k

variables

is

multilinear

if

it

can

be

represented

as

a

sum

of

monomials

and

each

of

these

monomials

is

linear

in

all

of

its

variables.

Note

that

this

definition

is

different

from

a

more

standard

one

in

that

we

do

not

require

that

all

of

the

monomials

have

the

same

degree.

Recall

that

the

payoffs

of

a

vertex

with

k

neighbours

are

described

by

matrices

and

where

Pj

is

the

payoff

that

V

gets

when

it

plays

j,

and

its

neighbours

play

ik,

and

j,

ik

Let

P[j]

P[j](w,

uk)

be

the

expected

payoff

obtained

by

this

vertex

when

it

plays

j

and

the

(mixed)

strategies

of

its

neighbours

are

given

by

a

vector

(w,

uk),

i.e.,

P[j]

E[P

j

where

ik

are

independent

Bernoulli

random

variables,

each

of

which

is

with

the

respective

probabilities

w,

uk.

LEMMA

Given

a

tree

vertex

V

whose

parent

is

W

and

whose

children

are

Uk,

for

any

function

f

uk)

that

can

be

represented

as

a

ratio

of

two

multilinear

functions

i.e.,

f

there

exist

payoff

matrices

and

for

V

such

that

uk)

uk).

The

proof

of

this

lemma

is

based

on

the

fact

that

every

monomial

of

the

form

(uk)sk

sk

can

be

represented

as

(uk)tk

for

some

Ct,

t

The

details

can

be

found

in

the

full

version

of

this

paper

Irreducibility

of

the

Best

Response

Policy

for

Tn

While

the

best

response

policy

constructed

in

the

previous

subsection

has

exponential

size,

it

is

not

clear

`a

priori

that

it

is

necessary

to

keep

track

of

all

of

its

line

segments

rather

than

to

focus

on

a

small

subset

of

these

segments.

However,

it

turns

out

that

for

two-pass

algorithms

such

as

the

algorithm

of

the

best

response

policy

cannot

be

simplified.

More

precisely,

we

say

that

an

algorithm

A

is

a

two-pass

algorithm

if

V

V

S

S

S

S

S

T

T

Figure

Breakpoint

policy

for

A

consists

of

an

upstream

pass

and

a

downstream

pass.

During

the

upstream

pass,

for

each

vertex

V

with

parent

W

A

constructs

a

set

BB(W,

V

B(W,

V

This

set

is

produced

from

the

sets

{BB(V,

U)

U

is

a

child

of

V

by

applying

the

procedure

from

the

beginning

of

Section

(substituting

BB(V,

Uj

for

B(V,

Uj)

for

all

children

Uj

of

V

and

then

possibly

omitting

some

of

the

points

of

the

resulting

set

(which

is

then

stored

explicitly).

The

downstream

pass

is

identical

to

the

downstream

pass

of

as

described

in

Section

except

that

it

operates

on

the

sets

BB(W,

V

rather

than

on

the

sets

B(W,

V

Theorem

demonstrates

that

any

two-pass

algorithm

will

fail

during

the

downstream

pass

on

Tn

if

there

is

an

index

j

such

that

the

set

Vj)

omits

any

interior

point

of

any

of

the

(at

least

segments

of

Vj).

This

implies

Theorem

THEOREM

For

any

two-pass

algorithm

A

for

which

there

exists

an

index

j,

j

a

segment

S

of

B(Vj

and

an

interior

point

(x,

y)

of

S

such

that

BB(Vj,

does

not

contain

(x,

y),

we

can

choose

payoff

matrices

of

the

vertices

Vj,

Vn

so

that

the

downstream

pass

of

A

will

fail,

and,

additionally,

payoffs

to

Vn

are

identically

We

sketch

the

proof

of

Theorem

the

details

can

be

found

in

the

full

version

of

this

paper

We

proceed

by

induction.

For

j

the

argument

is

similar

to

that

in

Section

For

the

inductive

step,

the

main

idea

is

that

we

can

zoom

in

on

any

part

of

a

best

response

policy

(including

the

part

that

was

omitted!)

by

using

an

appropriate

indifference

function;

this

allows

us

to

reduce

the

case

j

to

j

PPAD-COMPLETENESS

OF

BOUNDED

PATHWIDTH

GRAPHICAL

GAMES

In

the

previous

section,

we

showed

that

for

graphical

games

on

trees

that

are

almost

but

not

quite

paths,

two-pass

algorithms

fail

to

find

Nash

equilibria

in

polynomial

time.

We

next

show

that

a

milder

path-like

graph

property

allows

us

to

construct

graphical

games

for

which

it

is

unlikely

that

any

polynomial-time

algorithm

will

find

Nash

equilibria.

Pathwidth

A

path

decomposition

of

a

graph

G

(V,

E)

is

a

sequence

of

subset

Si(V

V

such

that

for

each

edge

(v,

v

E,

v,

v

Si(V

for

some

i,

and

furthermore,

for

each

v

V

if

v

Si(V

and

v

Sj(V

for

j

i,

then

v

Sk(V

for

all

i

k

j.

The

path

decomposition

has

width

k

if

all

sets

Si(V

have

cardinality

at

most

k

The

pathwidth

of

G

is

the

minimum

width

of

any

path

decomposition

of

G.

Pathwidth

is

a

restriction

of

treewidth

(in

which

one

would

seek

a

tree

whose

vertices

were

the

sets

Si(V

and

the

sets

containing

some

vertex

would

have

to

form

a

subtree).

For

any

constant

k

it

can

be

decided

in

polynomial

time

whether

a

graph

has

pathwidth

(or

treewidth)

k.

Furthermore

many

graph-theoretic

problems

seem

easier

to

solve

in

polynomial

time,

when

restricted

to

fixed

treewidth,

or

pathwidth,

graphs,

see

for

an

overview.

Note

that

a

path

has

pathwidth

and

a

cycle

has

pathwidth

PPAD-completeness

We

review

some

basic

definitions

from

the

computational

complexity

theory

of

search

problems.

A

search

problem

associates

any

input

(here,

a

graphical

game)

with

a

set

of

solutions

(here,

the

Nash

equilibria

of

the

input

game),

where

the

description

length

of

any

solution

should

be

polynomially

bounded

as

a

function

of

the

description

length

of

its

input.

In

a

total

search

problem,

there

is

a

guarantee

that

at

least

one

solution

exists

for

any

input.

Nash"s

theorem

assures

us

that

the

problem

of

finding

Nash

equilibria

is

total.

A

reduction

from

search

problem

S

to

problem

S

is

a

mechanism

that

shows

that

any

polynomial-time

algorithm

for

S

implies

a

polynomial-time

algorithm

for

S.

It

consists

of

functions

f

and

g,

computable

in

polynomial

time,

where

f

maps

inputs

of

S

to

inputs

of

S

and

g

maps

solutions

of

S

to

solutions

of

S,

in

such

a

way

that

if

IS

is

an

input

to

S,

and

SS

is

a

solution

to

f(IS),

then

g(SS

is

a

solution

to

IS.

Observe

that

total

search

problems

do

not

allow

the

above

reductions

from

problems

such

as

CIRCUIT

SAT

(where

the

input

is

a

boolean

circuit,

and

solutions

are

input

vectors

that

make

the

output

true)

due

to

the

fact

that

CIRCUIT

SAT

and

other

NP-complete

problems

have

inputs

with

empty

solution

sets.

Instead,

recent

work

on

the

computational

complexity

of

finding

a

Nash

equilibrium

has

related

it

to

the

following

problem.

Definition

END

OF

THE

LINE.

Input:

boolean

circuits

S

and

P,

each

having

n

input

and

n

output

bits,

where

and

Solution:

x

such

that

S(x)

x,

or

alternatively

x

such

that

P(S(x))

x.

S

and

P

can

be

thought

of

as

standing

for

successor

and

predecessor.

Observe

that

by

computing

Si

(for

i

and

comparing

with

we

must

eventually

find

a

solution

to

END

OF

THE

LINE.

END

OF

THE

LINE

characterizes

the

complexity

class

PPAD

(standing

for

parity

argument

on

a

graph,

directed

version),

introduced

in

Papadimitriou

and

any

search

problem

S

is

PPAD-complete

if

END

OF

THE

LINE

reduces

to

S.

Other

PPAD-complete

problems

include

the

search

for

a

ham

sandwich

hyperplane,

and

finding

market

equilibria

in

an

exchange

economy

(see

for

more

detailed

descriptions

of

these

problems).

NASH

is

the

problem

of

finding

a

Nash

equilibrium

for

a

graphical

game

whose

graph

has

degree

Daskalakis

et

al.

show

PPAD-completeness

of

NASH

by

a

reduction

from

BROUWER,

introduced

in

and

defined

as

follows.

Definition

BROUWER.

Input:

a

circuit

C

having

input

bits

and

output

bits.

The

input

bits

define

a

cubelet

of

the

unit

cube,

consisting

of

the

coordinates

of

its

points,

given

to

n

bits

of

precision.

The

output

represents

one

of

four

colours

assigned

by

C

to

a

cubelet.

C

is

restricted

so

as

to

assign

colour

to

cubelets

adjacent

to

the

(y,

z)-plane,

colour

to

remaining

cubelets

adjacent

to

the

(x,

z)-plane,

colour

to

remaining

cubelets

on

the

(x,

y)-plane,

and

colour

to

all

other

cubelets

on

the

surface

of

the

unit

cube.

A

solution

is

a

panchromatic

vertex,

a

vertex

adjacent

to

cubelets

that

have

distinct

colours.

The

reason

why

a

solution

is

guaranteed

to

exist,

is

that

an

associated

Brouwer

function

φ

can

be

constructed,

i.e.

a

continuous

function

from

the

unit

cube

to

itself,

such

that

panchromatic

vertices

correspond

to

fixpoints

of

φ.

Brouwer"s

Fixpoint

Theorem

promises

the

existence

of

a

fixpoint.

The

proof

of

Theorem

uses

a

modification

of

the

reduction

of

from

BROUWER

to

NASH.

To

prove

the

theorem,

we

begin

with

some

preliminary

results

as

follows.

Each

player

has

actions,

denoted

and

For

a

player

at

vertex

V

let

p[V

denote

the

probability

that

the

player

plays

LEMMA

There

exists

a

graphical

game

Gshift

of

fixed

size

having

vertices

V

V

where

p[V

is

the

fractional

part

of

COROLLARY

There

exists

a

graphical

game

Gn−shift

of

size

Θ(n)

of

constant

pathwidth,

having

vertices

V

Vn

where

p[Vn]

is

the

fractional

part

of

.p[V

PROOF.

Make

a

chain

of

n

copies

of

Gshift

in

Lemma

Each

subset

of

vertices

in

the

path

decomposition

is

the

vertices

in

a

copy

of

Gshift.

Let

In(x)

denote

the

n-th

bit

of

the

binary

expansion

of

x,

where

we

interpret

as

true

and

as

false.

The

following

uses

gadgets

from

COROLLARY

There

exists

k

such

that

for

all

n,

and

for

all

n,

there

exists

a

graphical

game

of

size

O(n)

with

pathwidth

k,

having

vertices

where

PROOF

OF

THEOREM

Let

C

be

the

boolean

circuit

describing

an

instance

of

BROUWER.

Let

gp(n)

be

the

gates

of

C

indexed

in

such

a

way

that

the

input(s)

to

any

gate

are

the

output(s)

of

lower-indexed

gates.

will

be

the

inputs

to

C.

All

players

in

the

graphical

game

G

constructed

in

have

actions

denoted

and

The

probability

that

V

plays

is

denoted

p[V

G

has

players

Vx,

Vy

and

Vz

for

which

p[Vx],

p[Vy]

and

p[Vz]

represent

the

coordinates

of

a

point

in

the

unit

cube.

G

is

designed

to

incentivize

Vx,

Vy

and

Vz

to

adjust

their

probabilities

in

directions

given

by

a

Brouwer

function

which

is

itself

specified

by

the

circuit

C.

In

a

Nash

equilibrium,

p[Vx],

p[Vy]

and

p[Vz]

represent

coordinates

of

a

fixpoint

of

a

function

that

belongs

to

the

class

of

functions

represented

by

BROUWER.

For

i

p(n)

we

introduce

a

vertex

V

(i)

C

such

that

for

j

i,

Ij(p[V

(i)

C

is

the

output

of

gate

gj;

for

i

j

p(n),

Ij(p[V

(i)

C

is

Construct

V

(i)

C

from

V

C

using

Corollary

Let

G(i)

be

the

graphical

game

that

does

this.

Let

Sn(G(i)

be

a

length

n

path

decomposition

of

G(i)

where

V

C

and

V

(i)

C

Sn(G(i)

Then,

a

path

decomposition

of

is

obtained

by

taking

the

union

of

the

separate

path

decompositions,

together

with

for

i

p(n).

Let

GC

be

the

above

graphical

game

that

simulates

C.

GC

has

inputs,

consisting

of

the

first

n

bits

of

the

binary

expansions

of

p[Vx],

p[Vy]

and

p[Vz].

Similarly

to

the

output

of

GC

affects

Vx,

Vy

and

Vz

as

follows.

Colour

incentivizes

Vx,

Vy

and

Vz

to

adjust

their

probabilities

p[Vx],

p[Vy]

and

p[Vz]

in

the

direction

colour

incentivizes

them

to

move

in

direction

colour

direction

colour

direction

We

need

to

ensure

that

at

points

at

the

boundaries

of

adjacent

cubelets,

the

change

of

direction

will

be

approximately

the

average

of

directions

of

surrounding

points.

That

way,

all

four

colors/directions

must

be

nearby

so

that

they

can

cancel

each

other

out

(and

we

are

at

a

panchromatic

vertex).

This

is

achieved

using

the

same

trick

as

in

which

we

make

a

constant

number

M

of

copies

of

GC,

which

differ

in

that

each

copy

adds

a

tiny

displacement

vector

to

its

copies

of

p[Vx],

p[Vy]

and

p[Vz]

(which

are

derived

from

the

original

using

the

addition

gadget

of

Using

the

addition

and

multiplication

gadgets

of

we

average

the

directions

and

add

a

small

multiple

of

this

average

to

(p[Vx],

p[Vy],

p[Vz]).

At

a

Nash

equilibrium

the

outputs

of

each

copy

will

cancel

each

other

out.

The

pathwidth

of

the

whole

game

is

at

most

M

times

the

pathwidth

GC.

OPEN

PROBLEMS

The

most

important

problem

left

open

by

this

paper

is

whether

it

is

possible

to

find

a

Nash

equilibrium

of

a

graphical

game

on

a

bounded-degree

tree

in

polynomial

time.

Our

construction

shows

that

any

two-pass

algorithm

that

explicitly

stores

breakpoint

policies

needs

exponential

time

and

space.

However,

it

does

not

preclude

the

existence

of

an

algorithm

that

is

based

on

a

similar

idea,

but,

instead

of

computing

the

entire

breakpoint

policy

for

each

vertex,

uses

a

small

number

of

additional

passes

through

the

graph

to

decide

which

(polynomial-sized)

parts

of

each

breakpoint

policy

should

be

computed.

In

particular,

such

an

algorithm

may

be

based

on

the

approximation

algorithm

of

where

the

value

of

is

chosen

adaptively.

Another

intriguing

question

is

related

to

the

fact

that

the

graph

for

which

we

constructed

an

exponential-sized

breakpoint

policy

has

pathwidth

while

our

positive

results

are

for

a

path,

i.e.,

a

graph

of

pathwidth

It

is

not

clear

if

for

any

bounded-degree

graph

of

pathwidth

the

running

time

of

(the

breakpoint

policybased

version

of)

our

algorithm

will

be

polynomial.

In

particular,

it

is

instructive

to

consider

a

caterpillar

graph,

i.e.,

the

graph

that

can

be

obtained

from

Tn

by

deleting

the

vertices

Sn.

For

this

graph,

the

best

response

policy

of

a

vertex

Vk

in

the

spine

of

the

caterpillar

is

obtained

by

combining

the

best

response

policy

of

its

predecessor

on

the

spine

and

its

other

child

Tk;

since

the

latter

is

a

leaf,

its

best

response

policy

is

either

trivial

(i.e.,

or

or

consists

of

two

horizontal

segments

and

one

vertical

segment

of

the

form

that

connects

them.

Assuming

for

convenience

that

B(Vk,

Tk)

[α,

and

f

is

the

indifference

function

for

Vk,

we

observe

that

the

best

response

policy

for

Vk

consists

of

components:

and

three

components

that

correspond

to

and

[α,

Hence,

one

can

think

of

constructing

Vk)

as

the

following

process:

turn

B(Vk,

by

cut

it

along

the

(now

horizontal)

line

vk

α,

apply

a

fractional

linear

transform

to

the

horizontal

coordinate

of

both

parts,

and

reconnect

them

using

the

image

of

the

segment

under

f.

This

implies

that

the

problem

of

bounding

the

size

of

the

best

response

policy

(or,

alternatively,

the

breakpoint

policy),

can

be

viewed

as

a

generalization

of

the

following

computational

geometry

problem,

which

we

believe

may

be

of

independent

interest:

PROBLEM

Given

a

collection

of

axis-parallel

segments

in

consider

the

following

operation:

pick

an

axis-parallel

line

li

(either

vertical

or

horizontal),

cut

the

plane

along

this

line,

and

shift

one

of

the

resulting

two

parts

by

an

arbitrary

amount

δi;

as

a

result,

some

segments

will

be

split

into

two

parts.

Reconnect

these

parts,

i.e.,

for

each

segment

of

the

form

[a,

b]

{c}

that

was

transformed

into

[a,

t]

{c

δi}

and

[t,

b]

{c},

introduce

a

segment

{t}×[c,

c+δi].

Is

it

possible

to

start

with

the

segment

and

after

n

operations

obtain

a

set

that

cannot

be

represented

as

a

union

of

poly(n)

line

segments?

If

yes,

can

it

be

the

case

that

in

this

set,

there

is

no

path

with

a

polynomial

number

of

turns

that

connects

the

endpoints

of

the

original

segment?

It

turns

out

that

in

general,

the

answer

to

the

first

question

is

positive,

i.e.,

after

n

steps,

it

is

possible

to

obtain

a

set

that

consists

of

Θ(cn

segments

for

some

c

This

implies

that

even

for

a

caterpillar,

the

best

response

policy

can

be

exponentially

large.

However,

in

our

example

(which

is

omitted

from

this

version

of

the

paper

due

to

space

constraints),

there

exists

a

polynomial-size

path

through

the

best

response

policy,

i.e.,

it

does

not

prove

that

the

breakpoint

policy

is

necessarily

exponential

in

size.

If

one

can

prove

that

this

is

always

the

case,

it

may

be

possible

to

adapt

this

proof

to

show

that

there

can

be

an

exponential

gap

between

the

sizes

of

best

response

policies

and

breakpoint

policies.

REFERENCES

H.

Bodlaender

and

T.

Kloks.

Efficient

and

constructive

algorithms

for

the

pathwidth

and

treewidth

of

graphs.

Journal

of

Algorithms,

X.

Chen

and

X.

Deng.

is

PPAD-complete.

Technical

Report

Electronic

Colloquium

in

Computational

Complexity,

X.

Chen

and

X.

Deng.

Settling

the

complexity

of

Nash

equilibrium.

Technical

Report

Electronic

Colloquium

in

Computational

Complexity,

C.

Daskalakis,

P.

Goldberg,

and

C.

Papadimitriou.

The

complexity

of

computing

a

Nash

equilibrium.

In

Proceedings

of

the

ACM

Symposium

on

Theory

of

Computing,

C.

Daskalakis

and

C.

Papadimitriou.

Three-player

games

are

hard.

Technical

Report

Electronic

Colloquium

in

Computational

Complexity,

E.

Elkind,

L.

Goldberg,

and

P.

Goldberg.

Nash

equilibria

in

graphical

games

on

trees

revisited.

Technical

Report

Electronic

Colloquium

in

Computational

Complexity,

P.

Goldberg

and

C.

Papadimitriou.

Reducibility

among

equilibrium

problems.

In

Proceedings

of

the

ACM

Symposium

on

Theory

of

Computing,

M.

Kearns,

M.

Littman,

and

S.

Singh.

Graphical

models

for

game

theory.

In

Proceedings

of

the

Conference

on

Uncertainty

in

Artificial

Intelligence,

M.

Littman,

M.

Kearns,

and

S.

Singh.

An

efficient

exact

algorithm

for

singly

connected

graphical

games.

In

Proceedings

of

the

Annual

Conference

on

Neural

Information

Processing

Systems,

L.

Ortiz

and

M.

Kearns.

Nash

propagation

for

loopy

graphical

games.

In

Proceedings

of

the

Annual

Conference

on

Neural

Information

Processing

Systems,

C.

Papadimitriou.

On

the

complexity

of

the

parity

argument

and

other

inefficient

proofs

of

existence.

J.

Comput.

Syst.

Sci.,

large-scale distributed network
dynamic programming-based algorithm
ppad-completeness
bounded-degree tree

graphical game
nash equilibrium
degree
generic algorithm
response policy
downstream pass
breakpoint policy