1. The selfish-edges Shortest-Path problem

2. The selfish-edges SP problem Input: an undirected graph G=(V,E) such that each edge is owned by a distinct selfish agent, a source node s and a destination node z; we assume that agent’s private type is the positive cost (length) of the edge, and his valuation function is equal to his type if edge is selected in the solution, and 0 otherwise. SCF: a (true) shortest path in G between s and z.

3. Notation and assumptions n=|V|, m=|E| d G (s,z): distance in G=(V,E,r) between s ans z (sum of reported costs of edges on a shortest path P G (s,z)) Nodes s and z are 2-edge-connected in G, i.e., there exists in G at least 2 edge disjoint paths between s and z  for any edge of P G (s,z) removed from the graph there exist at least one replacement path in G-e between s and z (this will bound the problem, since otherwise a bridge-edge might have an unbounded marginal utility)

4. VCG mechanism The problem is utilitarian (indeed, the cost of a solution is given by the sum of the valuations of the selected edges)  VCG-mechanism M= : g(r): computes P G (s,z) in G=(V,E,r) p e : for each e  E: p e =  j≠e v j (r j,x(r - e )) -  j≠e v j (r j,x), namely d G-e (s,z)-(d G (s,z)-r e ) if e  P G (s,t) 0 otherwise  For each e  P G (s,z), we have to compute d G-e (s,z), namely the length of a shortest path in G-e =(V,E\{e},r -e ) between s and z. pe=pe= {

5. The best replacement path s z e 2 2 3 4 5 6 5 10 5 12 P G-e (s,z) P G (s,z) Remark: p e  r e, since d G-e (s,z)  d G (s,z)

6. A trivial but costly implementation Step 1: First of all, apply Dijkstra to compute P G (s,z)  this costs O(m + n logn) time by using Fibonacci heaps. Step 2: Then,  e  P G (s,z) apply Dijkstra in G-e to compute P G-e (s,z)  we spend O(m + n logn) time for each of the O(n) edges in P G (s,z), i.e., O(mn + n 2 logn) time  Overall complexity: O(mn + n 2 logn) time We will see an efficient solution costing O(m + n logn) time

7. Notation S G (s), S G (z): single-source shortest paths trees rooted at s and z M s (e): set of nodes in S G (s) not descending from edge e (i.e., the set of nodes whose shortest path from s does not use e) N s (e)=V/M s (e) M z (e), N z (e) defined analogously

8. A picture s u v z e Ms(e)Ms(e) Ns(e)Ns(e) S G (s)

9. Crossing edges (M s (e),N s (e)) is a cut in G C s (e)={(x,y)  E\{e}: x  M s (e), y  N s (e)} edges “belonging” to the cut: crossing edges

10. Crossing edges s u v z e Ms(e)Ms(e) Ns(e)Ns(e) S G (s) Cs(e)Cs(e)

11. What about P G-e (s,z)? Trivial: it does not use e It must cross the cut C s (e) It is shortest among all the paths between s and z not using e Its length is: where w(f) denotes the cost declared for f. d G-e (s,z)= min {d G-e (s,x)+w(f)+d G-e (y,z)} f=(x,y)  C s (e)

12. The path P G-e (s,z) s u v z e x y d G-e (s,z)= min {d G-e (s,x)+w(f)+d G-e (y,z)} f=(x,y)  C s (e)

13. How to compute d G-e (s,z) Let f=(x,y)  C s (e); we will show that d G-e (s,x)+w(f)+d G-e (y,z)=d G (s,x)+w(f)+d G (y,z) Remark: d G-e (s,x)=d G (s,x), since x  M s (e) Lemma: Let f=(x,y)  C s (e) be a crossing edge (x  M s (e)). Then y  M z (e) (from which it follows that d G-e (y,z)=d G (y,z)).

14. A simple lemma Proof (by contr.) Let y  M z (e), then y  N z (e). Hence, y is a descendant of u in S G (z), and P G (z,y) uses e. But P G (v,y) is a subpath of P G (z,y), and then: d G (v,y)=w(e) + d G (u,y) > d G (u,y). But y  N s (e), then P G (s,y) uses e. But P G (u,y) is a subpath of P G (s,y), an then: d G (u,y)=w(e) + d G (v,y) > d G (v,y).

15. A picture s z N s (e)  M z (e) Ms(e)Ms(e)

16. Computing best replacement paths Given S G (s) and S G (z), in O(1) time we compute: k(f):= d G-e (s,x) + w(f) + d G-e (y,z) d G (s,x) given by S G (s) Remark: k(f) is the length of a shortest path between s and z passing through f d G (y,z) given by S G (z)

17. A corresponding algorithm Step 1: Compute S G (s) and S G (z) Step 2:  e  P G (s,z) check all the crossing edges in C s (e), and take the minimum w.r.t. k(). Time complexity Step 1: O(m + n logn) time Step 2: O(m) crossing edges for each of the O(n) edges on P G (s,z): total of O(mn) time  Overall complexity: O(mn) time Improves on O(mn + n 2 logn) if m=o(n logn)

18. A more efficient solution: the Malik, Mittal and Gupta algorithm (1989) MMG have solved in O(m+n log n) time the following related problem: given a SP P G (s,z), what is its most vital edge, namely an edge whose removal induces the worst (i.e., longest) best replacement path between s and z? Their approach computes efficiently all the best replacement paths between s and z… …but this is exactly what we are looking for in our VCG-mechanism!

19. The MMG algorithm at work Let e 1, e 2,…, e q be the edges of P G (s,z) from s to z, in this order. At Step i, we maintain in a heap H the set of nodes N s (e i ) (initially H=V) Let us call active the nodes in H. With each node y  H, we associate a key k(y) and a corresponding crossing edge, as follows: k(y)= min {d G (s,x)+w(x,y)+d G (y,z)}  k(y) is the length of a SP in G-e i from s to z passing through the active node y (x,y)  E, x  M s (e i )

20. The MMG algorithm at work (2) Initially, H =V, and k(y)=+  for any y  V Consider e 1, e 2,…, e q one after the other. When edge e i is considered, modify H as follows: Remove from H all the nodes in W s (e i )=N s (e i-1 )\N s (e i ) Consider all the edges (x,y) s.t. x  W s (e i ) and y  H, and compute k’(y)=d G (s,x)+w(x,y)+d G (y,z). If k’(y)<k(y), decrease k(y) to k’(y), and update the corresponding crossing edge to (x,y) Then, find the minimum in H w.r.t. k(), which returns the length of a best replacement path for e i (i.e., d G-e i (s,z)), along with the selected crossing edge

21. An example N s (e 1 ) e1e1 e2e2 e3e3 e5e5 e4e4 s z W s (e 1 )

22. An example (2) N s (e 2 ) e1e1 e2e2 e3e3 e5e5 e4e4 s z W s (e 2 )

23. Time complexity of MMG Theorem: Given a shortest path between two nodes s and z in a graph G with n vertices and m edges, all the best replacement paths between s and z can be computed in O(m + n log n) time.

24. Time complexity of MMG Proof: Compute S G (s) and S G (z) in O(m + n logn) time. Then, use a Fibonacci heap to maintain H, on which the following operations are executed: A single make_heap O(n) insert O(n) find_min O(n) delete O(m) decrease_key In a Fibonacci heap, the amortized cost of a delete and a delete_min is O(logn), while insert, find_min, decrease_key,make_heap cost O(1), so O(m + n logn) total time

25. Plugging-in the MMG algorithm into the VCG-mechanism Corollary There exists a VCG-mechanism for the selfish- edges SP problem running in O(m + n logn) time. Proof. Running time for g(): O(m + n logn) (Dijkstra). Running time of p(): O(m + n logn), by applying MMG to compute all the distances d G-e (s,z).