Economics and Computer Science Network Routing

Economics and Computer ScienceNetwork Routing

CS595, SB 213

Xiang-Yang Li Department of Computer Science

Illinois Institute of Technology

IntroductionPreliminaries and Related WorksUnicastMulticastAnycastBroadcastConclusion and future work

Outline

Example: Routing need nodes to relay packets, but Nodes are battery powered Nodes are selfish (self-incentive) Lying can result disaster for system

Example: TCP/IP congestion control Additive increase, Multiplicative decrease Terminals can deviate from this and

benefit

Why need truthful computing?

Game Theory Neoclassical economics Mathematics Other social and behavioral sciences (Psychology) Computer Science

Game Theory History John von Neumann, Oskar Morgenstern (1944) “Theory of

games and economics behavior” Prisoner's Dilemma (1950) John Nash: Non-cooperative game; Nash equilibrium (1951)

Game Model Extensive (Sequential) Game– Chess Strategic (Simultaneous) Game ()

Truthful via Game Theory

Algorithm Mechanism Design

N players Private type ti

Strategy from Ai

Mechanism Output O(a) Payment p(a)

Player i Valuation: Utility:

N wireless nodes Private cost ci

Strategies: all possible costs

Mechanism Output O(c): a structure Payment p(c)

Node i Valuation: -ci

if relays

Utility: ui=pi-ci if relays

),( ii tov),( iiii tovpu

Algorithm Mechanism Design

Truthful Mechanism Design Direct revelation: for every agent i . Incentive Compatibility: for every agent i,

revealing its true type is a dominant strategy.

Individual Rationality: Every agent must have non-negative utility if they reveal their true private input.

Other Desirable Property Polynomial time complexity.

ii TA

it

VCG Mechanism

Who designed? Vickrey(1961); Groves(1973);

Clarke(1971) What is VCG Mechanism?

A VCG Mechanism is truthful.

)),((maxarg)(1

n

i

iio otvto

)())(,()( ii

ij

jji thtotvtp

Problems studied

Unicast Truthful payment scheme (VCG scheme) Our contribution: Fast Computation Collusion Among nodes: Negative results

Multicast VCG not applicable Several truthful mechanisms for

structures: LCPS, VMST, PMST, Steiner Tree.

Payment Computing

Unicast

Unicast

0v

9v

4v

1v8

7v

2v

6v5v

8v

6 7

795

1 7

3v

Node vk costs ck to relay (private knowledge)

Each node vk reports a cost dk

Find the shortest path from node v0 to node v9 based on reported costs d

Compute a payment pk for node vk based on d

Objective: Find a payment pk(d) so node maximizes utility when dk =ck

Unicast Payment Scheme

Remove node vk and all its incident edges, find the LCP in the new graph, say LCP(vi ,vj ,G\ vk).

The payment to vk is),,()\,,( GqqLCPvGqqLCPcp jiktskk

If vk is not on the LCP(vi ,vj ,G) then pk is 0; else its payment is the difference of second shortest path and shortest path plus its declared cost.

Find the least cost path between node vi and vj, say LCP(vi,vj,G)

54v 5

18756),,( 74190 cccGqqLCP

21777)\,,( 863490 cccvGqqLCP

),,()\,,( 9049044 GqqLCPvGqqLCPcp 0v

9v

1v 8

7v

2v

6v5v

8v

6 7

79

7 7

3v

8182154 p

91 p 107 p

Total payment is 8+9+10 =27 instead of actual cost 18.

Overpayment ratio: %15018

27

741

741

ccc

ppp

Payment Calculation

Payment calculation for one node Dijstra’s algorithm Time complexity O(n log n+m)

Payment calculation for all nodes on the LCP Using Dijstra’s algorithm for every node Time complexity O(n2 log n+nm) Worst Case could be O(n3)

Can we calculate it faster? Our Result: Payment calculation for all nodes on the

LCP could be done in O(n log n+m) which is optimal.

Fast Payment Calculation

1. First we calculate the Shortest Path Tree (SPT) rooted at vi and v0 respectively and denote them as SPT(vi) and SPT(v0). The shortest path between vi and v0 is . Let L(vk) be the length of the shortest path from vk to v0 and R(vk) be the length of shortest path from vk to vi.

2. This step calculates a level (denoted as vk.level) for every node vk in graph G.3. For every node vk not on the LCP(v_i,v_0,d), we find a avoiding shortest

path between vk and vi where v_k.level=l. Let R-l(vk) denote the length of this path.

4. For node vk with level greater than or equals l and each of its neighbors vj such that vj.level < l, we calculate L(vj) +R-l( vk)+cj+ck. Choose the neighbor vj with the minimum value and denote it as c-l(vk). Among all nodes with label l, choose the one with the minimum c-l(vk), denote it as c-l. c-l is the length of the second shortest path.

5. The payment to node as follow

)()(10 0 ijjj vvvvv

r

ljv

ljv

),,( 0 GvvLCPcdp il

jj ll

Fast Payment Computation Algorithm

)( 00vv j

)( ij vvr1j

v ljv

kvjv

jkkl

jljk ccvRvLc )()(,

lkllevelvllevelv

l ccjk

.,.min

Conclusion: is the length of shortest avoiding path. lclj

v

llevelv j . llevelvk .

Algorithm Illustration

Incentive-Compatible Interdomain Routing

Based on the article:

“Incentive-Compatible Interdomain Routing”

Joan Feigenbaum, Christos Papadimitriou,

Rahul Sami, Scott Shenker

Preliminaries

Data on the Internet has to be conveyed from many sources to many targets.

RoutingRouting - Conveyance of the data through the different routes.

ASAS = Autonomous System = A Sub-network that serves as a mid-point for the conveyance routes. A.K.A DomainDomain.

Our Goal

To convey all data on the Internet in the most efficient way.

Problem:To know the most efficient way, we must know the true efficiencies of the AS’s.But every AS has an owner, and the owners are human!

Definitions TrafficTraffic - Quantity of packets that are

transmitted throughout the network. CostCost - For every AS, it is the additional

load imposed on its internal network by carrying traffic.

Transit TrafficTransit Traffic - For every AS, it is the traffic which neither originates nor is destined to that AS.

PricePrice - A compensation which is paid for every AS for carrying transit traffic.

LCPLCP = Lowest-Cost Path (between any two AS’s).

Our Goal - More Formally

To convey all data on the network s.t. the total costs are minimized. High efficiency = Low total costs

Problem:To do that, we must know the true costs of the AS’s.But every AS might be lying about its costs!

Model - General Assumptions (I)

AS’s are unitary strategic agents. There is no centralized authority that

controls the network, whom the AS’s can trust.

There exists a protocol that, given a set of AS costs, can compute all LCPs.

Model - General Assumptions (II)

Cost per-packet is constant. BGP (Border Gateway Protocol) is a

suitable protocol that finds and uses LCPs. In reality, BGP doesn’t find LCPs, but

shortest paths (in terms of number of hops). In reality, BGP doesn’t always use LCPs, but

also employs routing by policy and transit restrictions.

Our Goal - According to Model

Devise a pricing scheme for the AS’s s.t. they would have no incentive to lie about their transit costs. Must be strategy-proof. Additional Requirement: The pricing scheme

would give no payments to AS’s that carry no transit traffic.

Provide a distributed algorithm for the AS’s that is “BGP-friendly”, to compute the above prices.

Part I:Pricing Scheme

NN - set of nodes (AS’s) on the network.nn = |N|

LL - set of links between nodes of N. GG - the AS graph (N - vertices, L - edges). TTijij - For any two nodes i, j N, it is the

intensity of traffic (number of packets) originating from i destined to j.

cckk - the transit cost of node k for each transit packet it carries.cc-k-k = (c1, ..., ck-1, ck+1, ..., cn)

ppkk - the payment which will be given to node k to compensate it for carrying transit traffic.

Definitions

Between every two nodes there is at most one link. Allows us to represent network as graph G.

Every link is bi-directional. Allows G to be undirected.

G is 2-connected.

The transit cost of a node k is the same for all neighbors of k from which the traffic arrives. Allows us to define ck.

Specific Assumptions

IIkk(c;i,j)(c;i,j) - Indicator function for the LCP from i to j. Ik(c;i,j) = 1 if node k is an intermediate node on the LCP from i to j. Ik(c;i,j) = 0 otherwise. Note: Ii(c;i,j) = Ij(c;i,j) = 0.

V(c)V(c) - Total cost of routing all packets on LCPs.

More Definitions

Nk

kkNji

ij cjicITcV ),;()(,

Minimize V(c). Problem:

If nodes report false costs, BGP might end up computing different (false) LCPs. Let c* be the reported cost vector. Then, by

definition of Ik:

Formulation of Goal

Nkkk

Njiij

Nkkk

Njiij cjicITcjicITcV ),;(),;()(

,

*

,

Nkkk

Nkkk cjicIcjicIji ),;(),;(, *

Purpose: Minimize V(c) (objective function) by making nodes reveal true costs.

Input: <G, c> c is vector of reported costs, or strategies. The strategy ck of node

k is the cost that it reports. Output: Set of LCPs and prices.

For any given vector c we require:

Mechanism Design Problem

Njikkij

kk

kkk

cjicITpc

xcc

,

),;()(

where

)|()(

k’srevenues

k’sprofits

k’scosts

Theorem:When routing picks lowest-cost paths and the network is 2-connected, there is a unique strategy-proof pricing mechanism that gives no payment to nodes that carry no transit traffic. The payments are of the form:

Mechanism Design Solution

Nr Nrrrr

krkk

kij

kij

Njiij

k

cjicIcjicIjicIcp

pTp

,;,;|),;(

where

,

k’s costs per packet from i to j

cost of all nodes per packet from i

to j if k didn’t exist

cost of all nodes per packet from i to j

when k exists

welfare that world receives from k’s existence per packet from i to j

Let uk(c) denote the total costs incurred by a node for the cost vector c.

Proof of Theorem (I)

Nji Nk Nkkkkij

Njikijkk

cucjicITcV

jicITccu

,

,

)(),;()(

Then,

),;()(

We have already seen that (Ik(c;i,j))k N minimizes V(c).

We can build a VCG mechanism!

Proof of Theorem (II)

)()()( kkk

k chcVcup kc

finite) are costsother connected,-2 is(G

0),;|(, jicIji kk

payment) zero

ofnt (Requireme

0 kp 0)( ; cuk

)|()( kkk cVch

known fact - payments must be expressible as:

Proof of Theorem (III)

)()()|( cVcucVp kkk

Nji Nrrr

Nrr

krkkij cjicIcjicIjicIcT

,

),;(),;|(),;(

Nji

kijij pT

,

Payments are a sum of per-packet payments that don’t depend on the traffic matrix.

Payments are zero if LCP between i and j doesn’t traverse k. Therefore, payments can be computed at k by counting the packets as they enter k (after pricing has been determined).

Costs do not depend on the source and destination of packets, but prices do.

Payment to node k for a packet from i to j is determined by the cost of the LCP and the cost of the lowest-cost path that doesn’t pass through k.

Notes on Pricing

kijp

Part II:Distributed Algorithm(for computing prices)

dd - Diameter of network, i.e. the maximum number of AS’s in an LCP (not the diameter of G).

Every node i stores, for each AS j, the LCP from i to j (vector of AS ID’s). Each LCP is also described by its total transit cost (sum of costs of transit nodes). Every node stores O(nd) AS numbers and O(n)

path costs. Routing TableRouting Table - the above information stored in

node i.

Substrate - BGP (I)

“BGP” Algorithm:for each node i (concurrently) {

while (1) {Receive routing tables from all neighbors

that have sent them;Compute own routing table;if (change detected) {

Send routing tables to all neighbors;} } }

StageStage - every while iteration. For every node i, a change can occur because:

A neighbor’s routing table has changed. A link of i was added or removed.

Substrate - BGP (II)

Same assumptions as before. G is an undirected, 2-connected graph.

Router table contains total costs of LCPs. All nodes compute and exchange tables

concurrently. Frequency of communication is limited by need for

keeping network traffic low. Local computation is not a bottleneck.

When there is more than one LCP to choose from, BGP makes the choice in a loop-free manner. Explained below.

Static environment - no changes in links.

BGP - Specific Assumptions

Storage requirement on each node - O(nd) (size of router table).

Number of operations complexity - Measured by number of stages required for convergence and total communication.

Computation of all LCPs within d stages. Each stage involves O(nd) communication

on any link (size of router table). For node i, total communication in a single stage

is O(nd * degree(i)).

BGP - Performance

BGP builds the LCPs in a manner that satisfies the following:For every node j, the sub-graph of G containing all the LCPs from j to other nodes in G, is a tree.

Contrary example:

Loop-Free BGP

j

k

i

55

2

Input: cost vector c where ci is known only to node i.

Output: set of prices, with node i knowing all the values.

Substrate: BGP, receiving <G, c> as distributed input, and giving LCPs as distributed output.

Complexity: Around O(nd) storage requirements on each node, around d stages of communication, around O(nd * degree(i)) data communicated by node i in each stage.

Goal - Computation Algorithm

kijp

P(c;i,j)P(c;i,j) - LCP from i to j for the vector of declared costs c (the inner nodes).

c(i,j)c(i,j) - The cost of the above path. k-avoiding pathk-avoiding path - Any path that doesn’t

pass through k. PP-k-k(c;i,j)(c;i,j) - The lowest-cost k-avoiding path

from i to j. T(j)T(j) - The tree of all LCPs for node j.

Yet More Definitions

Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ?

Reminder:

Case I: a is i’s parent in T(j), a isn’t k.

Upper Bounds for Prices (I)

kajp k

ijp

Nr Nr

rrrk

rkkkij cjicIcjicIjicIcp ,;,;|),;(

kaj

kij pp

j

a

k

i


Reminder:

Case II: a is i’s child in T(j).

Upper Bounds for Prices (II)

aikaj

kij ccpp j

i

k

a

Nr Nr

rrrk


kajp k

ijp


Reminder:

Case III: a isn’t adjacent to i in T(j), and k is on P(c;a,j).

Upper Bounds for Prices (III)

),(),( jicjaccpp akaj

kij

j

a

k

i

d

Nr Nr

rrrk


kajp k

ijp


Reminder:

Case IV: a isn’t adjacent to i in T(j), and k isn’t on P(c;a,j).

Upper Bounds for Prices (IV)

),(),( jicjacccp akkij

j

a

d

i

k

Nr Nr

rrrk


kajp k

ijp


Other Cases: a is i’s parent in T(j), a = k. a is i’s descendant in T(j), but not its child. a is i’s ancestor in T(j), but not its parent.

In all the above cases, P-k(c;i,j) will not be (a, P-k(c;a,j)).

Upper Bounds for Prices (V)

kajp k

ijp

bb - The neighbor of i on P-k(c;i,j). Lemma:

For b, the previous four inequalities attain equality.

Case I:

Case II:

Case III:

Case IV:

Exact Prices (I)

kbj

kij pp

bikbj

kij ccpp

),(),( jicjbccpp bkbj

kij

),(),( jicjbcccp bkkij

Proof: b falls into one of the four cases. From definition of P-k(c;i,j), there is no

undercutting shorter k-avoiding path (no other “blue” path).

kijp

Consequence:From the inequalities of cases (I) - (IV) and from the Lemma, we can deduce that: is exactly equal to the minimum, over all neighbors a of i, of the right-hand side of the corresponding inequality !!!

Exact Prices (II)

Data:In each node i, for each destination node j: LCP from i to j (after running BGP), i.e.:

P(c;i,j) = (i = vk, vk-1, …, v0 = j) Array of prices in LCP, i.e.:

Cost of LCP, i.e. c(i,j). Assumptions:

Same assumptions as before for BGP. Each node i knows for each destination node j and each neighbor a, whether a is its parent, child or

neither in T(j). ),...,,( 01 jij

vij

vij

vij

iij ppppp kk

Price Computation Algorithm (I)

Run BGP();for each node i (concurrently) {

for each destination node j {Set all entries in array P(c;i,j) to ;Set entries in array P(c;i,j) to 0;

}Send all arrays P(c;i,j) to neighbors;

}

Initialization:

rvijp

jij

iij pp ,

Price Computation Algorithm (II)

while (1) {for each destination node j {

if (received array P(c;a,j) from neighbor a) {if (a is i’s parent in T(j))

else if (a is i’s child in T(j))

else { vt=nearest common ancestor of i and a;

}}if (array P(c;i,j) changed)

Send array P(c;i,j) to neighbors;}

}}

);,min(:1 rrr vaj

vij

vij pppkr

);,min(: aivaj

vij

vij ccpppkr rrr

));,(),(,min(: jicjaccppptr avaj

vij

vij

rrr ));,(),(,min(: jicjacccpptr av

vij

vij r

rr

Case I

Case II

Case III

Case IV

Price Computation Algorithm (III)

Inductively, according to inequalities of cases (I) - (IV), the value of is never too low.

For every node s on P-k(c;i,j), the suffix of P-

k(c;i,j) from s to j is either P(c;s,j) orP-k(c;s,j).

Therefore, inductively, after m stages there will be m nodes on P-k(c;i,j) with a correct per-packet price value .

kijp

sijp

j

sk

i

j

sk

i

Correctness of Algorithm

d’d’ - Main part of algorithm requires O(d’) stages. After computing , there still remains to

compute the total prices. For every packet from i to j, every node k on

P(c;i,j) counts the number of packets and multiplies by . This is later sent to an accounting mechanism.

Requires O(n) additional storage in each node.

kijp

|)),;((|max,,

jicP k

kji

kijp

Performance of Algorithm (I)

Theorem (proven):Our algorithm computes the VCG prices correctly, uses storage of size O(nd), converges in at most (d+d’) stages, and communicates for node i O(nd*i) data in each stage.

Compare to original BGP - O(nd) storage, d stages, communication for node i of O(nd*i) data in each stage.

In the worst case, d’/d = (n). Tested on a snapshot of more than half the real

internet:n = 5773, d = 8, d’ = 11.

Performance of Algorithm (II)

A lot of assumptions in the model. But a good starting point.

Mixing theoretical and real information. Payment for AS’s - theoretical. Structure of Internet - real.

More than one way to tell a lie.

A Pinch of Criticism

Incentive - efficiency of data transfer on network (Internet).

Strategy-proof pricing scheme to make AS’s reveal true costs.

Distributed algorithm for calculation of price, using BGP.

More room for development.

Summary

Frugal Path Mechanisms

by

Aaron Archer and Eva Tardos

The Model

53

7

111

2 2

Each edge is controlled by a selfish agent.The cost of the edge is known only to him.

The utility of agent i is (his payment minus the cost he incurred)

Problem: How to find a low-cost s-t path ?

s t

ii cp

Possible Solution: VCG In VCG:

Each edge declares some cost. The shortest path according to the declared costs is

chosen The payment to edge e in the chosen path:

(the cost of the shortest path in the graph without e) minus(the cost of the chosen path without counting e)

VCG is truthful (you will be convinced later on).

Problem: The total payment increases when the chosen pathhas more edges. When C1, C2 are the 1st, 2nd lowest costs,and the length of the shortest path is k, then:

)12(1

12)1(2

1 CCkCpP

CCccCCp

Pe e

eee

Main Question:

Is there a truthful mechanismthat pays less ??

Threshold-based Mechanisms For all truthful mechanisms that pay 0 to “loosing” edges:

Observation: If edge e “wins” when bidding be , it must alsowin with a lower bid b’e < be

Conclusion 1: There is a threshold bid Te : edge e wins withlower bids and looses with higher bids.

Conclusion 2: The payment to edge e must be exactly Te ,its threshold bid.

Theorem:Any mechanism for the path selection problem istruthful if and only if it is a Threshold-based Mechanism.

For example, VCG is Threshold-based (thus it is truthful).

Min-Function Mechanisms

Definition: A mechanism is called a Min-Function Mechanismif it defines, for every s-t path P, a (positive real valued)function fP of the vector of bids bP , such that:

fP is monotonically strictly increasing, and continuous.

The mechanism always selects the path P with the lowestvalue fP(bP).

Notice that: A Min-Function Mechanism is Threshold-based

(and thus truthful). VCG (for the path selection problem) is a min function

mechanism.

Min-Function Mechanisms: Costly Example

Take any Min-Function mechanism, and any graph with twonode-disjoint s-t paths (P & Q). The following scenario is costly: Define , a vector of bids of the edges in path P : each

edgedeclares L/|P| , except the i’th edge, who declares

w.l.o.g :

Then, if P bids and Q bids then P wins. In this case, the cost of P is L, and the cost of Q is L(1+d).

Let us calculate the total payment in this case: Each edge gets paid its threshold bid, . If an edge in P raises its bid by less than , P will still win. So, , and the total payment is

( e.g. for d=1 the payment is (|P|+1)L )

iPb

LdPL ||/)}(),...,(),(),...,({max)( ||1||11 Q

QQQQPPPPPQQ bfbfbfbfbf

1Qb0

Pb

eTLd

LdPLTe ||/ LdPL ||

Conclusion: All min-function mechanisms suffer from thesame drawback of the VCG mechanism we have seen.

What remains to show: “In many cases”, all truthfulmechanisms are min-function mechanisms.

Reasonable Mechanism Properties

1. Edge Autonomy: For any edge e, given the bids of the otheredges, e has a high enough bid that will ensure that no pathusing e will not win. (We say that e bids infinity)

2. Path Autonomy: Given the bids of all edges outside P, thereis a bid bP such that P will be chosen.

3. Independence: If path P wins, and an edge e not in P raisesits bid, then P will still win.

Definition: If path P wins, and there is an edge e such thatany (small) change in e’s bid causes another path Q to win,then P and Q are tied.

4. Sensitivity: If P wins and Q is tied with P, then increasing thebid of any , or decreasing the bid of any ,will cause P to lose. QPe \ PQe \

Comparing Bids

Definition: Suppose path P bids bP, path Q bids bQ, and all otheredges bid infinity. If P wins, then we writeIf either then they are comparable.

Lemma: Suppose path Q is node-disjoint from paths P and L.

Proof: Suppose P bids bP, Q bids bQ, L bids bL ,and allother edges bid infinity. Who wins? If Q, then after raising to infinity the bids of L\P, Q still wins

(by independence), contradicting (The same for L)

Since only P,Q, and L might win, then P wins.P still wins after raising to infinity the bids of Q.

QP bb

LPLQQPLP bbbbbbbb and , ,comparable are and if Then

QP bb

PQQP bbbb or

The edge (s,t) is in G

Theorem: If G contains the edge (s,t) then any truthful mechanismsatisfying the above properties is a min function mechanism.

Proof: Let R be the edge (s,t). Define the functions:

Choose some P and raise all bids besides P and R to infinity.Notice that now, fP(bP) is exactly R’s threshold bid.

Therefore, R wins if fR(bR) is minimal, and looses if not. For any P,Q (besides R), if fP(bP) < fQ(bQ) then Q will not win:

choose some c, fP(bP) < c < fQ(bQ) , so :

})(|{sup)(;)( PRPPR bccbfccf

not win. willQ)(and)( QPQRRP bbbccb

(proof continued)

Claim: fP() is strictly increasing. Fix some P, e in P, and some bid bP. If R bids fP(bP) then R

and P are tied. Thus any decrease in e’s bid causes P to win(by sensitivity).

Consider a new bid b’P, in which e decreases its bid by d.We need to show that fP(b’P) < fP(bP).

But if fP(b’P) = fP(bP) = bR then R and P are tied again.Thus increasing e’s bid by d/2 will cause P to lose - contradiction.

Claim: fP() is continuous. Otherwise let (bP-e ,be) be a discontinuity point for fP() ,

jumping from x to y. Suppose R bids (x+y)/2. Thus R and P are tied. If R wins then small increase in R’s

bidmakes P the winner - contradiction. (the same if P wins).

Three s-t connected components

Theorem: If G contains an s-t connected component and twoother s-t paths (disjoint from the rest), then any truthfulmechanism satisfying the above properties is a min functionmechanism.

Proof: Let R,S be the two separate s-t paths. Define:

By defining we can show thatis strictly increasing and continuous, similar to before.For other bids of R, we define:

})1(|{sup)(: PRPP bccbfRP

}and)(s.t.|{sup)( RSSSSRR bbcbfbcbf

ccfR )1(

)(: PP bfRP

(proof continued)Claim:

Case 1: Neither P nor Q is RTake c, fP(bP) < c < fQ(bQ) and so

Case 2a: Q = R and P is not STake bS such that fP(bP) < fS(bS) < fR(bR) andBy case 1, and the claim follows.

[ for case 2b, P = R and Q is not S, the proof is similar ]

Case 3a: P = S and Q = RChoose some other path L. By autonomy and continuityof fL() there is a bid bL such that fS(bS) < fL(bL) < fR(bR).By case 1 and by case 2 , as needed.

[ for case 3b, P = R and Q = S, the proof is similar ]

QPQQPP bbbfbf )()(

QRP bcb

)1(

RS bb

SP bb

RL bb LS bb

Conclusion: Any truthful mechanism on a graph that containseither an s-t edge or three edge-disjoint s-t paths, and thatsatisfies the desired properties, can be forced to pay times the cost of the winning path, where k is the lengthof the winning path.

Remark: There is a graph with two disjoint s-t paths anda truthful mechanism for this graph, that is not a minfunction mechanism. (the next slides, if time permits)

)(k

Two s-t disjoint paths

The following mechanismis a counter example: Given bids bP =(x1,x2 ) and bQ =(y1,y2 ), draw a line in the x1-

x2

plane, with x1-intercept: y1+(y2 / 2), and x2-intercept: y2+(y1 / 2).

If bP is strictly above the line, Q wins, otherwise P wins. Verify: all four bidders have threshold values. Autonomy,

independence and sensitivity hold.

x1 x2

y1 y2

s t

P

Q

To see that thismechanism is notmin-function:

Take two Q bids:b1

Q =(2,1 ), b2Q =(1,2 )

The dashed/solid line is P’s threshold if Q bids b1Q / b2

Q

From the diagram: and they aren’t tied

If the mechanism were a min function, we would have: fP(b1

P) < fQ(b1Q) < fP(b2

P) < fQ(b2Q) < fP(b1

P) - a contradiction

Two s-t disjoint paths (continue)

12211PQPQP bbbbb

Multicast

Problem Statement: A graph , a cost vector

for all nodes, k receiving nodes R. Find a spanning tree to minimize

NP hard without only ln n approximation.

VCG does not apply How to design truthful mechanisms?

),( ENG c

)()( xcTC Tx

Multicasting

Least Cost Path Star (LCPS) Based Pruning Minimum Spanning Tree Based Virtual Minimum Spanning Tree Based Steiner Tree Based

Define Truthful Payment Schemes for these methods Receivers relay for free Network is bi-connected (avoid monopoly)

Commonly Used Structures

Structure Calculate all shortest paths from

source node to receivers Combine these shortest paths The structure is a tree called Least

Cost Path Star (LCPS) Payment Scheme

Calculate the payment for node vk based on every LCP containing vk

Choosing the maximum of these payments as the final payment

0q

34 7

3

9 2

2q

1q

1v

5v

2v

3q4v

6v

3v

1

6693202 qqp 467330

2 qqp

6),max( 2020222 qqqq ppp

7v

LCPS Based Method

Structure Build MST Prune MST

Payment Scheme: Payment based on MST A selected link e

2q

1q

1v

5v

2v

3q4v

6v3

5

4

7

33

1

63

63

1

5

4

2

0q

3v

6

Pruning MST Based Method

ee cGMSTeGMSTp )()\(

Virtual MST algorithm Construct the virtual complete graph K(G)

Nodes are receivers, plus source node Edges are LCP between two end-points

Find the MST on K(G), say VMST(G) Build LCPS at source node using all nodes in

VMST(G), say LCPS-VMST(G) Property

VMST is 5-Approximation of the optimal cost under UDG network model

Virtual MST Based Method

4v3 7

5

9 2

3q

1q

1v

5v

2v

2q

6v

3v

1

0q

4

Construction of LCPS-VMST(G)

0q

34 7

5

9 2

3q

1q

1v

5v

2v

2q4v

6v

3v

1

0q

1q

3q

2q

4 7

8

5 2

5

Algorithm Illustration Virtual MST

Payment Illustration

41v

26v

0q

3 7

5

9

3q

1q

5v

2v

2q4v

3v

1

101)( qqvE 7)\,,( 20110 qqvGqqLE4),,( 10 kcGqqLCP

7),,()\,,( 901901110 GqqLCPvGqqLEcp qq

0q

1q

3q

2q

4 78

5 2

5

VMST(G)

0q

1q

3q

2q

8 78

5 2

5

VMST(G\v1)

evEe pp 1)(1 1

max

Payment Is Truthful!

Individual Rationality (IR): non-negative utility

Incentive Compatibility (IC) A node lies up its cost to

Originally it is a relay node Originally it is not a relay node

A nodes lies down its cost to Originally it is a relay node Originally it is not a relay node

kckc

kckc

Individual Rationality

Observation 1: If C is a cycle of graph G, and e is the longest edge in this cycle, then e is not in MST.

jqiq

IqJq

kv

),,()\,,( GqqLCPvGqqLEcp jikjikek

))(( GKMSTqqev jik

CIn cycle C, the edge with maximum length is not .jiqq

JI qq has the maximum length in C.

)\,,(),,( kjiJIjiji vGqqLEqqqqGqqLCP

kek cp k

ekEek cpp

k max 0 kkk cpu

Lemma

iq

IqJq

kv

jq

IQ JQ

)()( kkkk cEcE

From Lemma 3 and Lemma 4, we focus our attention on the payment of where

ekp )()( kkkk cEcEe

The bridge with the smallest length between and is . ),( JI QQBEMIQ

JQ

Two Cases:),( JIk QQBEMv

),( JIk QQBEMv

kv?

Incentive Compatibility

Payment Optimality

Our payment scheme is optimal regarding every individual payment among all truthful payment scheme based on

LCPS-RMST structure

Steiner Tree Based Method

General Edge weighted Steiner Tree NP-Hard, constant approximation algorithms

exist The existence of the truthful payment How to design the truthful payment based on

approximation algorithms General Node weighted Steiner Tree

NP-Hard, best approximation algorithm O(ln k) The existence of the truthful payment How to design the truthful payment based on

the approximation algorithm

Link Weighted Graphs

Find good multicast tree

0q

3q

1q

1v

5v

2v

2q4v

6v

3v2 3

43 4

5 2 43 44 2

3 2 2 44

3 3

0q

3q

1q

1v

5v

2v

2q4v

6v

3v

Strategyproof Payment

Round based method A node is in round r if its cost is in a

range],[ 1 r

iri BB

0 1riB r

iB

irP


The payment

The overall payment

It is strategyproof!

ri

ri

iir

ir

ir BBccP )|()(

irr Pmax

Node Weighted Graphs

Find good multicast tree

Find a spider connecting some receiversContract themRepeat until all receivers are connected

86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v

||

),(

minT

qudTq

i

Ti

Spiders

Best Spider– approximation ln k

86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v 86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v


Round based method A node is in round r if its cost is in a range In each round, it is in a spider of t terminals if

its cost is in ],[ ,1, tri

tri BB

],[ 1 ri

ri BB

0 1riB r

iB1, triB tr

iB ,

itrP ,


The payment

The overall payment

It is strategyproof!

1,1,, )|()(

)(

tri

tri

iir

iri

r

itr BBcc

ct

tP

itrtr P ,,max

Simulation Setting nodes randomly distributed in a 2000m x

2000m region 100 random instances

Metrics of the overpayment Total Overpayment Ratio (TOR):

Individual Overpayment Ratio (IOR):

Worst Overpayment Ratio:

N

ii i icp )0,(/

)0,(/1

icpn i i

)0,(/ icpMaxi ii

Overpayment: Experiments

Fixed transmission range Transmission range 300m Power for to forward a packet to is

Random transmission range Power for to forward a packet to is

randomly take value from 300 to 500 randomly take value from 10 to 50 Reflect the power cost of 2Mbps wireless

network

iq jq jiqq

iqjq

jiqqcc 21

1c

2c

Overpayment Simulation, cont.

2 5.2

Fixed Transmission Range

2 5.2

Randomized Transmission Range

Anycast

K-Anycast

86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v

Broadcast

86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v86 7

9

4 4

0q

3q

1q

1v

5v

2v

2q4v

6v

3v

5

3

5 5

3

5

Summarize

Truthful computing Credit based Incentive based (mechanism design, VCG)

Unicast (fast and distributed computing)

Multicast (approximation and truthful scheme)

Anycast Broadcast

Other methods

Methods “Watchdog” and “Pathrater” Nuglet counter

Drawbacks Heuristic Special hardware

Credit Based Method

General 0/1 Problems

Settings Each agent is either selected or not Each agent has a private cost (or type) Find some agents so some objective function is

optimized NP-hard for most questions Approximation methods exist already for many

questions To Do

Whether does a method support a truthful mechanism?

How to define and calculate the payment?

Economics and Computer Science Network Routing

Documents