lower bounds for local algorithms
play

Lower Bounds for Local Algorithms Jukka Suomela Aalto University, - PowerPoint PPT Presentation

Lower Bounds for Local Algorithms Jukka Suomela Aalto University, Finland ADGA Austin, Texas 12 October 2014 LOCAL model Input: simple undirected graph G communication network nodes labelled with 54 unique O


  1. Lower Bounds for 
 Local Algorithms Jukka Suomela Aalto University, Finland � ADGA · Austin, Texas · 12 October 2014

  2. LOCAL model • Input: simple undirected graph G • communication network • nodes labelled with 
 54 unique O (log n )-bit 
 12 3 identifiers 23

  3. LOCAL model • Input: simple undirected graph G • Output: each node v produces a local output • graph colouring: colour of node v • vertex cover: 1 if v is in the cover • matching: with whom v is matched

  4. LOCAL model • Nodes exchange messages with each other, 
 update local states • Synchronous communication rounds • Arbitrarily large messages

  5. LOCAL model • Time = number of communication rounds • until all nodes stop and 
 produce their local outputs

  6. LOCAL model • Time = number of communication rounds • Time = distance: • in t communication rounds, 
 all nodes can learn everything 
 in their radius- t neighbourhoods

  7. time t = 2 LOCAL model

  8. LOCAL model � 1 A :

  9. LOCAL model • Everything trivial in time diam( G ) • all nodes see whole G , 
 can compute any function of G • What can be solved much faster?

  10. Distributed 
 time complexity • Smallest t such that the problem 
 can be solved in time t

  11. Distributed 
 time complexity • n = number of nodes • Δ = maximum degree • Δ < n • Time complexity t = t ( n , Δ )

  12. Landscape O (1) log* n log n n Δ log Δ log* Δ O (1)

  13. Landscape O (1) log* n log n n Δ log Δ log* Δ t = O ( Δ + log* n ) O (1)

  14. Landscape O (1) log* n log n n Δ log Δ log* Δ O (1) t = O (log n )

  15. Landscape O (1) log* n log n n Δ log Δ log* Δ t = O (log* Δ ) O (1)

  16. Landscape O (1) log* n log n n Δ log Δ log* Δ O (1)

  17. Landscape O (1) log* n log n n Δ log Δ log* Δ O (1) All problems

  18. Landscape O (1) log* n log n n Δ log Δ log* Δ Maximal O (1) matching

  19. Landscape O (1) log* n log n n Δ log Δ log* Δ Bipartite 
 maximal O (1) matching

  20. Landscape O (1) log* n log n n Δ log Δ log* Δ Linear 
 programming 
 O (1) approximation

  21. Landscape O (1) log* n log n n Δ log Δ log* Δ Weak colouring 
 O (1) (odd-degree graphs)

  22. Landscape O (1) log* n log n n Δ log Δ log* Δ Dominating sets 
 O (1) (planar graphs)

  23. Landscape O (1) log* n log n n Δ log Δ log* Δ our focus today n >> Δ O (1)

  24. Typical state of the art O (1) log* n Δ positive: O (log* n ) log Δ yes tight bounds 
 no as a function of n log* Δ O (1) negative: o (log* n )

  25. Typical state of the art O (1) log* n positive: O ( Δ ) Δ yes log Δ exponential gap 
 ? ? ? as a function of Δ log* Δ no negative: o (log Δ ) O (1)

  26. Typical state of the art O (1) log* n positive: O ( Δ ) Δ yes log Δ exponential gap 
 as a function of Δ log* Δ ? ? ? — or much worse O (1) negative: nothing

  27. fairly well 
 understood O (1) log* n Δ log Δ poorly 
 understood log* Δ O (1)

  28. Example: 
 LP approximation • O (log Δ ): possible • Kuhn et al. (2004, 2006) • o (log Δ ): not possible • Kuhn et al. (2004, 2006)

  29. Example: 
 Maximal matching • O ( Δ + log* n ): possible • Panconesi & Rizzi (2001) • O ( Δ ) + o (log* n ): not possible • Linial (1992) • o ( Δ ) + O (log* n ): unknown

  30. Example: 
 ( Δ +1)-colouring • O ( Δ + log* n ): possible • Barenboim & Elkin (2008), Kuhn (2008) • O ( Δ ) + o (log* n ): not possible • Linial (1992) • o ( Δ ) + O (log* n ): unknown

  31. Example: Bipartite maximal matching • O ( Δ ): trivial • Ha ńć kowiak et al. (1998) • o ( Δ ): unknown

  32. Example: 
 Semi-matching • O ( Δ 5 ): possible • Czygrinow et al. (2012) • o ( Δ 5 ): unknown

  33. Example: 
 Semi-matching • O ( Δ 5 ): possible • Czygrinow et al. (2012) • o ( Δ 5 ): unknown • o ( Δ ): unknown

  34. Example: 
 Weak colouring • O (log* Δ ): possible (in odd-degree graphs) • Naor & Stockmeyer (1995) • o (log* Δ ): unknown

  35. fairly well 
 understood O (1) log* n Δ log Δ poorly 
 understood log* Δ O (1)

  36. Orthogonal challenges? • n : “symmetry breaking” • fairly well understood • Cole & Vishkin (1986), Linial (1992), 
 Ramsey theory … • Δ : “local coordination” • poorly understood

  37. “symmetry breaking” O (1) log* n Δ log Δ “local coordination” log* Δ O (1)

  38. Orthogonal challenges • Example: maximal matching, O ( Δ + log* n ) • Restricted versions: • pure symmetry breaking, O (log* n ) • pure local coordination, O ( Δ )

  39. Orthogonal challenges • Example: maximal matching, O ( Δ + log* n ) • Pure symmetry breaking: • input = cycle • no need for local coordination • O (log* n ) is possible and tight

  40. Orthogonal challenges • Example: maximal matching, O ( Δ + log* n ) • Pure local coordination: • input = 2-coloured graph • no need for symmetry breaking • O ( Δ ) is possible — is it tight?

  41. Maximal matching 
 in 2-coloured graphs • Trivial algorithm: • black nodes send proposals 
 to their neighbours, one by one • white nodes accept the first 
 proposal that they get • “Coordination” ≈ one by one traversal

  42. Maximal matching 
 in 2-coloured graphs • Trivial algorithm: • black nodes send proposals 
 to their neighbours, one by one • white nodes accept the first 
 proposal that they get • Clearly O ( Δ ), but is this tight?

  43. Maximal matching 
 in 2-coloured graphs • General case: • upper bound: O ( Δ ) • lower bound: Ω (log Δ ) — Kuhn et al. • Regular graphs: • upper bound: O ( Δ ) • lower bound: nothing!

  44. Linear-in- Δ bounds • Many combinatorial problems seem to 
 , takes O ( Δ ) time? require “local coordination” • Lacking: linear-in- Δ lower bounds • known for restricted algorithm classes 
 (Kuhn & Wattenhofer 2006) • not previously known for the LOCAL model

  45. Recent progress • Maximal fractional matching • O ( Δ ): possible • SPAA 2010 • o ( Δ ): not possible • PODC 2014

  46. 0 0 0 1 Matching • Edges labelled with integers {0, 1} • Sum of incident edges at most 1 • Maximal matching: 
 cannot increase the value of any label

  47. 0.3 Fractional 
 0.3 0.6 matching 0.4 • Edges labelled with real numbers [0, 1] • Sum of incident edges at most 1 • Maximal fractional matching: 
 cannot increase the value of any label

  48. Maximal fractional matching • Possible in time O ( Δ ) • does not require symmetry breaking • d -regular graph: label all edges with 1/ d • Nontrivial part: graphs that are not regular…

  49. Maximal fractional matching • Not possible in time o ( Δ ), independently of n • note: we do not say anything about e.g. 
 possibility of solving in time o ( Δ ) + O (log* n ) • Key ingredient of the proof: 
 analyse many di ff erent models of 
 distributed computing

  50. ID: unique identifiers Nodes have unique identifiers, 
 output may depend on them 7 23 2 4 3 12 ≠ 9 54

  51. OI: order invariant Output does not change if we change 
 identifiers but keep their relative order 7 23 2 4 3 12 = 9 54

  52. PO: ports & orientation No identifiers 2 1 Node v labels 
 3 incident edges 
 2 1 with 1, …, deg( v ) 1 2 Edges oriented 1

  53. EC: edge colouring No identifiers 3 No orientations 1 1 Edges coloured 
 with O ( Δ ) colours 2

  54. 23 2 3 12 1 3 2 1 2 1 ID PO 1 54 OI EC c 3 a b 1 1 a < b < c < d 2 d

  55. 23 2 3 12 1 3 2 1 2 1 ID PO 1 54 OI EC c 3 a b 1 1 a < b < c < d 2 d

  56. Simulation argument • Trivial: ID → OI → PO • for any problem • We show: EC → PO → OI → ID • for maximal fractional matching 
 in “loopy graphs”

  57. Proof overview • EC model is very limited • maximal fractional matching requires 
 Ω ( Δ ) time in EC, even for “loopy graphs” • Simulation argument: EC → PO → OI → ID • maximal fractional matching requires 
 Ω ( Δ ) time in ID, at least for “loopy graphs”

  58. 3 1 1 EC 2 • Recursively construct a degree- i graph 
 where this algorithm takes time i • Focus on “loopy graphs” • highly symmetric • forces algorithm to produce “tight” outputs 
 (all nodes saturated, “perfect matching”)

  59. EC → PO “Unhelpful” port numbering & orientation 6 3 2 5 1 3 1 4 EC PO 2

  60. 53 45 31 52 PO → OI 39 51 25 44 37 13 50 41 49 2 14 38 “Unhelpful” 
 29 43 15 40 30 48 23 47 1 total order 3 3 9 42 17 27 35 1 46 4 4 2 2 36 can be easily 
 10 28 3 16 21 34 constructed given 
 24 33 1 4 22 11 26 19 a port numbering 
 5 32 6 20 and orientation 12 7 18 8

  61. OI → ID “Unhelpful” unique identifiers Ramsey-like argument: 
 for any algorithm we can find unique identifiers 
 that do not help in comparison with total order

  62. EC → PO → OI → ID • In general: stronger models help • In our case: we can always come up 
 with situations in which ID model 
 is not any better than EC model

Recommend


More recommend