Conference Call 61803: Project Review

1
CS-590A Distributed Network Algorithms Prof.
Gopal Pandurangan Fast Distributed
Construction of Small k-dominating Sets and
Applications -Shay Kutten -David
Peleg January ,2000 Presenter Satyajit Desai
2
Presentation Outline

• Overview Motivation, Results and Related
  Research.
• Terminologies and Model
• Basic Algorithms small k-dominating sets
• O (Diam) Diam being the diameter of the graph
• Distributed Computation small k-dominating set
  on a tree.
• Balanced dominating set algorithm O (log n)
• Fast distributed algorithm for small k-dominating
  set O (k log n)
• Distributed Computation small k-dominating set
  on a graph.
• O (k log n)
• Application fast MST algorithm.
• O (vn log n Diam)
• Discussion and Open Problems

3
Definition A k-dominating set D is the subset
of the graph G such that, for each node v in the
graph, there is a node w in D at distance at most
k from it.
4
Overview

• Motivation Build fast distributed algorithm for
  small k-dominating set problem.
• Applications in routing w/ sparse routing tables.
  PU
• Design of distributed data structures. P2
• Center selection in a distributed network. BKP
• Building faster MST (Minimum Spanning Tree)
  algorithm.

5
Overview

• Results
• Algorithm is termed fast or neighborhood
  optimal for problem P, if its time complexity is
  O (R(P)). Li
• R(P) is the radius from where the information
  needs to be fetched to solve P.
• The small k-dominating set problem has inherent
  radius k.
• Hence, this paper describes the distributed
  algorithm which holds the neighborhood optimality
  upto a factor of log n, hence is fast.

6
Overview

• Related Research
• Distributed algorithm for MST. GHS 83
• O (n log n)
• Improvement in time complexity of two
  message-optimal election algorithms. G 85
• O (n log n)
• Optimal distributed algorithms for MST, counting,
  leader election and related problems. A2 87
• O (n)
• Sub-Linear time distributed algorithm for MST.
  GKP 93
• O (n0.614 Diam)

7
Terminologies and Model

• Terminologies
• G (V, E) undirected graph G with V as set of
  all the nodes and E as set of all the edges.
• k in terms of number of hops.
• P partition of the nodes in G with atleast one
  node from the dominating set D.
• Diam (G) diameter of the graph G maximum
  distance between any two nodes in G.
• Rad (G) radius of the graph G maximum
  distance between any node to a some center node
  in G.
• MST Minimum spanning tree of G, a tree covering
  the nodes in V whose total edge weight is no
  greater than any other spanning tree for G.

8
Terminologies and Model

• Model
• Synchronous network all the nodes start
  computation simultaneously.
• Nodes have unique identifiers and weights of the
  edges are also unique.
• Nodes communicate over communication links.
• Communication cost is ignored.
• Only one message of O (log n) size could be sent
  over one time step.
• Edge weights are polynomial in n , so can be sent
  in a single message.

9
Basic Algorithms small k-dominating sets

• Existence of small k dominating set in an n -
  node graph. PU 89
• Lemma 2.1 For every connected graph G of n
  vertices and for every k 1 there exists a k
  dominating set D such that
• Proof Consider T as the spanning tree
• for graph G and its depth being h.
• If k h then D may consist of root alone.
• Otherwise, divide V into levels T0.Th
  acc.
• to their heights.
• Now merge these sets into k1 sets D0.Dk
• by taking
  .
• Clearly Di is a k dominating set and
  since Tree T, k 2 ,D0 dashed
  lines,
• these sets form a complete disjoint
  partition D1 red solid lines,
• of V , at least one of the sets
  D2 - green solid lines

10
Basic Algorithms small k-dominating sets

• Slow distributed algorithm for computing small k
  - dominating set
• Algorithm Diam_DOM.
• Uses two subroutines Initialize and Census.
• Time complexity O (Diam (G)).
• 
  Procedure Initialize
• 
  
• Perform the distributed BFS on the graph,
  starting from the root r and terminating at r.
  Label every node v by its distance from r, Depth
  (v).
• A node v joins the unique set Dl for 0 l k
  such that Depth (v) l.
• Perform broadcast and echo from r to learn the
  largest distance label M maxvDepth (v)
  (namely, the depth of the tree).
• Broadcast the tree depth M to all the nodes.

11
Basic Algorithms small k-dominating sets

• 
  Procedure Census (l)
• Code for a node v in Depth (v) i, with
  children u1,,up.
• Assumption The procedure starts
  operating at time t0.
• / M is the tree depth /
• 1. If v is not a leaf At time t0 (M i) 1,
  receive from children messages containing the
  values of counter(uj ,l) for 1 j p.
• 2. At time t0 (M i) do
• Compute Below ?j counter(uj ,l).
• Set
• counter(v,l) 1 Below, v ? Dl
• Below, otherwise
• If not the root, send counter(v,l) to parent in
  the tree.
• Lemma 2.2 At the end of Procedure Census (l),
  counter (v, l) holds the number of Dl nodes in
  the subtree rooted at v, for each node v. In
  particular, for the root r, counter (r, l) Dl.

12
Basic Algorithms small k-dominating sets

• 
  Algorithm Diam_DOM
• Apply Procedure Initialize.
• 2. Let t1 be the time unit just after the
  completion of this procedure.
• For l 0 to k do
• At time t1 l, start Procedure Census (l).
• After completion of all Procedure Census (l)
  executions, the root r computes l such that
  counter(r ,l) is the minimum, and broadcasts it
  on the tree.
• Dl is the output k-dominating set.

13
Basic Algorithms small k-dominating sets

• Lemma 2.3 Algorithm Diam_DOM computes the k-
  dominating set claimed in Lemma 2.1, and its time
  complexity is 6 .Diam (G) k.
• Proof Immediate from Lemma 2.2 that the
  algorithm is an implementation of construction in
  Lemma 2.1.
• Time complexity of Procedure Initialize is 4.
  Diam (G) (Broadcast and echo BFS construction).
• Executions of Procedure Census (l) for 0 l k
  never collide. Hence, last Census operation
  terminates after Diam (G) k time.
• Final broadcast requires additional Diam (G)
  time units.
• Hence, total time units are 6.Diam (G) k.

14
Presentation Outline

• Overview Motivation, Results and Related
  Research.
• Terminologies and Model
• Basic Algorithms small k-dominating sets
• O (Diam) Diam being the diameter of the graph
• Distributed Computation small k-dominating set
  on a tree.
• Balanced dominating set algorithm O (log n)
• Fast distributed algorithm for small k-dominating
  set O (k log n)
• Distributed Computation small k-dominating set
  on a graph.
• O (k log n)
• Application fast MST algorithm.
• O (vn log n Diam)
• Discussions and Problems

15
Distributed Computation small k-dominating set
on a tree.

• Fast distributed algorithm for small k-
  dominating set on a tree T.
• Partition a tree T into clusters such that each
  cluster has size k 1 and depth O (k).
• Apply Diam_DOM described previously on each
  cluster.
• Merge the resulting dominating sets.
• Algorithms introduced
• Balanced_DOM constructs balanced dominating
  set in O ( log n).
• DOM_Partition_1(k) constructs ( k1, O (k2))
  spanning forest in O (k2 log n).
• DOM_Partition_2(k) constructs ( k1, O (k))
  spanning forest in O (k log k log n).
• DOM_Partition(k) constructs ( k1, O (k))
  spanning forest in O (k log n).
• Fast_DOM_T constructs small k-dominating set in
  O ( k log n).

16
Distributed Computation small k-dominating set
on a tree.

• Definition A balanced dominating set of a graph
  G with n nodes is a set of nodes in G, and an
  associated partition P of Gs nodes with the
  following properties
• b. D is a dominating set.
• c. In P, each cluster has at least two nodes (
  including the node in D ).
• Lemma 3.3 GKP There exists a distributed
  procedure Small-Dom-Set which, applied to given
  n-vertex tree T for n 2, computes (in a
  synchronous manner) a dominating set D of size at
  most using O (log n) bit messages, and
  its time complexity is O (log n). Furthermore,
  the output of the procedure has the property that
  each node in D has some neighbor outside D.

17
Distributed Computation small k-dominating set
on a tree.

• Algorithm Balanced_DOM
• 1. Perform Algorithm Small-Dom-Set of GKP on
  the tree T.
• Let D and P be the output dominating set and
  partition.
• For every singleton v in P , v quits D, and
• selects arbitrary neighbor u ? D as its
  dominator, D (v) u.
• 3. Each node u ? D selected as dominator in step
  (2) adds
• itself to D, quits its old cluster in P and
  forms a new
• cluster, consisting of itself and all the nodes
  that chose
• it as their dominator.
• Node v ? D whose cluster in new P is singleton,
  chooses arbitrary u that was in its cluster in
  the old partition and left it in step (2), and
  joins its cluster. Also, v quits the dominating
  set.

18
Distributed Computation small k-dominating set
on a tree.

• Lemma 3.4 On a tree of n 2 vertices ,
  Algorithm Balanced _DOM constructs a balanced
  dominating set and requires time O (log n).
• Proof By last property in Lemma 3.3 step (2)
  can always be performed.
• Whenever some node v is left singleton after
  step (3), a node u as defined in step (4) exists.
• v cannot have belonged to a singleton in the
  original partition of step (1), since all of
  those have quit D by step (2). Hence vs original
  cluster must have contained u that has left it by
  step (3).
• Properties (b) and (c) are immediate from the
  algorithm and (a) follows from (c).
• Time bound follows from Lemma 3.3, since all
  additional steps require constant time.

19
Distributed Computation small k-dominating set
on a tree.

• Definition A (s , ?) spanning forest of a graph
  G(V,E) is a collection of disjoint trees T1
  ,..,Tm with the following properties
• the trees consist of edges of E and span all
  the nodes of V,
• each tree contains at least s nodes, and
• the radius of each tree is at most ? .
• Constructing a ( k1, O (k2)) spanning forest
• Lemma 3.5 Algorithm DOM_Partition_1(k) requires
  time O (k2 log n). Every cluster C in the output
  partition P satisfies C k 1 and Rad (C)
  4k2 .

20
Distributed Computation small k-dominating set
on a tree.

• Algorithm
  DOM_Partition_1(k)
• For times do
• Perform Algorithm Balanced_DOM , assigning
• each node not in the dominating set to a cluster
  
• with an arbitrary neighbor in the dominating
  set.
• 2. Contract each cluster to one node.
• End_For

21
Distributed Computation small k-dominating set
on a tree.

• Constructing a (k 1, O (k)) spanning forest.
• Algorithm DOM_Partition_2 (k)

22
Distributed Computation small k-dominating set
on a tree.

23
Distributed Computation small k-dominating set
on a tree.

• 
  

• Time Complexity O ( k log k log n ).
• Proof Each application of Algorithm
  Balanced_DOM takes time O ( log n ), except
  that its
• distributed implementation on the ith
  iteration is slowed down by a factor proportional
  to the
• maximum diameter of clusters at that
  iteration. This diameter is bounded by k, hence
  the total
• time bound of

24
Distributed Computation small k-dominating set
on a tree.

• Lemma 3.6 The collection Pout output by
  Algorithm DOM_Partition_2 is a partition of T.
• Proof Note that whenever we erase a node v from
  some tree during iteration i, we make sure to
  move the corresponding set C (v) of original
  nodes to Pout or to S. Also note that in the
  final step (4), each cluster C (v) in S is either
  moved to Pout or merged into some cluster of Pout
  .
• We now prove that is empty at the end of
  main loop
• Let si denote the minimum size of a cluster Ci
  (v) corresponding to a node v occurring in some
  tree in i , namely ,
• By Lemma 3.4 and property (c) in the definition
  of balanced dominating set, si atleast doubles
  in every iteration i. Since initially si 1, at
  the end of last iteration we have si 1 k
  1, hence i1 must be empty.

25
Distributed Computation small k-dominating set
on a tree.

• Lemma 3.7 If the input tree T is of size n k
  1, then every cluster C in the output
  collection Pout has the following properties.
• C k 1.
• Rad (C) 5k 2.
• Proof For part a. , claim follows from the
  rule in step (3b). This also remains true for the
  final output since sets in Pout can only increase
  in the last step.
• For part b. , consider a cluster Ci1 (v)
  constructed in step (3a). The radius of this
  cluster obeys the relationship Rad (Ci1 (v))
  3r 1, where r is maxw?C Rad (Ci(w)). Claim now
  follows for Ci1 (v) by the fact that the
  clusters Ci(w) that formed it had radius k or
  smaller , hence Rad (Ci1 (v)) 3k 1.
• Merge at the final step results in another 2k
  1 increase in the radius and so claim b.
  follows.

26
Distributed Computation small k-dominating set
on a tree.

• An O ( k log n ) time construction.
• Idea is to execute each phase i only for O (2i)
  time.
• Clusters with depth larger than 2i will not
  participate in further phases.
• Merging for the clusters of smaller size whose
  neighbors are large and hence non-participating
  does not take place till the last step.
• Algorithm DOM_Partition(k) used by adding the
  following instructions before step (3a) in
  Algorithm DOM_Partition_2(k)

27
Distributed Computation small k-dominating set
on a tree.

• Algorithm DOM_Partition(k)

28
Distributed Computation small k-dominating set
on a tree.

29
Distributed Computation small k-dominating set
on a tree.

• Lemma 3.8 The collection Pout output by
  Algorithm DOM_Partition(k) is a partition of T.
  Furthermore, if T is of size n k1, then every
  cluster C in Pout has the following properties.
• C k 1.
• Rad (C) 5k5.
• Proof Cluster which reaches size k 1 is
  eventually put in Pout as in Lemma 3.6. For
  clusters moved to S in the additional step (3-IV
  (B)), note that by arguments similar to those in
  Lemma 3.6 , such a cluster merge into a larger
  cluster in Pout. Hence, we conclude that output
  is a partition.
• Property (a) follows as in Lemma 3.7 for a
  cluster that is put in Pout in step 3(b).
• Property (b) follows again as before for
  clusters in Pout. For clusters generated in the
  last iteration by merging some small clusters C
  onto a non-participating cluster C Ci (u) in
  the additional step (3-IV), the property follows
  from the rule in step (3-IV)(A)(i), noting that
  the node w to which C is connected is at depth k
  or less, and the radius of C itself is at most
  2i1 2k 2, hence the radius of the resulting
  cluster is at most 5k5.

30
Distributed Computation small k-dominating set
on a tree.

• Lemma 3.9 Algorithm DOM_Partition(k) requires
  time O (k log n).
• Proof This is clear from step (3-I), which
  ensures that iteration i takes only O (2i) time.
• Algorithm Fast_DOM_T
• Perform Algorithm DOM_Partition(k), yielding the
  partition P.
• Perform Algorithm Diam_DOM on each cluster Ci of
  the partition P.
• Corollary 3.10 (a) D n/ (k1).
• (b) Rad (P) k.
• Lemma 3.11 The time complexity of Algorithm
  Fast_DOM_T is O (k log n).
• Theorem 3.12 There exists a distributed
  algorithm for computing a k- dominating set of
  size at most n/ (k 1) on a tree, with time
  complexity O (k log n).

31
Distributed Computation small k-dominating set
on a graph.

• Constructing a ( k 1, n ) spanning forest
• Procedure Simple_MST
• Modified version of algorithms in GHS, A2, G.
• High Level Description of Simple_MST
• Nodes group themselves into fragments (F) forming
  the tree T (F).
• Fragment terminates growing when depth is k 1.
• Active fragments (depth is k or smaller) are
  identified by their root id. Each node in F
  knows this id and the MST edges connected to it.
• For fragments that are terminated, ids are not
  clear. They know only three things
• MST edges connected to them
• Fact that the fragment F is terminated.
• Outdated fragment id of the fragment to which
  they belonged before merging.
• In each phase nodes in the active fragment
  co-operate to find the min-weight outgoing edge.
• Message is then sent through this edge to the
  fragment on the other side.
• Termination of the phase is by deciding whether
  the fragment will be active in the next phase.

32
Distributed Computation small k-dominating set
on a graph.

• Procedure Simple_MST
• Operates in phases 1,2, .. log k 1, where
  phase i lasts exactly 5 . 2i 2 time units
• In phase i the root finds out whether the depth
  of its tree is larger than 2i (broadcast and
  echo, so 2 . 2i time units).
• If it is larger, than it does nothing more in
  this phase, but also doesnt terminate.
• If not larger, then root broadcasts the identity
  over the tree.
• Hence, exactly after 2i 1 time units after the
  beginning of identity broadcast, each node knows
• whether its fragment is active or not in the
  current phase.
• Each node now selects its min-outgoing edge and
  convergecasts its weight to the root.
• Hence, after 2i time units of the convergecast
  process, root learns the min-outgoing edge.
• In the next time step ( 2i 1 time units after
  the start of convergecast ) root starts the
  process that transfers the rootship to the end
  point of the min-outgoing edge.
• Hence, exactly 2i time units later that endpoint
  is now the new root and it asks the other end to
• connect.
• The endpoint with the highest identity becomes
  the root of the combined fragment.

33
Distributed Computation small k-dominating set
on a graph.

• Analysis of Simple_MST
• Each phase i lasts O ( 2i ) time, so
• Lemma 4.1 The Simple_MST procedure terminates
  after O (k) time.
• Lemma 4.2 When the Procedure Simple_MST
  terminates, the collection of resulting fragments
  forms a (k 1, n) spanning forest for the graph.
  Moreover, each tree of this forest is a fragment
  of the MST of the graph.
• Lemma 4.3 Procedure Simple_MST terminates after O
  (k) time. Upon termination, the collection of
  resulting fragments forms a (k1, n) spanning
  forest for the graph. Moreover each tree of this
  forest is a fragment of the MST of the graph.

34
Distributed Computation small k-dominating set
on a graph.

• Computing a small k- dominating set on a graph
• Algorithm Fast_DOM_G
• Perform Algorithm Simple_MST, yielding a ( k 1,
  n ) spanning forest F for G.
• Perform Algorithm Fast_DOM_T on each tree Ti in
  the spanning forest F.
• Theorem 4.4 There exists a distributed algorithm
  for computing a k- dominating set of size atmost
  n / ( k 1 ) on a graph, with time complexity O
  ( k log n).

35
Application fast MST algorithm.

• Composed of two parts
• Partition the graph into fragments of the MST
  invoking Fast_DOM_G with k vn.
• Combine the fragments together GKP.
• Here, BFS tree is constructed for the graph.
• Each node sends the description of the
  inter-fragment edges it knows of to its parent.
• Node forwards only the light weight edges and
  those that do not form cycles with edges already
  forwarded.
• This convergecast is fully pipelined GKP.
• Lemma 5.1 When Procedure Pipeline is run on an
  input composed of a fragment graph with N
  fragments of the MST, its running time is bounded
  by O (N Diam(G)), and its output is an MST for
  G.

36
Application fast MST algorithm.

• Algorithm Fast_MST
• Perform Algorithm Fast_DOM_G for k vn.
• Perform Algorithm Pipeline GKP.
• Theorem 5.2 There exists a distributed
  Minimum-weight Spanning Tree algorithm with time
  complexity O (v n log n Diam (G)).
• Proof First part has execution time of O (vn
  log n ) Theorem 4.4
• Second part is bounded by O (vn Diam (G) ) as
  the number of fragments of MST after the
  execution of the first part is N vn . Lemma
  5.1

37
Discussion and Open Problems.

• Still a gap of O (log n) between upper and lower
  bounds for k-dominating set construction problem.
• Better k-dominating set size may exist for a
  particular graph.
• A better time-complexity algorithm might still be
  found for MST problem. Lower bound on time
  complexity still to be found out.
• Need of coming up with tools and
  characterizations for identifying problems for
  which neighborhood optimal algorithms exist and
  hence construct them.

38
Questions ??
39
References

40
References

• 
  

41
References

• 
  

42
References

•