Economics and Computer Science Network Routing CS595, SB 213 Xiang-Yang Li Department of Computer...
-
date post
21-Dec-2015 -
Category
Documents
-
view
216 -
download
2
Transcript of Economics and Computer Science Network Routing CS595, SB 213 Xiang-Yang Li Department of Computer...
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
Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ?
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
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kajp k
ijp
Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ?
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
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kajp k
ijp
Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ?
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
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kajp k
ijp
Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ?
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
Strategyproof Payment
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
Strategyproof Payment
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 ,
Strategyproof Payment
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?