1 vertices. In any broadcast scheme for G and m 1 messages, we have. P. v2G sends(v) ...... have S1;0 = f001g, S1;1 = f001;011g and S1;2 = f001;011;101;111g.
MULTIPLE MESSAGE BROADCASTING by Matthew Suderman B.Sc. Trinity Western University 1997 A THESIS SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF
Master Of Science in the School of Computing Science
c Matthew Suderman 1999
SIMON FRASER UNIVERSITY September 1999
All rights reserved. This work may not be reproduced in whole or in part, by photocopy or other means, without the permission of the author.
Approval Name: Degree: Title of thesis:
Matthew Suderman Master of Science Multiple Message Broadcasting
Examining Committee: Dr. Hovhannes Harutyunyan Chair
Dr. Arthur Liestman, Senior Supervisor
Dr. Joseph Peters, Supervisor
Dr. Thomas Shermer, Examiner
Date Approved:
ii
Abstract Broadcasting is the information dissemination process in which one or more messages are sent from one member of a network to all other members by a series of calls between members. In a call, one member sends a message to another adjacent member in the network. Members can participate in at most one call per time unit. Within this model, we provide new bounds on the number of time units required to broadcast multiple messages in speci c network con gurations such as paths, trees, cycles, grids and hypercubes. We also nd sparse network con gurations containing up to ten members in which we can broadcast multiple messages in minimum time.
iii
Contents Approval
ii
Abstract
iii
List of Tables
v
List of Figures
vi
1 Introduction
1
1.1 1.2 1.3 1.4
Formal De nition History . . . . . . Motivation . . . . Plan . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
1 2 3 4
2 Lower Bound Techniques
5
3 Broadcasting in Speci c Graphs
7
3.1 3.2 3.3 3.4 3.5
Broadcasting in a Path . . . . Broadcasting in Trees . . . . . Broadcasting in a Cycle . . . Broadcasting in a Grid . . . . Broadcasting in a Hypercube
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. 7 . 8 . 11 . 23 . 24
4 Bounds on Bm(n)
38
5 Conclusions and Open Problems
61
References
62
A Details for Proving B5i+3(10) 15 and B5i+4(10) 15
65
4.1 Lower Bounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 4.2 Exact Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
iv
List of Tables 1 1 1 1 2 2 2 2 2
(Part 1 of 4) Edge call times from scheme described in Figure 16. (Part 2 of 4) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (Part 3 of 4) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (Part 4 of 4) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (Part 1 of 5) Edge call times from scheme described in Figure 20. (Part 2 of 5) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (Part 3 of 5) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (Part 4 of 5) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . (Part 5 of 5) . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
v
. . . . . . . . .
. . . . . . . . .
66 67 68 69 69 70 71 72 73
List of Figures 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
A scheme for broadcasting m messages from vertex vx in Pn . . . . . . A scheme for broadcasting m messages from vertex u in a complete tree with maximum degree four and height two. . . . . . . . . . . . . A 3-dimensional hypercube with bit-string vertex labels. . . . . . . . A 4-dimensional hypercube with bit-string vertex labels. . . . . . . . Phases one and two of a scheme for a 3-dimensional hypercube. . . . Phase three of a scheme for a 3-dimensional hypercube. . . . . . . . . Modi cations of a scheme for a 3-dimensional hypercube. . . . . . . . Modi cations of a scheme for a 4-dimensional hypercube. . . . . . . . Tm(Kn ) for 3 n 16 and 1 m 15. . . . . . . . . . . . . . . . . A graph on seven vertices and eight edges. . . . . . . . . . . . . . . . Broadcast schemes for the graph in Figure 10. . . . . . . . . . . . . . The only eight vertex graph on nine edges such that each vertex has at least two neighbors and each degree two vertex has a degree three neighbor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A member of MMBG(8; 2) . . . . . . . . . . . . . . . . . . . . . . . Schemes for broadcasting two messages in the graph from Figure 13. A member of MMBG(10; m), m 3(mod 5). . . . . . . . . . . . . . (Part 1 of 2) Scheme for broadcasting 5i + 3 messages in 9i + 7 time units in the graph from Figure 15 where i is any integer greater then or equal to 0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A member of MMBG(10; 2). . . . . . . . . . . . . . . . . . . . . . . Schemes for broadcasting two messages in the graph from Figure 17. . Scheme for broadcasting ve messages in the graph from Figure 15. . (Part 1 of 2) Scheme for broadcasting 5i + 4 messages in 9i + 9 time units in the graph from Figure 15 where i is any integer greater than or equal to 0. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vi
8 10 24 25 27 28 34 36 41 44 45 48 49 50 51 51 54 55 56 58
1 Introduction Broadcasting is the process of disseminating one or more messages from one member of a network, called the originator, to all other members by a series of calls between members. A call consists of one member sending a message to another adjacent member in the network. We make the simplifying assumption that time is discrete meaning that everything occurring in a single time unit occurs simultaneously. There are many broadcast models based on the de nitions so far; however, the model we will be using simply adds the additional constraint that a member may be involved in at most one call per time unit. Within the constraints of this model, we will attempt to nd sparse network con gurations in which we can broadcast multiple messages in minimum time. By sparse network con gurations we mean con gurations with a minimum number of links and by minimum time we mean the time needed to broadcast multiple messages in a completely connected con guration.
1.1 Formal De nition We use a graph G = (V; E ) to model a network con guration by letting the vertices of V correspond to the members of the network and the edges of E correspond to the links of the network. For convenience, then, we will refer to networks as graphs in what follows letting M = fM1; M2; :::; Mmg be the set of m messages being broadcast and V = fv0; v1; :::; vn?1g. We then use Tm(G) to denote the minimum number of time units needed to broadcast m messages from any vertex in G. It is easy to see that Tm(Kn ) Tm(G); that is, the minimum time to broadcast m messages in any graph on n vertices can be achieved in the complete graph. We use Bm (n) to denote the minimum number of edges in any graph G0 on n vertices such that Tm(G0) = Tm(Kn ). For such a graph G0 we say that G0 2 MMBG(n; m). A broadcast scheme is a schedule of calls satisfying the following constraints:
A message arrives at a vertex before the vertex sends it. 1
Each vertex is involved in at most one call per time unit as either sender or receiver but not both.
Each vertex receives every message once except the originator which does not receive any messages.
1.2 History As mentioned in Section 1, many broadcast models have been investigated. Some are less restrictive than our model. For instance, the simultaneous send/receive model permits a member to send one message and receive one other message in a single time unit. This model has been investigated by Bar-Noy and Ho ([3]) and Kwon and Chwa ([15]). A slightly more restrictive model investigated by Bar-Noy, Kipnis and Schieber ([5]) also allows a member to send and receive in a single time unit however the member must send to and receive from the same neighbor. In other words, a call involves two members exchanging messages. Other models place restrictions on the links. For instance, Liestman and Peters ([16]) consider graphs where each link can transport messages in one direction; that is, directed graphs. The models described so far are fairly abstract. Other models such as the LogP ([22]), multiport ([2]) and postal ([4]) models attempt to model speci c computer networks more closely. For example, the LogP model modi es simultaneous send/receive introducing communication latency. Much of the work on broadcasting multiple messages has involved nding optimal broadcast schemes in speci c graphs. Examples include complete graphs ([8, 9, 11]), hypercubes, grids ([21, 23, 24]), general trees ([12]), and positive weighted trees ([1]). We note the following result for complete graphs obtained by Cockayne and Thomason ([9]).
Theorem 1.1 For any m 1 and n 3, 8 > < 2m + blog nc ? 1 Tm(Kn ) = > blog : 2m + blog nc ? m?1+2 2 n
2
nc
for n odd for n even
Notice that Tm(Kn ) is the same for even and odd n when m < n ? 2blog nc +1; however, for larger m, it is smaller for even n than for odd n. Very roughly, we can broadcast more eciently when n is even because n being even and m large enough allows us to de ne a broadcast scheme for Kn in which we can have every vertex involved in a call during certain time units. On the other hand, when n is even at least one vertex must be idle during each time unit. Most of the work investigating sparse network con gurations has been restricted to broadcasting a single message; that is, nding values for B1(n). Currently, values for B1(2k ) and B1(2k ? 2) and several speci c values for B1(n) when n < 64 are known. Some work in this area has been done recently ([6, 10, 13]) and a survey of the work on this and other similar problems has been published ([14]). We will extend this work by investigating multiple message broadcasting.
1.3 Motivation Broadcasting is a communication operation supported by many network systems. It is important, then, to investigate how eciently the operation can be completed in speci c network con gurations such as cycles and grids and to discover con gurations in which it can be completed in minimal time. In some such systems multiple message broadcasting may be more ecient than single message broadcasting. In a system where the time to send a message across a link is directly proportional to the length of the message, it may be more ecient for the originator to broadcast m messages of length l=m than to broadcast a single message of length l. For instance, suppose that a network N contains an odd number of vertices, n, and Tm(N ) = Tm(Kn ) for all m 1. From Theorem 1.1, we have Tm(Kn ) = 2m + blog nc ? 1 and therefore T1(Kn ) = blog nc + 1. Suppose also that it requires p + kl time units to send a message of length l across a network link; that is, p time units of overhead to send a message and kl time units send the message across the link. With these assumptions, we require (p + kl) blog nc time units to broadcast a single message of length l and (p + k(l=m))(2m + blog nc ? 1) time units 3
to broadcast m messages of length l=m. Thus, it is more ecient to broadcast m messages of length l=m than one message of length l when (p + k ml )(2m + blog nc ? 1) < (p + kl)(blog nc + 1) 2pm < blog nc ? 1 kl So, given constants n, p and k for some network and length l of a message it is a simple calculation to determine for which m multiple message broadcasting will be more ecient than single message broadcasting. Finally, we note that multiple message broadcasting bears a close resemblance to perpetual gossiping ([17]) so results found in multiple message broadcasting may be useful in investigating perpetual gossiping and vice versa. Work of this type has not yet been attempted.
1.4 Plan In Section 2, we provide some simple lemmas that will be useful for proving lower bounds for the functions Tm and Bm. In Section 3, we will investigate broadcasting in paths, trees, cycles, grids and hypercubes. For most con gurations, we will prove a lower bound on the broadcast time and then describe a broadcast scheme which in most cases will match the lower bound. These results will then be used in Section 4 to prove bounds for Bm.
4
2 Lower Bound Techniques In this section we provide some simple lemmas which will be used later to prove lower bounds for the functions Tm and Bm. The rst is a trivial lower bound for Tm based on the observation that any graph G on n vertices is a subgraph of the complete graph Kn so any broadcast scheme for G is also a broadcast scheme for Kn .
Lemma 2.1 Let G be any graph on n 1 vertices; then, for any m 1, Tm(G) Tm(Kn ).
The remaining lemmas use the following function de nitions. For some broadcast scheme, rst(v) is the time when v receives its rst message in the scheme and sends(v) is the number of times v sends a message in the scheme. The next lemma shows that if a vertex is a cutpoint in a graph then it acts as a broadcast \bottleneck" in the graph.
Lemma 2.2 Let G be a graph containing a cutpoint v whose removal from G results in c connected components. A broadcast scheme for any orginator w = 6 v will then require at least rst(v) + cm ? 1 time units. If v is the originator then a broadcast scheme will require at least cm time units. Proof. If v is not the originator w then since v is a cutpoint whose removal results in c connected components then w must belong to one of the c components. As a result, v must send m messages to each of the c ? 1 other components. In addition, v must receive m messages so it will be involved in at least cm calls. The rst of these calls occurs at time rst(v) so the scheme requires at least rst(v) + cm ? 1 time units. If, on the other hand, v is the originator then v must send m messages to each of the c components so the scheme requires at least cm time units. 2
A simple observation is that the sum of sends(v) over all vertices v in a graph for a scheme is exactly the number of calls made in the scheme.
Lemma 2.3 Let G be a graph on n 1 vertices. In any broadcast scheme for G P and m 1 messages, we have v2G sends(v) = m(n ? 1). 5
Proof. Broadcasting m messages to n ? 1 vertices requires exactly m(n ? 1) calls.
Since each of these calls includes one sender and one receiver, counting the number of sends should yield the number of calls. 2
We can place upper bounds on sends(v) based on two pieces of information: the number of neighbors that a vertex v has and the amount of time the broadcast scheme uses.
Lemma 2.4 Let v be a vertex with d neighbors. If v is the originator then sends(v) dm; otherwise, sends(v) (d ? 1)m. Proof. Clearly a vertex can call a neighbor at most m times; therefore, if a vertex
has d neighbors it can be involved in at most dm calls. If the vertex is the originator then it can be the sender in each of these calls. On the other hand, if the vertex is not the originator then it must receive m messages so can be the sender in at most dm ? m of the calls. 2
Lemma 2.5 In a broadcast scheme for any originator u in G using t time units sends(u) t and sends(v) t ? ( rst(v) + m ? 1) for v 6= u. Proof. Clearly, the originator u can make at most one call per time unit and so can send at most once per time unit. Any other vertex v = 6 u cannot send before time rst(v) and must receive m ? 1 messages after time rst(v) so can send at most t ? ( rst(v) + m ? 1) times. 2
6
3 Broadcasting in Speci c Graphs In this section we prove upper and lower bounds on the broadcast times for speci c graphs: paths, trees, cycles, grids and hypercubes. These graphs are of interest because they are sparse and therefore useful in Section 4 where we investigate the function Bm(n). In fact, a broadcast graph must be connected so paths and trees contain the absolute minimum number of edges.
3.1 Broadcasting in a Path Let Pn be a path on n vertices where V (Pn ) = fv0; v1; :::; vn?1g and E (Pn) = f(vi; vi+1)j0 i n ? 2g. In the following theorem, we prove an exact value for Tm(Pn ). Though simple, it is important to understand this proof and the accompanying diagrams because the underlying ideas will be reused to prove time bounds for more complicated graphs later on.
Theorem 3.1 For any m 1,
8 >
Proof. For n 3 the result is easily veri ed. Assume that n 4. Let vx 2 V (Pn ) be the broadcast originator and assume, l m without loss of generality, that 0 x n2 ? 1. Since n 4, vn?2 is between vx and
vn?1. Notice also that vn?2 is a cutpoint of Pn so we can use Lemma 2.2 to obtain a lower bound for Tm(Pn ). If the originator is v0 then rst(vn?2) n ? 2 so by Lemma 2.2 we have Tm(Pn ) 2m + n ? 3. Figure 1 illustrates a broadcast scheme for originator vx. To understand the gure, consider some edge e with label t; then, message Mi is sent across edge e at time t + 2(i ? 1) for each i, 1 i m. If e is to the left of vx then the message is sent left; otherwise, right. Vertex vn?1 receives its last message at time (n ? x ? 1) + 2(m ? 1) and v0 receives its last message at time (x + 1) + 2(m ? 1). 7
x+1 v0
3 v1
vx-2
2 vx-1
1 vx
2 vx+1
n-x-1 vx+2
vn-2
vn-1
Figure 1: A scheme for broadcasting m messages from vertex vx in Pn . Therefore, Tm(Pn ) maxf2m + n ? x ? 3g [ f2m + x ? 1g = 2m + n ? 3. This matches the lower bound so Tm(Pn ) = 2m + n ? 3 for n 4. The scheme is valid because:
Each message arrives at a vertex before the vertex sends it. This follows from the fact that message send times increase as one moves away from the originator vx .
Each vertex is involved in at most one call per time unit. This follows from the fact that if edges e and e0 are incident on the same vertex then messages are sent along e during even time units and along e0 during odd time units, or vice versa.
Each vertex except the originator receives all m messages. Clearly, both v0 and
vn?1 receive all m messages from vx. Since each message arrives at a vertex before the vertex sends it, then all vertices between v0 and vx and vn?1 and vx must receive all m messages.
2
3.2 Broadcasting in Trees We prove a general lower bound for broadcasting in trees and an exact value for broadcasting in complete d-ary trees of height h. A complete d-ary tree of height h is a rooted tree in which every vertex of distance less than h from the root has d neighbors and every vertex of distance h from the root has 0 children.
Lemma 3.2 Let T be a tree on n vertices with maximum degree d. Then, for any m 1, Tm(T ) dm. 8
Proof. Every non-leaf is a cutpoint in a tree so the result follows from Lemma 2.2.
2
Theorem 3.3 Let T be a complete d-ary tree of height h 1 with d 2. Then, for any m 1, Tm (T ) = (m + h ? 1)d. Proof. Let vr be the root of T . Let u and w be leaves in T such that vr is on the
path from u to w. Let u0 be the parent of u and w0 be the parent of w. Finally, let vu be the child of vr on the path from u to vr and vw be its child on the path from vr to w. Consider a broadcast scheme in which u is the originator. Since w0 is a cutpoint of T we can apply Lemma 2.2 to get a lower bound for Tm(T ). Thus, Tm(T ) rst(w0) + dm ? 1. In such a scheme, rst(vr ) h. Because T is complete, vr is the parent of d isomorphic subtrees; therefore, without loss of generality, assume that vw is the last to receive a message. That is, rst(vw ) h + d ? 1. Similarly, vw and all of its non-leaf descendents are each parents of d ? 1 isomorphic subtrees; therefore, without loss of generality, assume that each vertex along the path from vw to w is the last of its siblings to receive a message. As a result, rst(w0) h +(h ? 1)(d ? 1). Therefore, the lower bound for Tm(T ) above becomes Tm(T ) h + (h ? 1)(d ? 1) + dm ? 1 = (m + h ? 1)d. We now describe a broadcast scheme showing that Tm(T ) (m + h ? 1)d. In the scheme, a non-leaf originator vo sends message i to its d neighbors (in the same order for each message) at times d(i ? 1)+1, d(i ? 1)+2, ..., d(i ? 1)+ d. If vo is not the root then it sends a message rst to its parent before sending that message to its other neighbors. If vo is a leaf then it sends message i to its parent at time d(i ? 1) + 1. The other vertices receive message i at time rst(v) + d(i ? 1). If v is not a leaf and not the originator then v forwards message i to its d ? 1 other neighbors (in the same order for each message) at times rst(v) + d(i ? 1) + 1, rst(v) + d(i ? 1) + 2, ..., rst(v) + d(i ? 1) + d ? 1. If v is on the path from vo to vr then v sends a message rst to its parent before sending that message to its other neighbors. See Figure 2 for an example of this scheme. The label next to each edge indicates the time of the 9
vr 2
1
3
4
3
4
5
5
4
6
5
u
6
7
6
7
8 w
Figure 2: A scheme for broadcasting m messages from vertex u in a complete tree with maximum degree four and height two. rst call across that edge. Vertex u is the originator of the scheme and vertex w is the last vertex to receive all m messages. The scheme is valid because:
A message arrives at a vertex before the vertex sends it. This follows clearly from the way the scheme is de ned.
Each vertex is involved in at most one call per time unit. This follows from the
fact that if a vertex calls a neighbor at time t then, if a subsequent call to that neighbor is necessary, that call will occur at time t + d, the time immediately after the neighbor has nished calling it's d ? 1 other neighbors.
Each vertex receives every message once except the originator which does not receive any messages. The root v receives all m messages by time d(m?1)+h so the last leaf receives all m messages by time d(m?1)+h+h(d?1) = (m+h?1)d. 2 Investigating Tm for trees of up to ten vertices suggests that, for small m, Tm is minimized for trees with higher maximum degree but, for larger m, Tm is minimized for trees with lower maximum degree. The following conjecture states this more formally. 10
Conjecture 3.4 Let T be a tree with maximum degree d 3 such that for all trees T 0 with the same maximum degree Tm(T ) Tm(T 0). Let U be a tree with maximum degree 2 d0 < d such that for all U 0 with the same maximum degree Tm(U ) Tm(U 0). There exists a p 1 such that Tm(U ) Tm(T ) for all 1 m p. For example, for trees on ten vertices the best tree with degree at least four requires time 4m + 1, the best tree with degree three requires time 3m + 3 and the best tree with degree two (ie. a path) requires time 2m + 7. Clearly as m gets larger the best trees over all have increasingly smaller maximum degree.
3.3 Broadcasting in a Cycle Let Cn be a cycle on n vertices where
V (Cn) = fv0; v1; :::; vn?1g and
E (Cn) = f(vi; v(i+1)mod n)j0 i n ? 1g: In what follows, we assume that vertex subscript addition and subtraction is modulo n. We also assume, without loss of generality, that v0 is the originator and calls its neighbor v1 rst in any scheme. We begin our investigation of cycles by describing a simple broadcast scheme based on the path scheme de ned in Theorem 3.1 in order to obtain an upper bound on Tm(Cn). l m
Theorem 3.5 For any m 1 and n 3, Tm(Cn ) 2m + n2 ? 2. Proof. We simply apply the path scheme from Theorem 3.1 to the path created by removing edge (vd 2 e?1 ; vd 2 e ) from the cycle. Then, in terms of that scheme, the l m originator x is in the middle of the path; that is, x = n2 ? 1 so the scheme requires l m max(2m + x ? 1; 2m + n ? x ? 3) = 2m + n2 ? 2 time units. 2 n
n
For a given broadcast scheme with originator v0 broadcasting m messages, we de ne fi to be the number of messages that vi sends directly to vi+1 and ri to be 11
the number of messages vi sends directly to vi?1. One could view fi as the number of messages being sent \forward" and ri as the number of messages being sent in \reverse". The following lemmas constrain the possible values of fi and ri.
Lemma 3.6 If i 6= n ? 1 then fi + ri+2 = m; otherwise, fn?1 = r1 = 0. Proof. Vertex vi+1 receives exactly fi + ri+2 messages. Since every vertex except the originator must receive m messages, fi +ri+2 = m for any i = 6 n?1 and fn?1 = r1 = 0. 2
Lemma 3.7 If i 6= n ? 1 then fi fi+1 and if i 6= 1 then ri ri?1. Proof. By de nition, vi+1 receives fi + ri+2 messages: fi from vi and ri+2 from
vi+2. Also by de nition, vi+1 sends fi+1 messages to vi+2. So, if fi+1 > fi, then vi+1 sends more messages to vi+2 than it receives from vi. Thus it is either sending messages to vi+2 that it received from vi+2 or it is sending the same messages more than once. In either case we have an invalid scheme. The only exception to this involves the originator v0 because it sends messages but does not receive any in an optimal scheme. A similar argument proves that ri ri?1. 2 The following two lemmas are the keys to proving Theorem 3.10. We de ne ci to be the number of calls that are made along the edge fvi; vi+1g; that is, ci = fi + ri+1. In the next lemma we show that the sum of calls across each edge is equal to m(n ? 1) as it should.
Lemma 3.8 Pni=0?1 ci = m(n ? 1) Proof. By de nition, Pni=0?1 ci = Pni=0?1 (fi + ri+1 ). Since Pni=0?1(fi + ri+1) = Pni=0?1 fi + Pn?1 Pn?1 Pn?1 2 i=0 ri = i=0 (fi + ri+2 ), then by Lemma 3.6 i=0 ci = m(n ? 1). The next lemma basically states that each vertex in a cycle will be involved in at least m calls and in at most 2m calls.
Lemma 3.9 Let the broadcast scheme use a total of t time units. Then, m ci + ci+1 min(2m; t ? min(i; n ? i ? 1)). 12
Proof. By de nition, ci + ci+1 is the total number of calls vi+1 makes. If vi+1 is not
the originator then it must receive m messages; otherwise, if the vi+1 is the originator then it must send m messages. Both cases require ci + ci+1 m. By Lemma 2.4, if vi+1 is the originator then sends(vi+1) 2m; otherwise, sends(vi+1) m. So, the originator makes at most 2m calls because it does not receive any messages. Every other vertex also makes at most 2m calls because they receive exactly m messages. Therefore, ci + ci+1 2m. By Lemma 2.5, if vi+1 is the originator then sends(vi+1) t; otherwise, sends(vi+1) t ? rst(vi+1) ? m + 1. The distance between v0 and vi+1 is min(i; n ? i ? 1) + 1 so rst(vi+1) min(i; n ? i ? 1)+1; thus if vi+1 is not the originator then sends(vi+1) t ? m ? min(i; n ? i ? 1). Vertex vi+1 receives m messages so can make at most m + (t ? m ? min(i; n ? i ? 1)) = t ? min(i; n ? i ? 1) calls. Thus, ci + ci+1 t ? min(i; n ? i ? 1). 2 We now use the above lemmas to prove a lower bound for Tm(Cn ) when n is even. Later, in Theorem 3.11, we describe a broadcast scheme which provides a matching upper bound. Theorem 3.10 For even n and any m 1, 8 p > < 2m + n ? 1+ 8m+1 m n(n?2) 8 Tm(Cn ) > 2m(n?1)2 n?2 2 n ( n : + 4 m > 8?2) n
Proof. Assume that t is the minimum time that any broadcast scheme uses to broadcast m messages in Cn . By Lemma 3.9, ci + ci+1 min(2m; t ? min(i; n ? i ? 1))
so we have
2
nX ?1 i=0
ci =
nX ?1 i=0 nX ?1 i=0
ci + ci+1 min(2m; t ? min(i; n ? i ? 1))
?1 c = m(n ? 1). Putting these two results together we have By Lemma 3.8, Pni=0 i Pn?1 2m(n ? 1) i=0 min(2m; t ? min(i; n ? i ? 1)). Evaluating this with respect to t will give us a lower bound for t. To evaluate we must consider two cases:
13
1. t 2m. 2. t < 2m. In the rst case, t = 2m + x for some x 0 which by Theorem 3.5 is bounded by x n2 ? 2 because n is even so that 8 > > > > > > >
> t ? (n ? i ? 1) n2 i < n ? x ? 1 > > > > > : 2m n?x?1 i n?1 ?1 min(2m; t ? min(i; n ? i)) is then The sum 21 Pni=0 2 ?1 X 1 n i+ = 2 (2m(x + 1) + ( 2 ? x ? 1)t ? i=x+1 n?X x?2 ( n2 ? x ? 1)t ? (n ? i ? 1) + 2m(x + 1)) i= n2 n
0
1
2 ?1 X n 1 @ iA = 2 4mx + 4m + 2( 2 ? x ? 1)t ? 2 i=x+1 n 1 n = 2mx + 2m + ( ? x ? 1)t ? ( ? x ? 1)( n + x) 2 2 2 2 2 2 = 2mx + 2m + ( n2 ? x ? 1)t ? n8 + n4 + x 2+ x n
Since the sum must be greater than or equal to m(n ? 1) and t = 2m + x we get the following inequality: 2 2 m(n ? 1) 2mx + 2m + ( n2 ? x ? 1)(2m + x) ? n8 + n4 + x 2+ x 2 2 ? 2mx ? x2 ? 2m ? x ? n + n + x + x mn ? m 2mx + 2m + mn + nx 2 8 4 2 2 2 n + n + ?x ? x ?m nx ? 2 8 4 2 2 n 2 ?n + 1 n x 0 2 + 2 x + ( 8 ? 4 ? m) 14
q
q
Therefore, solving this quadratic for x we get n?2 1 ? 2m + 41 x n?2 1 + 2m + 14 . Since in the qcase we are considering t = 2m + x, we get a lower bound for t: t p 2m + n?2 1 ? 2m + 14 = 2m + n2 ? 1+ 82m+1 . In the equation t = 2m + x recall that x 0; therefore, our lower bound is useful when:
p
n ? 1 + 8m + 1 2 2 n?1 2 (n ? 1)2 n(n ? 2) 8
0 p8m + 1 2 8m + 1 m
In the second case, t = 2m ? x for some x bounded by 0 < x < 2m so that 8 >
: t ? (n ? i ? 1) n i n ? 1 2 ?1 min(2m; t ? min(i; n ? i)) is then nt ? P 2 ?1 i = nt ? n2 + n . As The sum 12 Pni=0 i=0 2 2 8 4 before, this sum must be greater than or equal to m(n ? 1) and t = 2m ? x so we get the following inequality: 2 m(n ? 1) n(2m2 ? x) ? n8 + n4 2 ?m ?2nx ? n8 + n4 n2 + n 2 m ? 4 2 x n n
In the case we are 2considering t = 2m ? x so we get the following lower bound for n n t: t 2m ? 2m? n4 + 2 = 2m(nn?1) + n?4 2 . In the equation t = 2m ? x, recall that 0 < x < 2m. Therefore, our lower bound is useful when 2m ? x < 2m: 2m(n ? 1) + n ? 2 < 2m n 4 15
?2m + n ? 2 < 0 n 4 n ? 2 < 2m 4 n n(n ? 2) < m 8
2 Now we prove a matching upper bound which yields:
Theorem 3.11 For even n and any m 1, 8 l > >
l > :
2m(n?1) n
+ n?4 2
2
m
m n(n8?2) m > n(n8?2)
Proof. Having already proved Theorem 3.10 we are left with proving a matching
upper bound. We do this by describing a particular broadcast scheme which achieves this time. Before giving the details of the scheme, we rst give a more intuitive description. To ensure that a vertex v does not make two calls in the same time unit we have v call one of its two neighbors only during odd time units and its other neighbor only during even time units. For example, v0 calls v1 during odd time units 1, 3, 5, ... and vn?1 during even time units 2, 4, 6, ... . This is possible because the number of edges in the cycle is even. The originator v0 sends messages to v1 in ascending order beginning with message one. To vn?1 , however, v0 sends the messages in descending order beginning with message m. Then, v1 simply forwards the messages it receives on to v2 in ascending order beginning with message one during even time units 2, 4, 6, ... . In some cases, v1 will not be able to forward every message it receives from v0 because of time constraints. Likewise, vertices vi, 2 i n2 , simply forward messages they have received on to vertex vi+1. Vertex vn?1 behaves similarly to v1 forwarding messages 16
it receives from v0 but in descending order beginning with message m. Vertices vi, n + 2 i n ? 2, simply forward messages they have received on to vertex v . i?1 2 At vertex v n2 +1 , the pattern changes after v n2 +1 has received all m messages from v n2 and v n2 +2. It then stops receiving messages from its neighbors because it has received all m messages and begins to forward messages it has received from v n2 to v n2 +2 in ascending order starting at message one and forwards messages it has received from v n2 +2 to v n2 in descending order starting at message m. This essentially reverses the
ow of messages in the cycle as v n2 now forwards messages to v n2 ?1 and v n2 +2 now forwards messages to v n2 +3. The scheme continues in this mode until every vertex has received all m messages. An example of the scheme when n = 10 and m = 25 follows this proof. Here are the details of the scheme. For edge fvi; vi+1g, 0 i n2 , vi sends messages M1; M2; :::; Mfi to vi+1 at times i + 1; i + 3; :::; i + 2fi ? 1 respectively, and vi+1 sends messages Mm ; Mm?1; :::; Mm?ri+1 +1 to vi at times i + 2fi + 1; i + 2fi + 3; :::; i + 2fi + 2ri+1 ? 1 respectively. For edge fvi; vi+1g, n2 + 1 i n ? 1, vi+1 sends messages Mm ; Mm?1; :::; Mm?ri+1 +1 to vi at times n ? i + 1; n ? i + 3; :::; n ? i + 2ri+1 ? 1 respectively, and vi sends messages M1; M2; :::; Mfi to vi+1 at times n ? i + 2ri+1 + 1; n ? i + 2ri+1 + 3; :::; n ? i + 2ri+1 + 2fi ? 1 respectively. The time t required by the scheme is then max fi + 2fi + 2ri+1 ? 1 j 0 i n2 g [ fn ? i + 2ri+1 + 2fi ? 1 j n2 + 1 i n ? 1g
(1)
To de ne values fi and ri, we consider two cases: t < 2m and t 2m. In both cases, r1 = fn?1 = 0 by Lemma 3.6. Case t < 2m. For 0 i n2 ? 1, if i and t have di erent parity then we set i + 2fi + 2ri+1 ? 1 = t; otherwise, we set i + 2fi + 2ri+1 ? 1 = t ? 1. Solving for fi we get fi = t?2i+1 ?ri+1 and fi = t?2 i ?ri+1 respectively. From Lemma 3.6, ri+1 = m?fi?1 for i 6= 0 so we get fi = t?2i+1 ? m + fi?1 and fi = t?2 i ? m + fi?1. Solving these recurl t m ? im ? ( i )2 when i is even and f = (i+1)t ? im ? i+1 i?1 rences, we get fi = (i+1) i 2 2 2 2 2
17
when i is odd. For n2 + 1 i n ? 1, if i and t have di erent parity then we set n ? i + 2ri+1 + 2fi ? 1 = t; otherwise, we set n ? i + 2ri+1 + 2fi ? 1 = t ? 1. Solving for ri+1 we get ri+1 = t?n+2 i+1 ? fi and ri+1 = t?n2+i ? fi respectively. From Lemma 3.6, fi?1 = m?ri+1 for i 6= 0 so we get ri+1 = t?n+2 i+1 ?m+ri+2 and ri+1 = t?n2+i ?m+ri+2. Solving these recurrences, we get ri+1 = (n?2 i)t ? (n ? i ? 1)m ? ( n?2 i )2 when i is even j k and ri+1 = (n?2i)t ? (n ? i ? 1)m ? n?2i?1 n?2i+1 when i is odd. The remaining two values to de ne are f n2 and r n2 +1. By Lemma 3.6, they are simply m ? r n2 +2 and m ? f n2 ?1. From the values calculated above, f n2 is 8 > >
j ( n ?1)t k n n > 2 : ? + ( n2 ? 1)m + 2 2?1 22 2 and r n2 +1 is
n
8 > >
n t n n > : ? 2 + n m + 2 ?1 2 2 2 2 2 n
n 2 n 2
n 2
is odd
n 2
is even
is odd
is even Using these formulas for f n2 and r n2 +1, we can calculate the time t required by the scheme. More speci cally, according to the scheme, we use time units n2 + 2j ? 1, for j 1 and n2 + 2j ? 1 t, to make exactly f n2 + r n2 +1 calls between v n2 and v n2 +1. l nm l nm The number of time units is then t?2 2 so solving f n2 + r n2 +1 t?2 2 for t we get l m t 2m(nn?1) + n?4 2 . If we let t = 2m(nn?1) + n?4 2 then since t > 2m this result applies when 2m > 2m(nn?1) + n?4 2 ; that is, m > n(n8?2) . Case t 2m. In this case, t = 2m + x for some x where x 0 and, according to Theorem 3.5, x n2 ? 2. According to equation 1, if we let fx+1 = m and rx+2 = 0 then t = (x +1)+2fx+1 +2rx+2 ? 1 and, similarly, if we let rn?x = m and fn?x?1 = 0 then t = n ? (n ? x ? 1) + 2rn?x + 2fn?x?1 ? 1. So, for 0 i x + 1, fi = m, and, for n ? x i n, ri = m. By Lemma 3.6, it follows that, for 1 i x + 3, ri = 0 and, for n ? x ? 2 i n ? 1, fi = 0. For the remaining fi and ri we de ne them as recurrences exactly as in the previous case (ie. for t < 2m). Solving those
18
recurrences for 0 y n2 ? x ? 1, fx+y = y(t?2 x) ? (y ? 1)m ? ( 2y )2 when y is even n and fx+y = y(t2?x) ? (y ? 1)m ? y?2 1 y+1 2 when y is odd. Solving for 0 y 2 ? x ? 2, (y+1)(t?x) ? ym ? y y+2 2 rn?x?y = (y+1)(2 t?x) ? ym ? ( y+1 2 ) when y is odd and rn?x?y = 2 2 2 when y is even. Calculating f n2 and r n2 +1 as before and then using them to nd t we get: t p 2m + n2 ? 1+ 82m+1 when m n(n8?2) . The scheme is valid because:
Each message arrives at a vertex before the vertex sends it. We rst show that
the scheme satis es Lemma 3.7 using the values for fi and ri found by solving recurrences. In the t < 2m case, fi+1 fi for 0 i n2 ? 2 if and only if t 2m + i; ri ri?1 for n2 + 3 i n if and only if t 2m + n ? i ? 1. Clearly both are true because t < 2m. In the t = 2m + x case, x 0, fi = m for 0 i x +1 and ri = m for n ? x i n. For x +2 i n2 ? 2, fi+1 fi if and only if t 2m + i. For n2 + 3 i n ? x ? 1, ri ri?1 if and only if t 2m + n ? i + 1. Clearly both are true because t = 2m + x. It remains then to show that f n2 f n2 ?1 and r n2 +2 r n2 +1. Suppose that f n2 > f n2 ?1; that is, f n2 = z + 1 and f n2 ?1 = z. Then, because r n2 +1 = m ? f n2 ?1, r n2 +1 = m ? z; similarly, r n2 = m ? f n2 ?2. We have already shown that f n2 ?1 f n2 ?2 so r n2 r n2 +1 = m ? z. In the scheme we set n2 + 2f n2 + 2r n2 +1 ? 1 t and ( n2 ? 1)+2f n2 ?1 +2r n2 ? 1 equal to t or t ? 1. The inequality gives n2 +2m +1 t and the equations give n2 + 2m ? 1 t. Both cannot be true so f n2 f n2 ?1. A similar argument shows that r n2 +2 r n2 +1. It follows from Lemma 3.7 that if a vertex must send a message at a certain time then it will have received it at an earlier time.
Each vertex is involved in at most one call per time unit. According to the
scheme, if vertices w and w0 are adjacent to v then v will call w during even time units and w0 during odd time units, or vice versa. 19
Each vertex receives every message once except the originator which does not receive any messages. The scheme is de ned so that it satis es Lemma 3.6.
2 For example, we get the following scheme for broadcasting 25 messages in C10 from the general scheme described in the proof. According to the proof, T25(C10) = t = 47 so we use the scheme for t < 2m. Calculating fi, 0 i 4, we get f0 = 24, f1 = 22, f2 = 20, f3 = 17, and f4 = 14. Calculating ri, 7 i 9 or i = 0, we get r0 = 23, r9 = 21, r8 = 18, and r7 = 15. The remaining values for fi and ri follow from the calculated values and Lemma 3.6: r1 = 0, f9 = 0, ri = m ? fi?2 for 2 i 6 and fi = m ? ri+2 for 5 i 8. From these values we can determine the actual times messages are sent: Messages Times Messages Times v0 to v1 1, 2, ..., 24 1, 3, ..., 47 v1 to v0 v1 to v2 1, 2, ..., 22 2, 4, ..., 44 v2 to v1 25 46 v2 to v3 1, 2, ..., 20 3, 5, ..., 41 v3 to v2 25, 24, 23 43, 45, 47 v3 to v4 1, 2, ..., 17 4, 6, ..., 36 v4 to v3 25, 24, ..., 21 38, 40, ..., 46 v4 to v5 1, 2, ..., 14 5, 7, ..., 31 v5 to v4 25, 24, ..., 18 33, 35, ..., 47 v5 to v6 1, 2, ..., 10 6, 8, ..., 24 v6 to v5 25, 24, ..., 15 26, 28, ..., 46 v6 to v7 1, 2, ..., 7 35, 37, ..., 47 v7 to v6 25, 24, ..., 11 5, 7, ..., 33 v7 to v8 1, 2, ..., 4 40, 42, ..., 46 v8 to v7 25, 24, ..., 8 4, 6, ..., 38 v8 to v9 1, 2 45, 47 v9 to v8 25, 24, ..., 5 3, 5, ..., 43 v9 to v0 v0 to v9 25, 24, ..., 3 2, 4, ..., 46 Having produced a minimum time scheme for cycles on an even number of vertices, we turn to cycles on an odd number of vertices. Unfortunately, in this case we were unable to obtain matching upper and lower bounds. We believe the following is a good lower bound. Theorem 3.12 For odd n and any8 m 1, j k > < 2m + n?3 m n 4 4 Tm(Cn) > n ? 1 : m+ otherwise 2 20
Proof. Consider broadcasting in a cycle Cn. For each time unit i during broadcasting, we partition the vertices of Cn into three disjoint sets as follows:
Si contains the originator and all vertices that have received at least one message.
Fi contains vertices that have not received a message but have a neighbor in Si.
Ni contains all vertices not in Si or Fi. We use these de nitions to show that at most i calls can be made at time i. Observe that if 2 jSij n ? 2 then Si induces a connected subgraph in the cycle. This is because S0 = fv0g and thereafter Si Si?1 [ Fi?1 where Fi?1 consists of neighbors of vertices in Si?1. Any connected subgraph of a cycle is a path so the subgraph induced by Si is a path. Furthermore, the endpoints of this path are adjacent to exactly two vertices in Cn not in Si. By de nition, then, Fi must be the set of these two vertices. As a result, jSij jSi?1j + jFi?1j = jSi?1j +2 = 2i. Because each vertex can be involved in at most one call per time unit, each call involves two vertices, and only vertices in Fi?1 and Si?1 can send or receive a message at time i, then at most jFi?1 j+2 jSi?1j 2+2(2i?1) = i calls can be made at time i. If m is small enough at most 2m calls can be made in a single time unit. This follows from the fact that any particular message can be sent in at most two simultaneous calls. Consider the case when a message is being sent in at least three calls in a single time unit; that is, there are at least three vertices vh, vh0 and vh00 sending a message Mj such that h < h0 < h00. In order for vh0 to learn message Mj , that message must have already reached vertices v1; v2; :::; vh; :::; vh0?1 or vertices vn?1; vn?2; :::; vh00 ; :::; vh0+1; consequently, either vh's or vh00 's neighbors already know message Mj and so needn't send it. Finally, at most n?2 1 calls can be made in a single time unit because each vertex can be involved in at most one call and each call involves two vertices. 21
We thus have three upper bounds on the number of calls that can be made in a single time unit. Combining these bounds we nd that we can make at most minfi; 2m; n?2 1 g calls at time i. If m is large enough that 2m > n?2 1 then we can make at most minfi; n?2 1 g calls n?1 at time i. From time 1 to n?2 1 , then, at most Pi=12 i = (n+1)(8 n?1) calls can be made. For the remainder of the broadcast, at most n?2 1 calls can be made in a single time unit so, recalling that m(n ? 1) total calls must be made in a broadcast scheme, we get the following lower bound for Tm(Cn ): (n+1)(n?1) Tm(Cn ) n ?2 1 + m(n ? 1)n??1 8 2 n ? 3 = 2m + 4
mi = On the other hand, if 2m < n?2 1 then from time 1 to 2m at most P2i=1 m(2m + 1) calls can be made. For the remainder of the broadcast, at most 2m calls can be made per time unit. Therefore, Tm(Cn) 2m + m(n ? 1) ?2mm(2m + 1) = m + n2 ? 1
2 From Theorems 3.5, 3.11 and 3.12 we get:
Corollary 3.13 For n even and any m 1 8 l > >
l > :
p8m+1 m
2m + n2 ? 1+ 2m(n?1) n
+ n?4 2
2
m
m n(n8?2) m > n(n8?2)
and, for n odd and any m 1, 8 >
: m + n?1 otherwise 2 22
Farley ([11]) claims that Tm(G) 2(m ? 1) + D for any connected graph G with diameter D and m 1. Since, for even n, the diameter of Cn is n2 then by Farley's claim Tm(Cn ) 2(m ? 1) + n2 . However, from Corollary 3.13, we see that Tm(Cn) < 2(m ? 1) + n2 whenever n is even and 3 m n(n8?2) or m maxf n(n8?2) ; n(108?n) g. Thus, Farley's claim is erroneous.
3.4 Broadcasting in a Grid Let Gd;d0 be an d d0 grid. In the following theorem we use the cycle results from the previous section to obtain a result for grids.
Theorem 3.14 Let d or d0 be even and n = d(d0). Then, for any m 1, 8 l > >
l > :
p8m+1 m
2m + n2 ? 1+ 2m(n?1) n
+ n?4 2
2
m
m n(n8?2) m > n(n8?2)
Proof. If d or d0 is even then Gd;d0 contains a cycle subgraph on all n = d(d0 ) vertices so we simply apply the cycle broadcast scheme described in the proof of Theorem 2 3.11 to get Tm(Gd;d0 ) Tm(Cn).
Van Scoy and Brooks ([23]) present two algorithms for d d grids which require time maxfd + 25 m ? 1; 2d +2m ? 4g and time 2d + 52 m ? 4, respectively. Wojciechowska and Van Scoy ([24]) present an algorithm which requires time 2d + 2m + 2. Roditty and Shoham ([21]) investigated broadcasting in multi-dimensional grids. Because their algorithm is more general, it is not as ecient as the previously mentioned algorithms for two dimensional grids. Notice that each algorithm mentioned requires at least 2d + 2m ? 4 time units. Our result improves on the 2d + 2m ? 4 time when m l d is even and m is very large. In particular, Tm(Cd2 ) = 2m(dd22?1) + d24?2 is smaller than 2d + 2m ? 4 when m > d2(d2?88d+18) .
23
3.5 Broadcasting in a Hypercube Let Qd be a d-dimensional hypercube. We label each vertex v in Qd with a unique bit string of length d, bd?1bd?2:::b0, such that v is adjacent to w if and only if we can obtain w's bit string by ipping one bit in v's bit string. See Figures 3 and 4 for examples of 3 and 4-dimensional hypercubes. Our lower bound for Tm(Qd) is simple|we use the trivial lower bound from Lemma 2.1 that Tm(Qd) Tm(K2d ). k j From Theorem 1.1 Tm(K2d ) = 2m + d ? 2 ? m2d??11 . Our upper bound, as for other graphs, is found by describing and evaluating a broadcast scheme. We describe two broadcast schemes. The rst scheme provides an upper bound of 2m + d ? 2 for Tm(Qd) which matches our lower bound when m is small, m 2d?1 , but not when m is large. The second scheme is a modi cation of the rst scheme and provides an upper bound matching our lower bound for all m though only for 3 and 4-dimensional hypercubes. How to generalize the second scheme for all hypercubes is still an open problem. 000
001
010
100
011
101
110
111
Figure 3: A 3-dimensional hypercube with bit-string vertex labels. As mentioned the rst scheme requires 2m + d ? 2 time units. We divide the scheme into three phases. The rst phase is m time units, the second is d ? 1 time units, and the third is m ? 1 time units. In the rst two phases each of messages M1 24
0000
0001
0011
0101
0111
0010
1001
0100
0110
1011
1010
1101
1000
1100
1110
1111
Figure 4: A 4-dimensional hypercube with bit-string vertex labels. to Mm?1 are broadcast to half the vertices in the hypercube and the last message is broadcast to all vertices in the hypercube. More speci cally, the originator sends message Mx, 1 x m?1, to one of its neighbors at time x and by time x+d?1 half the vertices of the hypercube have received message Mx. The originator sends the last message to each of its neighbors at times m, m +1, ..., m + d ? 1 respectively and by time m + d ? 1, the end of phase two, every vertex knows the last message. Figure 5 gives the exact details of the route of each message throughout a 3-dimensional hypercube. Four trees appear in the gure. The rst tree illustrates the route of message Mx when x 1(mod 3). The second and third trees illustrate the routes of messages Mx for x 2(mod 3) and x 0(mod 3) respectively. The fourth tree shows the route of the last message if m 0(mod 3). Similar trees can be constructed if m 6 0(mod 3). The solid edge lines indicate that those edges are also in tree three, the dashed edge lines indicate that those edges are also in tree one, and the dashed-dot edge lines indicate that those edges are also in tree two. 25
An integer i next to an edge indicates that message Mx crosses that edge at time i + x ? 1. Notice that at the end of phase two each vertex with a label b2b11 knows every message Mx, x 1(mod 3). Similarly, every vertex with a label b21b0 knows every message Mx, x 2(mod 3) and every vertex with a label 1b1b0 knows every message Mx , x 0(mod 3). In general, at the end of phase two every vertex with a label bd?1bd?2:::b0 satisfying b(x?1)mod d = 1 knows message Mx. Observe that this is exactly half the vertices in the hypercube. This fact is necessary for phase three. At time x of phase three, we have each vertex that knows message Mx send that message to a neighbor that doesn't know it. This is possible because each vertex labelled bd?1bd?2:::b0 with b(x?1)mod d = 1 knows Mx and has a neighbor labelled exactly the same except that b(x?1)mod d = 0 that does not know Mx. As a result, every vertex knows message Mx at the end of time x of phase three. For example, if x 1(mod 3) then we have b2b11 send message Mx to b2b10 at time x of phase three. Since the last message is already known by all the vertices we need only m ? 1 time units. Figure 6 gives the exact details of what happens in phase three for a 3-dimensional hypercube. The dashed edge lines indicate the edges message Mx, x 1(mod 3), crosses, the dashed-dot edge lines indicate the edges message Mx, x 2(mod 3), crosses, and the solid edge lines indicate the edges message Mx, x 0(mod 3), crosses. The following is a formal description of the algorithm we just described informally above. Later on we will prove that these two descriptions are equivalent. As above, we split the algorithm into three phases. 1. At time t where 1 t m and i = (t ? 1) mod d, vertex v labelled bd?1bd?2:::b0 = bd?1 bd?2:::bi+10bi?1:::b0 sends a message to its neighbor w labelled bd?1bd?2:::bi+11bi?1:::b0. If v is the originator then it sends message Mt; otherwise, v sends the most recent message it has received. 2. At time t where m + 1 t m + d ? 1, the same message passing pattern holds except that the originator sends message Mm . 26
000
000
1
2
001
010
100
001
010
100 3
4
2 3
011
110
101
011
3
4 111
1.
111
msg = 1, 4, 7, ...
2.
000
010
m+1 100
4 011
101
5
001 m+2
110
m
m+2 010
100 m+1
011
101
m+2 110
m+2
5 111 3.
msg = 2, 5, 8, ... 000
3 001
110
101
111
msg = 3, 6, 9, ...
4.
msg = m (if m mod 3 = 0)
Figure 5: Phases one and two of a scheme for a 3-dimensional hypercube.
27
000
001
011
010
100
msg = 1, 4, 7, ... msg = 2, 5, 8, ... msg = 3, 6, 9, ...
110
101
111
Figure 6: Phase three of a scheme for a 3-dimensional hypercube. 3. At time t where m + d t 2m + d ? 2 and i = (t ? m) mod d, vertex v labelled bd?1bd?2:::b0 = bd?1bd?2:::bi+11bi?1 :::b0 sends a message to its neighbor w labelled bd?1bd?2:::bi+10bi?1 :::b0 if and only if w is not the originator. In all cases, v sends message Mi+1. We illustrate this scheme for a 3-dimensional hypercube with m = 5. It may be informative to check that this illustration complies with the scheme de nition of Figures 5 and 6. Each column in the following tables shows the calls that are made during the time unit noted in the rst row of the column. The notation 000 !2 010 means that the vertex labelled 000 sends message M2 to its neighbor labelled 010. Phase One 1 2 3 000 !1 001 000 !2 010 000 !3 100 001 !1 011 010 !2 110 001 !1 101 011 !1 111
28
4 000 !4 001 100 !3 101 010 !2 011 110 !2 111
5 000 !5 010 001 !4 011 100 !3 110 101 !3 111
Phase Two 6 000 !5 100 010 !5 110 001 !4 101 011 !4 111
7 000 !5 001 100 !5 101 010 !5 011 110 !5 111
Phase Three 8 9 10 11 011 !1 010 110 !2 100 101 !3 001 011 !4 010 101 !1 100 011 !2 001 110 !3 010 101 !4 100 111 !1 110 111 !2 101 111 !3 011 111 !4 110 Recall that at the beginning of this section we gave an intuitive description of a broadcast scheme for hypercubes and then gave a formal de nition of the broadcast scheme. In what follows, we prove that the formally de ned broadcast scheme is equivalent to our initial description. We rst de ne St;j . Informally, we use St;j to track the progress of a message sent by the originator at time t in phases one and two of the scheme. For example, if we are broadcasting in a 3-dimensional hypercube and the originator sends message M1 at time 1 then we want S1;0, S1;1 and S1;2 to be the set of vertices that have received message M1 immediately after times 1, 2 and 3, respectively. According to earlier examples of the broadcast scheme for 3-dimensional hypercubes, we should have S1;0 = f001g, S1;1 = f001; 011g and S1;2 = f001; 011; 101; 111g. In general, in order for phase three to work we must have St;d?1 = fbd?1bd?2:::b0 j b(t?1)mod d = 1g. We de ne St;j as follows. Let t be an integer in the range 1:::m + d ? 1 and j be any non-negative integer. Then, 8 > > fbd?1bd?2:::b0 = 00:::0b(t?1)mod d0:::0 j b(t?1)mod d = 1g j = 0 > > > > > < S [ fbd?1bd?2 :::b(t+j)mod d1b(t+j?2)mod d:::b0 0 j bd?1bd?2:::b0 2 St;j?1g > > > > > : S jd t;d?1 29
The next lemma shows how fast St;j grows. It will be useful in other proofs.
Lemma 3.15 For any 0 j d ? 1, jSt;j j = 2j . Proof. For j = 0 the result follows immediately from the de nition of St;j . For 0 < j < d, we are simply proving that jSt;j j = 2jSt;j?1j or equivalently St;j?1 \ fbd?1bd?2:::b(t+j)mod d1b(t+j?2)mod d:::b0 j bd?1bd?2:::b0 2 St;j?1g = fg. Assume that this
is not the case; then there is a vertex bd?1bd?2:::b0 in St;j?1 with b(t+j?1)mod d = 1. The only way this is possible is if there exists an integer j 0 such that 0 j 0 < j and (t + j 0 ? 1) (t + j ? 1)(mod d); however, this is clearly impossible because 0 j < d. Thus, jSt;j j = 2jSt;j?1j. 2 The next lemma shows that the last message that each vertex in St;j has received is the same. Recall that in the de nition of the broadcast scheme, we have vertices sending the most recent message they have received. Thus, this lemma shows how we can determine which vertices will be sending which message during each time unit of the scheme.
Lemma 3.16 In phases one and two of the scheme above, if the originator sends
message Mx at time t then, immediately after time t + j , the most recent message that the vertices in St;j have received is Mx. Proof. The proof is by induction on j . According to broadcast scheme, the originator sends message Mx at time t to its neighbor labelled bd?1bd?2:::b0 = 0:::0 b(t?1)mod d 0:::0 where b(t?1)mod d = 1. This is precisely the single vertex in St;0. Assume that the statement of the lemma is true for j = k for some integer k in the range 0::d ? 2. We then show that the statement is true for j = k +1. By assumption, if v 2 St;k and bd?1bd?2:::b0 is v's label, then b(t+k) mod d = 0 and Mx is the most recent message v has received. According to the scheme, then, v will send message Mx at time t+k+1 to its neighbor w whose label is bd?1bd?2:::b(t+k+1) mod d1b(t+k?1) mod d:::b0. Doing this for all v in St;k we get precisely the vertices that we add to St;k in order to form St;k+1. All the other vertices in St;k+1, that is those from St;k , send Mx at time t + k + 1 so the most recent message they have received remains message Mx.
2
30
The next two lemmas help us to determine the messages that each vertex knows at the end of phase two.
Lemma 3.17 Every vertex labelled bd?1bd?2:::b0 where b(t?1)mod d = 1 receives message Mt, 1 t m, during phases one and two of the scheme. Proof. By Lemma 3.15, jSt;d?1j = 2d?1 . By de nition, all the vertices in St;d?1 have labels with bit number (t ? 1)mod d set to 1. There are 2d?1 such labels so, since jSt;d?1j = 2d?1 , St;d?1 must be the set of all those labels. By Lemma 3.16, all the vertices in St;d?1 have received message Mt.
2
Lemma 3.18 Every vertex other than the originator receives message Mm during
phases one and two of the scheme. Proof. By Lemma 3.16, every vertex in Sm;d?1, Sm+1;d?2 , ..., and Sm+d?1;0 knows message Mm at the end of phase two. These sets are pairwise disjoint. To see this consider two such sets, Sm+x;d?x?1 and Sm+y;d?y?1 with 0 x d ? 2 and x < y d ? 1. Then, any vertex labelled bd?1bd?2:::b0 in Sm+x;d?x?1 has b(m+x?1) mod d = 1. On the other hand, any vertex labelled bd?1bd?2:::b0 in the other set has b(m+x?1) mod d = 0. By de nition, only bits in the range m + y ? 1::m + d ? 2 (mod d) could have been set to 1 in any label in Sm+y;d?y?1 . Bit number m + x ? 1 (mod d) is not one of those bits because 0 x < y d ? 1. By Lemma 3.15, the size of a set Sm+x;d?x?1 is 2d?x?1 . Therefore, 2d?1 + 2d?2 + ::: +20 = 2d ? 1 vertices in the hypercube have received message Mm. The originator does not receive any messages. 2
The next lemma combines the results of the previous lemmas to prove that the broadcast scheme we de ned is valid.
Lemma 3.19 At the end of the scheme, every vertex knows all m messages. Proof. During each time unit of phase three, we complete the broadcasting of a
single message. This follows from Corollary 3.17|if a vertex is not sending and is 31
not the originator then it is receiving and each sending vertex received the message it must send in phases one and two of the scheme. Only m ? 1 time units are allocated for phase three because from Lemma 3.18 every vertex already knows message Mm . 2
Corollary 3.20 For any d-dimensional hypercube Qd and any m 1, Tm(Qd) 2m + d ? 2. Corollary 3.21 The scheme is optimal for any d-dimensional hypercube and 1 m 2d?1 messages. k j 2 Proof. From Theorem 1.1, Tm(K2 ) = 2m + d ? 2 ? m2 ??11 . d
d
Thus, for large m our scheme is not optimal. The reason is that in phase three one possible call is lost during each time unit. The originator does not participate in any calls during phase three and there are an even number of vertices in any (d 0)dimensional hypercube so, during each time unit of phase three, two vertices are idle. For instance, in phase three for a 3-dimensional hypercube the originator and 001 are both idle during times 1(mod 3). If we can modify the broadcast scheme above to make use of these unused calls then we can broadcast any number of messages in a hypercube in minimum time. In fact, we show this for up to 4-dimensional hypercubes.
Theorem 3.22 For any m 1 and 1 d 4, Tm(Qd) = Tm(K2 ) = 2m + d ? 2 ? k j d
m?1 2d?1
.
Proof. Recall from Theorem 1.1 that Tm(K2 ) = 2m + d ? 2 ?
j
m?1 2d?1
k
. In Theorem 4.7 we show that we can broadcast any number m 1 of messages in 2-dimensional hypercubes in minimum time. For 3 and larger dimensional hypercubes we want a scheme using only Tm(K2d ) = j k 2m + d ? 2 ? m2d??11 time units. From Corollary 3.20, we know that the broadcast scheme we described earlier requires 2m + d ? 2 time units. Thus, the scheme is k j optimal for up to 2d?1 messages; however, because of the m2d??11 term in our desired d
32
scheme time, we must decrease our time by one for every 2d?1 messages. We can do this in phase three by using the unused calls, one per time unit, that we mentioned earlier to eliminate each time unit t, t 0(mod 2d?1) and 1 t m ? 1, of phase three. Recall from the scheme that at time t of phase three each vertex other than the originator that knows message Mt sends Mt to a vertex that does not know Mt. So, to eliminate time t from phase three, we modify the broadcast scheme to get message Mt to each vertex that doesn't know Mt before time t using the unused calls in phase three. From Lemma 3.17 we know that 2d?1 ? 1 vertices need to receive Mt. We then need 2d?1 ? 1 unused calls to eliminate a single time unit. Consequently, we eliminate each time t, t 0(mod 2d?1), using the 2d?1 ? 1 unused calls in the 2d?1 ? 1 time units prior to time t. For 3-dimensional hypercubes we must eliminate every fourth time unit of phase three. To eliminate time four, we use previously unused calls at times one, two and three to get message M4 to the vertices labelled 110, 010 and 100 (see Figure 6). The unused calls are between the originator 000 and 001 at time one, 010 at time two, and 100 at time three. To get M4 to 010 and 100 we simply have 000 send it to them at time two and three, respectively. It is a bit more complicated to get M4 to the vertex labelled 110. The diagrams labelled 1(a) and 1(b) of Figure 7 show how we do this. Diagram 1(a) shows calls made in the original scheme that we replace with the calls shown in diagram 1(b). The integers in the gure are message numbers, the subscripts indicate the time units at which they are sent and the arrows denote the direction messages are being sent along an edge. For example, the notation 31 ! next to edge f000; 001g means that the originator sends message M3 to its neighbor labelled 001 at time 1 of phase three. Recall the example scheme for 3-dimensional hypercubes and ve messages we presented earlier in this section. The following table shows how we modify phase three to complete the phase in 3 time units rather than 4:
33
1(a)
000
1(b)
000 31
001
010
22
100
33
33
011
001 32
110
101
010
100
33
011
23
33
43 111
2(a)
110
101
111
000
2(b)
000 75
001
010
100
001
010
77
66
77
011
67 110
101
77
011
110
101 87
77 111 3(a)
100 76
111
000
3(b)
000 119
001
010
100
001
010
100 1110
1010
1111 011
101
1111
1111 110
011
1111
1011 101
1211 111
111
Figure 7: Modi cations of a scheme for a 3-dimensional hypercube. 34
110
Phase Three 8 000 !3 001 011 !1 010 101 !1 100 111 !1 110
9 000 !4 010 110 !2 100 001 !3 011 111 !2 101
10 000 !4 100 101 !2 001 011 !3 010 111 !4 110
To eliminate time unit eight, we use the same technique though the details are slightly di erent. We use the unused calls at times ve, six and seven to get message M8 to the vertices labelled 101, 100 and 001. The unused calls are between the originator 000 and 010 at time ve, 100 at time six, and 001 at time seven. Since 100 and 001 are the originator's neighbors, we simply have the originator send them M8 at times six and seven, respectively. The diagrams labelled 2(a) and 2(b) of Figure 7 show how we get message M8 to the vertex labelled 101. To eliminate time unit twelve, we use the same technique though, as with eliminating time eight, the details are slightly di erent. We use the unused calls at times nine, ten and eleven to get message M12 to the vertices labelled 011, 001 and 010. The unused calls are between the originator 000 and 100 at time nine, 001 at time ten, and 010 at time eleven. Since 001 and 010 are the originator's neighbors, we simply have the originator send them M12 at times ten and eleven, respectively. The diagrams labelled 3(a) and 3(b) of Figure 7 show how we get message M12 to the vertex labelled 011. We can in fact use these three scheme modi cations to eliminate every fourth time unit. Observe that eliminating any time t of phase three when t 1(mod 3) will be the same as eliminating time four. Likewise, eliminating any time t when t 2(mod 3), will be the same as eliminating time unit eight and eliminating time unit t when t 0(mod 3), will be the same as eliminating time twelve. To generalize Figure 7 to eliminate time t simply add t ? 4 to each time or message label. For 4-dimensional hypercubes we must eliminate every eighth time unit of phase three. To eliminate time unit eight, we use previously unused calls at times one to 35
0000
1(a)
0001
0010
44
22 0011
0101
1001
0100
1000
0001
33 0110
0111
85
1010
1100
0011
1101
1110
82 3 6
0010
0100
0101
1001
0110
0111
1011
1101
2(b)
0000
64
8357
0011
0010
55
0101
1001
0100
1000
0001
0010
0100
85 55 0110
66 1010
1100
0011
0101
1000
65
66
56 1001
0110
1010
1100
86
66 0111
1110
1111
0000
66
1100
84 1111
0001
1010
34
44
2(a)
1000
85
24
43
1011
0000
42
44
33
41
1(b)
1011
1101
1110
0111
1111
1011
1101
1111
Figure 8: Modi cations of a scheme for a 4-dimensional hypercube. 36
1110
seven to get message M8 to the seven vertices labelled 1110, 0110, 1010, 1100, 0010, 0100 and 1000 (see Lemma 3.17). The unused calls are between the originator 0000 and 0001 at times one and ve, 0010 at times two and six, 0100 at times three and seven, and 1000 at time four. Figure 8 shows how to get message M8 to each vertex using these calls. As before, diagrams 1(a) and 2(a) show the calls that are made in the original scheme and diagrams 1(b) and 2(b) show the replacement calls. The vertex labels in bold font indicate the vertices that receive message M8. It is easy to verify that the modi ed scheme is valid. As for the 3-dimensional hypercube case, we can generalize this modi cation to remove every eighth time unit in the original scheme. We can do this because each time t, t 0(mod 8), (8 = 2d?1 ) also satis es t 0(mod 4) (4 = d); therefore, times t ? 7 to t involve the same calling scheme. We generalize Figure 8 to eliminate time t by adding t ? 8 to each time or message label. 2
37
4 Bounds on Bm(n) In this section we derive bounds on Bm(n). We begin by proving some general lower bounds and then proceed to proving some exact values for speci c m and n.
4.1 Lower Bounds Lemma 4.1 provides degree bounds for graphs in MMBG(n; m). The lemma provides a lower time bound for all graphs with minimum degree d so if this lower bound is larger than Tm(Kn ) then any graph in MMBG(n; m) must have degree greater than d.
Theorem 4.1 Let G be a graph on n 1 vertices with minimumjdegree dk log n. + Then, for any m 1, Tm (G) m(n?1)b?2c +2 + d + k where k = log 2n??11 . 2 Proof. All graphs on n vertices with minimumdegree d are isomorphic to a subgraph d k
k
d
n
of G0 where G0 is created by attaching a vertex v to Kn?1 using d edges. Therefore, any broadcast scheme on a graph on n vertices with minimum degree d will require at least Tm(G0 ) time units. To obtain a lower bound for Tm(G0) we consider a broadcast scheme m messages from v, the only degree d vertex in G. For this lower bound, we simply determine how fast we can make the required m(n ? 1) calls without worrying about which messages are being sent. The only restriction we place on calls is that a vertex cannot send a message if it has never received one; otherwise, we assume that it can. We can divide the broadcast scheme into three parts: Part One. Times 1; 2; :::; t1 where t1 is the earliest time after which all of v's neighbors have received at least one message. Part Two. Times t1 +1; t1 +2; :::; t2 where t2 is the earliest time by which more than n2 of the vertices have received at least one message. Notice that t2 t1 because d log n.
38
Part Three. Times t2 + 1; t2 + 2; :::; t where t is the time at which broadcast is completed.
De ne Si, as in the proof of Theorem 3.12, to be the set of vertices that know at least one message after time i. De ne Ci to be the number of calls made at time i. Then, in part one Ci jSi?1j because each vertex in jSi?1j could call a vertex not in Si?1. It follows then that jSij 2jSi?1 j. In part two Ci jSi?1j ? 1. This is because v's neighbors all belong to Si?1 so at best either v could be idle and each vertex in Si?1 except v could call a neighbor not in Si?1 or v could call a neighbor and the remaining vertices in Si?1 could call a vertex not in Si?1. If v is idle then j k jSij 2jSi?1j ? 1; otherwise, jSij 2jSi?1j ? 2. Finally, in part three Ci n2 because each call involves two vertices and a vertex can be involved in at most one call per time unit. It should be clear that if, in the rst two parts, we schedule calls so that Si grows j k as fast as possible and then, in part three, make n2 calls in each time unit, we will complete the necessary m(n ? 1) calls in minimum time. In other words, we assume that in part one jSij = 2jSi?1j and jCij = jSi?1j where jS0j = 1 and in part two jSij = 2jSi?1 j ? 1 and jCij = jSi?1j ? 1. Solving these recurrences we get jSij = 2i in part one and jSij = 2i ? 2i?d + 1 in part two. Using these facts, we calculate t1 = d, j k t2 = log( 1?n?2?1d ) so the number of calls made in parts one and two is: t1 X
=
i=1 d X
Ci +
t2 X i=t1 +1 t2 X
2i?1 +
Ci (2i?1 ? 2i?d?1 )
i=1 i=d+1 d (2 ? 1) + 2d(2t2 ?d ? 1) ? (2t2?d ? 1)
= = 2t2 ? 2t2 ?d
So, the number of calls that must be made in part three is m(n ? 1)? 2t2 +2t2 ?d, and, j k t t ?d because n2 can be made in each time unit, part three requires m(n?1)b?n2 c2 +2 2 2
39
time units. Therefore, the total time required by the scheme is, t2 t2 ?d t m(n ? 1) j?n k2 + 2 + t2 2
j
k
j
k
j
where t2 = log( 1?n?2?1d ) = log(n ? 1) ? log(1 ? 2?d ) = log(n ? 1) ? log((2d ? 1)=2d k j = log( 2nd??11 ) + d.
2
m(n?1)?2d+k +2k
Corollary 4.2 If for any m 1 and 0 d log n, Tm(Kn ) < j k n d + k where k = log 2n??11 , then Bm(n) (d+1) 2 .
b n2 c
+
d
The remainder of this section proves that Bm(n) n for any n 4. Lemma 4.3 uses Theorem 1.1 to show that Tm(K2k +1) is at least as large as each of Tm(K2k +2), Tm(K2k +3), :::, and Tm(K2k+1 ). This fact is used in Theorem 4.5 to show that if Bm(2k + 1) 2k + 1 then Bm(n) n for 2k + 1 < n 2k+1 leaving us to prove that Bm(2k + 1) 2k + 1.
Lemma 4.3 For any m 1 and k 0, Tm(Kn ) Tm(K2 +1) when 2k < n 2k+1 . Proof. By Theorem 1.1, when n is odd and 2k < n < 2k+1 , Tm(Kn ) = 2m + blog nc? 1 = 2m + k ? 1 = Tm(K2 +1). On the other hand, when n is even and 2k < n < 2k+1, k j k j Tm(Kn ) = 2m + blog nc ? m?1?n=22blog c = 2m + k ? m?n=1?2 2 . For any m 1, the j k is at least 1 so Tm(Kn ) 2m + k ? 1 = Tm(K2 +1 ). Finally, for term m?n=1+2 2 j k j k n = 2k+1 , Tm(Kn ) = 2m + blog nc ? m?1?n=22blog c = 2m + (k + 1) ? m?2 1??12 . For k j is at least 2 so Tm(Kn ) 2m + k ? 1 = Tm(K2 +1). any m 1, the term m?2 1+2 ?1 k
k
k
n
k
k
n
k
k
k
k
k
See Figure 9 for some examples of this phenomenon.
2
Lemma 4.4 proves the base case for an induction on m in the proof of Theorem 4.5.
Lemma 4.4 B1(2k + 1) 2k + 1 when k 2. Proof. Let G be a connected graph on 2k + 1 vertices and 2k edges. Clearly G
is a tree so consider a broadcast scheme in G where the broadcast originator v is 40
k
n\m 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 2 2 3 3 3 3 4 4 4 4 4 4 4 4
2 4 4 5 5 5 5 6 6 6 6 6 6 6 6
3 6 5 7 6 7 7 8 7 8 8 8 8 8 8
4 8 7 9 8 9 9 10 9 10 10 10 10 10 10
5 10 8 11 10 11 10 12 11 12 11 12 12 12 12
6 12 10 13 11 13 12 14 13 14 13 14 14 14 14
7 14 11 15 13 15 14 16 15 16 15 16 15 16 16
8 16 13 17 15 17 16 18 16 18 17 18 17 18 18
9 18 14 19 16 19 17 20 18 20 19 20 19 20 19
10 20 16 21 18 21 19 22 20 22 21 22 21 22 21
11 22 17 23 20 23 21 24 22 24 22 24 23 24 23
12 24 19 25 21 25 23 26 24 26 24 26 25 26 25
13 26 20 27 23 27 24 28 25 28 26 28 27 28 27
14 28 22 29 25 29 26 30 27 30 28 30 28 30 29
15 30 23 31 26 31 28 32 29 32 30 32 30 32 31
Figure 9: Tm(Kn ) for 3 n 16 and 1 m 15. a leaf. From Theorem 1.1 T1(K2k +1 ) = k + 1 so if G is in MMBG(2k + 1; 1) then after v sends the message to its parent the remaining 2k ? 1 vertices must receive the message in at most k time units. Therefore, if we remove v from G the result must be a binomial tree with v's parent as the root (see [20]); in fact, this must be true for every leaf in G. However, every binomial tree on at least 2k , k 2, verticescontains at least one leaf whose parent is degree 2 This parent cannot be the root of a binomial tree on 2k , k 2, vertices. Therefore, B1(2k + 1) 2k + 1 when k 2. 2
Theorem 4.5 For any m 1, Bm(n) n when n 4. Proof. We rst prove this for n = 4. There are two trees on four vertices: the path
P4 and the tree T with three leaves and a root. According to Theorem 3.1, Tm(P4) = m l 2m + 1 and according to Lemma 3.2, Tm(T ) 3m. However, Tm(K4 ) = 3m2+1 is 41
smaller than both Tm(P4) and Tm(T ) so Bm(4) 4. To prove this for ve or more vertices, we show that Bm+1 (2k + 1) 2k implies Bm(2k + 1) 2k . Then, because Lemma 4.4 shows that B1(2k + 1) > 2k for k 2 we get Bm (2k + 1) > 2k for all m and k 2. Finally, Lemma 4.3 shows that this result applies for all n 5; that is, Bm(n) n for all m and n. One way to prove that Bm+1(2k +1) 2k implies Bm(2k +1) 2k is to prove that if there exist broadcast schemes for broadcasting m +1 messages in Tm+1(K2k +1) time units in some tree T on 2k + 1 vertices then we can slightly modify those schemes to broadcast m messages in the same tree T in Tm(K2k +1) time units. Translating schemes to handle a di erent number of messages can be a very complex task; however, we can simplify the task by limiting ourselves to only certain types of schemes. We consider only schemes where the messages cross each edge in ascending order; that is, rst M1, then M2 and so on. For any tree and m 1, there is always at least one such optimal scheme because each vertex in the tree receives all m messages from the same neighbor and then forwards those m messages to each of its other neighbors. Thus, it does not matter which order the messages are sent or received. So, assume that there is a tree T on 2k + 1 vertices for which we have schemes so that Tm+1(T ) = Tm+1(K2k +1) = 2(m +1)+ k ? 1 = 2m + k +1 for some m 1. From the discussion above, then, there exist schemes of the special type we described for broadcasting m +1 messages in T in the same amount of time, 2m + k +1 time units. We know that Tm(K2k +1 ) = 2m + k ? 1 so our translated schemes for broadcasting m messages must use 2 fewer time units. To translate, we rst remove calls sending message Mm+1 from each scheme. Observe that we have just removed the last call across each edge in the tree; furthermore, the last call across each edge now sends message Mm. Thus, the schemes now broadcast m messages and require at most 2m + k time units; however, our schemes must complete in 2m + k ? 1 time units. Consider some call that occurs at time 2m + k. The call then involves some internal vertex v sending message Mm to a leaf v0. In the original scheme, then, v sends message Mm+1 to v0 at time 2m + k + 1. In order to do this, v must have 42
received message Mm+1 at some time t < 2m + k because v is busy sending during time 2m + k and 2m + k + 1. In the new scheme, v does not receive message Mm+1 at time t so we can use time t to have v send Mm to v0. Thus, we have a new scheme for m messages requiring 2m + k ? 1 time units. As we noted earlier, we have just proven that Bm+1(2k +1) 2k implies Bm(2k +1) 2k . However, Lemma 4.4 shows that B1(2k +1) > 2k when k 2; therefore, by induction, Bm(2k + 1) > 2k for all k 2. We can now prove that Bm (n) n for all n 5. By way of contradiction, suppose that for some tree T on n 5 vertices we have schemes requiring exactly Tm(Kn ) time units to broadcast m messages. Let k 2 be such that 2k +1 n 2k+1 . If we remove n ? (2k +1) vertices from T and remove calls to those vertices in the schemes we nd that we can broadcast m messages in a tree on 2k +1 vertices in Tm(Kn ) time units. By Lemma 4.3, this time is at most Tm(K2k +1). Therefore, Bm(2k + 1) = 2k . However, we just proved that Bm (2k + 1) > 2k .
2
4.2 Exact Values In this section, we use the results of the previous sections in order to prove exact bounds on Bm(n). Our overall strategy is to nd Bm (3), then Bm (4), then Bm (5) and so on. In general, the proofs begin by stating Tm(Kn ) from Theorem 1.1 and then proceed to eliminate increasingly less sparse graphs until a graph G is found satisfying Tm(G) = Tm(Kn ).
Theorem 4.6 For any m 1, Bm(3) = 2. Proof. P3 is the only connected graph on three vertices and two edges. From
Theorem 3.1, Tm(P3) = 2m and from Theorem 1.1, Tm(K3) = 2m.
2
In the remainder of this section, recall that Theorem 4.5 states that Bm (n) n.
43
Theorem 4.7 For any m 1, Bm(4) l= 4. m Proof. From Theorem 1.1, Tm(K4) = 3m2+1 . From Theorem 3.11, T1(C4) = 2 and l m
Tm(C4) =
3m+1 2
for m > 1 which is exactly Tm(K4) so Bm(4) = 4.
2
Theorem 4.8 For any m 1, Bm(5) = 5. Proof. From Theorem 1.1, Tm(K5 ) = 2m +1. From Theorem 3.5, Tm(C5) 2m +1
2
which is equal to Tm(K5) so Bm(5) = 5.
Theorem 4.9 For any m 1, Bm(6) = 6. j k l m Proof. From Theorem 1.1, Tm(K6) = 2m + 1 ? m3 = 5m3+3 .
From Theorem 3.11, T1(C6) = 3, T2(C6) = 5, T3(C6) = 6, and when m 4, m l 2 Tm(C6) = 5m3+3 . Therefore, Tm(C6) = Tm(K6) for all m so Bm(6) = 6.
Theorem 4.10 For any m 1, 7 Bm (7) 8. Proof. From Theorem 1.1, Tm(K7) = 2m + 1. The broadcast schemes in Figure 11 for the graph in Figure 10 show that Bm(7) 8. In the gure there are three schemes. Only three are needed because of vertex symmetry. The (a) part of each scheme shows the broadcast trees for messages 1 to m ? 1. A label, say t, next to an edge indicates that message x crosses that edge at time 2(x ? 1) + t. The (b) part of each scheme shows the broadcast trees for message m. It is easy to verify that the schemes are valid and require at most 2m + 1 time units. 2 v1 v0
v2 v3
v6
v5
v4
Figure 10: A graph on seven vertices and eight edges. 44
v1
1(a)
v2
3
1(b)
1
v6
v3 v0
2
v2
2m+1
2m
2 v0
v1
2m-1
v6
v3
2m
3 v5
v1
2(a)
v4
v2
2
1
2(a) 3
v0
v6
4
2m-1 v3 v0
v5
v4
v1
v2
2m+1
2m
2m+1 v3
v6
2m
2 3
v5
v1
3(a)
2m+1
2m+1
4
v4
v5
v2
2
v0
v6
v1
3(a)
v3 v0
4
2m
2m-1
3
1
2m+1
2m+1
v4
v2 2m+1 v3
v6
2m
2 v5
3
v4
v5
2m+1
Figure 11: Broadcast schemes for the graph in Figure 10.
45
v4
Theorem 4.11 For any m 1, B2(8) = 10 8 Bm(8) =
> < > :
12 m 1(mod 4) 8 m 6 1(mod 4) and m 6= 2 j
k
Proof. From Theorem 1.1, Tm(K8) = 2m + 1 ? lm4?1 m=
l
7m+5 4
m
. We know from Theorem 3.11 that Tm(C8) = 7m4+6 when m > 6 so Bm(8) 8 m l m l when 7m4+5 = 7m4+6 ; that is, when m 0; 2; 3(mod 4) and m > 6. From the same theorem, Tm(C8) = Tm(K8) when m = 3; 4; 6. From Theorem 4.1, if G is a graph on eight vertices with minimum degree two m l m l m l then Tm(G) 7m4+6 . Thus, for any m satisfying 7m4+5 < 7m4+6 every graph in MMBG(8; m) must have minimum degree 3. Therefore, Bm(n) 12 when m 1(mod 4). We know from Theorem 3.22 that Bm (8) 12. The only case not covered so far is when m = 2; note that T2(K8) = 5. According to Theorem 4.1, if G is a graph on eight vertices with minimum degree 1 then T2(G) 6; thus, every graph in MMBG(8; 2) must have minimum degree 2. From Theorem 3.11, T2(C8) = 6 is too large so B2(8) 9. In fact we can show that B2(8) > 9 by eliminating all possible graphs on eight vertices and nine edges. We do this by counting the maximum number of calls that can be made in a graph in ve time units. More speci cally, we use the lower bound techniques found in lemmas 2.3, 2.4, and 2.5. Let G be a graph on eight vertices. From Lemma 2.3 we have P v2G sends(v ) = 14. Let v be a vertex in G with d neighbors. Recall that d 2. From Lemma 2.4 and 2.5, if v is the originator then sends(v) min(2d; 5); otherwise, sends(v) min(2d ? 2; 4 ? rst(v)). Using these constraints, we can prove that any degree two vertex must have a degree three neighbor. By way of contradiction, consider a graph G on eight vertices fvi j 0 i 7g in which v0 has exactly two neighbors v1 and v2 each of degree two. Let v3 be the other neighbor of v1 and v4 be the other neighbor of v2. Without loss of generality, in any broadcast scheme in which v0 is the originator, 46
rst(v1) 1, rst(v2) 2, rst(v3) 2, rst(v4) 3, rst(v5) 3, rst(v6) 4, and rst(v7) 4. Thus, sends(v0) 2d = 4, sends(v1) 2d ? 2 = 2, sends(v2) 2d ? 2 = 2, sends(v3) 4 ? 2 = 2, sends(v4) 4 ? 3 = 1, sends(v5) 4 ? 3 = 1, sends(v6) 4 ? 4 = 0, and sends(v7) 4 ? 4 = 0 meaning Pv2G sends(v) 4 + 2 + 2 + 2 + 1 + 1 + 0 + 0 = 12 but we should have Pv2G sends(v) = 14. Each vertex must also have no more than three neighbors. Because there are only nine edges in the graph and each vertex must have at least two neighbors, a vertex cannot have more than four neighbors (solving x+2(7) 2 9 for x gives x 4). Further and for the same reasons, if a vertex v has exactly four neighbors then every other vertex must have exactly two neighbors. However, three vertices with degree two will not be adjacent to v so their neighbors will be degree two. This violates the previous requirement: a degree two vertex must have at least one degree three or greater neighbor. Finally, the diameter of the graph must be less than or equal to three. By way of contradiction, consider a broadcast scheme in a graph where the distance between the originator v and a vertex v0 is four. Because v0 must receive two messages in ve time units, the rst message v0 receives will arrive at time four and the second at time ve. Let w be the vertex that sends to v0 at time four. Then, the distance between v and w must be three so rst(w) = 3 resulting in sends(w) 4 ? 3 = 1. Thus, another vertex, say w0 also at distance three from v, must send the second message to v0. However, because w and w0 are at distance three from v and rst(v) = 3, then rst(w) 4 resulting in sends(w) 4 ? 4 = 0 so w0 cannot send any messages to v0. Putting all these constraints together, the graph must have two degree three and six degree two vertices and its diameter must be less than or equal to three. The only graph satisfying these constraints is illustrated in Figure 12. We now eliminate this graph. Call it G. Consider a broadcast scheme in G where v0, a degree three vertex, is the originator. Without loss of generality, rst(v1) 1, rst(v3) 2, and rst(v5) 3. So, we have rst(v2) 2, rst(v4) 3, and rst(v6) 4 implying rst(v7) 3. Thus, sends(v0) 5, sends(v1) 2, sends(v2) 47
v0
v1
v2
v3
v4
v5
v6
v7
Figure 12: The only eight vertex graph on nine edges such that each vertex has at least two neighbors and each degree two vertex has a degree three neighbor. 2, sends(v3) 2, sends(v4) 1, sends(v5) 1, sends(v6) 0, and sends(v7) 1 so v2G sends(v ) 14|exactly the number required. However, such a scheme is not possible. If v1 sends two messages, then it must send both to v2, so, if v2 sends two messages, then it must send both to v7. As a result, v4 cannot send a message to v7 so it must send to v3; however, this prevents v3 from sending two times. Therefore, B2(8) > 9. In fact, the graph in Figure 13 and the broadcast schemes illustrated in Figure 14 show that B2(8) 10. These schemes were rst discovered by Luo and Wang [18]. It is simple to verify that the schemes are correct. In Figure 14, the vertex marked with an x is the originator. The tree labelled 1(a) illustrates the path of message M1 and the the tree labelled 1(b) illustrates the path of message M2 in the rst scheme. Likewise, the trees labelled 2(a) and 2(b) illustrate the two message paths in the second scheme. Note that only two schemes are necessary because of vertex symmetry. 2
P
Theorem 4.12 For any m 1, B1(10) 11 B2(10) 12 Bm (10) Bm (10)
= 12 12 15 for m = 5 or m 4(mod 5) = 15 for m 3(mod 5) 48
v0
v1
v7
v2
v6
v3
v5
v4
Figure 13: A member of MMBG(8; 2)
Bm (10) = 10 for m > 5 and m 0; 1; 2(mod 5)
Proof. According to Mitchell and lHedetniemi ([19]), B1(10) = 12. m
l
m
From Theorem 1.1, Tm(K10) = 9m5+8 . From Theorem 3.11, Tm(C10) = 9m5+10 when m > 10. This is equal to Tm(K10) when m 0; 1; 2(mod 5). For m 10, the same theorem gives Tm(C10) = Tm(K10) for m = 6; 7; 10. From Theorem 4.1, if G is a graph on 10 vertices and has a vertex of degree m l m l m l 2, then Tm(G) 9m5+9 . If m 3(mod 5) then 9m5+9 > 9m5+8 so any graph in MMBG(10; m) has degree greater than 2 meaning that Bm (10) 15. In fact, the graph in Figure 15 and the broadcast scheme illustrated in Figure 16 show that Bm(10) = 15 when m 3(mod 5). Eight trees are drawn in Figure 16. Each tree shows the path of some subset of messages in the scheme with originator v0. Below each tree is a notation such as msg = 2i + 3; 2i + 4; :::; 3i + 2 which means that messages 2i + 3 to 3i + 2 will propogate throughout the graph following the edges in this tree. The time that some message j is sent across edge e in a tree can be calculated as follows: if k is the minimum message number in the tree's message subset and t is the label next to e 49
v0
1(a)
5
v1
v0
1(b) 1
v7 3
3
5
v6
v3
4 v5 v0
2(a)
v2
5
v3 4
4
v7
3
v6
v1
4 v2
2
2
v4
2
v5
v1 3
v7 1
4
5
v7
v2 3
4
v6
v1
5 v2
4
v0
2(b)
v4
5
v3
v6
v3 5
3 v5
2
v4
5 v5
4
v4
Figure 14: Schemes for broadcasting two messages in the graph from Figure 13. then the time is 3(j ? k) + t. The only exception to this is if t is written with an asterisk (*) next to it. In that case, message j is sent at time ?3(j ? k) + t. For example, consider tree number 4 where msg = 2i + 3; 2i + 4; :::; 3i + 2. Edge (v2; v3) has time 9 written next to it so vertex v2 sends messages 2i + 3; 2i + 4; :::; 3i + 2 to v3 at times 9; 12; :::; 3i + 6, in that order. On the other hand, the time next to edge (v8; v9), 9i + 3, has an asterisk next to it so v9 sends messages 2i + 3; 2i + 4; :::; 3i + 2 to v8 at times 9i + 3; 9i; :::; 6i + 6, in that order. This scheme is valid because:
Each message arrives at a vertex before the vertex sends it. This follows from the fact that edge call times increase as one moves away from the originator in 50
v0
v1
v9
v2
v3
v8
v7
v4 v6
v5
Figure 15: A member of MMBG(10; m), m 3(mod 5). v0
v1
v0
1
v9
v2
v1
6i+8
3i+4
v9
v2
6i+9 3i+7
v8
4
v8
5
4 4
v7
v3
3i+7
v4
3 2
v0
3
3i+6
3i+6 v6
2.
9i+5
3i+5
v5
msg = i+2, i+3, ... , 2i+1
v0
v1
6
v1
9i+2*
5
v9
9i+6
8
v9
v2
6 6i+4
v8
v4
v5
msg = 1, 2, ... , i+1
v2
9i+3*
v3
9
6i+7
v3
v8
3i+8
9i+5* v7
6i+6 6i+5
v4
9i+6*
6i+6 v6
3.
v7
v4
v3
3i+7
v7
3 v6
1.
6i+10
v6
v5
4.
msg = 2i+2
v5
msg = 2i+3, 2i+4, ... , 3i+2
Figure 16: (Part 1 of 2) Scheme for broadcasting 5i +3 messages in 9i +7 time units in the graph from Figure 15 where i is any integer greater then or equal to 0. 51
3i+6 v1
v0
6i+2
6i-1*
3i+8
v9
3i+7
3i+9
6i+8
v7
5.
3i+2
v7 v6
6.
3i-1* 3i*
3i+4
v8
v3
9i+7
3i+5
6i+9
v1 v2
9i+4* 3i+1*
v8
3i+2*
v7
v5
6i+10
v9
v2
6i+8
msg = 3i+4, 3i+5, ..., 4i+2
v0
9i+7
3i+3
v4
v1
6i+7
v9
6i+11
v5
6i+6
v3
6i+2*
msg = 3i+3
v0
3i+12 3i+10
v8
v4 v6
v2
6i*
v3
v8
6i+5
3i+11
v9
v2
9i+7
6i+3
3i+9 v1
v0
v3
9i+4*
v7
v4
v4
9i+6* v6
7.
9i+5
v6
v5
msg = 4i+3
8.
msg = 4i+4, 4i+5, ... , 5i+3
Figure 16: (Part 2 of 2)
52
v5
each tree.
Each vertex is involved in at most one call per time unit. We can describe
the graph in Figure 15 as a cycle on ten vertices with ve chords. The table in Appendix A shows that calls are made along cycle edge (v2i; v2i+1) at times t 0mod 3, cycle edge (v2i+1; v2i+2) at times t 2mod 3 and the chord edges at times t 1mod 3. The table also shows that di erent trees making calls along the same edge do not use overlapping times.
Each vertex except the originator receives all m messages. This follows from the facts that all call times in Appendix A are between 1 and 9i + 7 and that there is a tree spanning the entire graph in Figure 16 for each of the 5i + 3 messages .
The only cases not covered are m = 2; 5 and m 4(mod 5). For the m = 2 case, we show that 11 B2(10) 12. Note that T2(K10) = 6. The graph in Figure 17 and the three broadcast schemes for that graph illustrated in Figure 18 show that B2(10) 12. In Figure 18, the vertex marked with an x is the originator. The tree labelled 1(a) illustrates the path of message M1 and the tree labelled 1(b) illustrates the path of message M2 in the rst scheme. Likewise, the trees labelled 2(a) and 2(b) illustrate the second scheme and those labelled 3(a) and 3(b) illustrate the third scheme. Only three schemes are necessary because of vertex symmetry. To show that B2(10) 11, we rst prove that any graph in MMBG(10; 2) must have degree greater than 1. Let G be a graph on ten vertices. From Lemma 2.3 we have Pv2G sends(v) = 18 so we must be able to send 18 times in T2(K10) = 6 time units. Let v be a vertex in G with d neighbors. From Lemma 2.4 and 2.5, if v is the originator then sends(v) min(2d; 6); otherwise, sends(v) min(2d ? 2; 5 ? rst(v)). We want to prove that each vertex must have at least two neighbors so by way of contradiction, consider a graph G on ten vertices fvi j 0 i 9g in which v0 has exactly one neighbor v1. Without loss of generality, in any broadcast scheme in 53
v0
v1
v9
v2
v3
v8
v7
v4 v6
v5
Figure 17: A member of MMBG(10; 2). which v0 is the originator, rst(v1) 1, rst(v2) 2, rst(v3) and rst(v4) are 3, rst(v5), rst(v6), rst(v7), and rst(v8) are 4, and rst(v9) 5. Thus, sends(v0) d = 2, sends(v1) 5 ? 1 = 4, sends(v2) 5 ? 2 = 3, sends(v3) and sends(v4) are 5 ? 3 = 2, sends(v5), sends(v6), sends(v7), and sends(v8) are 5 ? 4 = 1, and sends(v9) 5?5 = 0 meaning that Pv2G sends(v) 2+4+3+2(2)+4(1)+0 = 17 but we should have Pv2G sends(v) = 18. The only graph on ten vertices and ten edges with no vertex of degree 1 is C10; however, from Theorem 3.11 we get T2(C10) = 7 which is larger than T2(K10) = 6. Thus, B2(10) 11. For the m = 5 case, we show that 12 B5(10) 15. We show that B5(10) 15 by de ning a scheme for the graph in Figure 15. The scheme is illustrated in Figure 19. It is easy to see that the scheme is valid and completes in T5(K10) = 11 time units; therefore, B5(10) 15. We now show that B5(10) 12. From Theorem 4.1, if G is a graph on ten vertices with minimum degree one, then T5(G) 12. This is larger than T5(K10) = 11 so every graph in MMBG(10; 5) must have minimum degree two. Thus, B5(10) 10; however, the only graph with minimum degree two on ten edges is C10 and, by Theorem 3.11, T5(C10) = 12 so B5(10) 11. To prove that B5(10) > 11 we show that if the originator of a scheme has at most two neighbors then one of those neighbors must be degree three. We prove this using an argument identical to the one above which proves that the degree of any graph 54
1(a)
5
v0
1(b)
v1
1
v0
6
v9
2
v1
4
3
v9
v2
3
v2
5 2
v8
v3
6
5 4
v8
v3
4 v7
6 v7
v4
3 v6
2(a)
4
v0
5 v6
v5
2(b)
v1
6
v0
4
6
v5
5
v1
4
5
3 2
6
v9
v2
v9
v8
v4
v2
2
v3
3
v8
1
v3
4 v7
v7
v4
3
6 v6
3(a)
4
v0
4
v5
4
v1
v4
5
5 v6
3(a)
v0
v5
6
v1
3
5
v9
v9
v2
4
3 1
v8
2
v3
6
4 v7
3 4
v3
3
v4 v6
6
v8
2 v7
v2
5
v4
5 v6
v5
6
v5
Figure 18: Schemes for broadcasting two messages in the graph from Figure 17.
55
1.
v0 v9
1
10
2.
v1
v0
11
4
v2
v1
4
v9
v2
7
6
9
v3
v8
8
5 v7
v3
v8
11 v7
v4
3
8
3 v6
3.
v0
8
2
v5
3
v1
6
6 v6
4.
v0
5
7
v9
v4
5
v5
6
v1
5
8
v9
v2
9
v2
6 10
v8
v3
11
7
v7
10 v7
v4 v6
5.
7
v8
v0
8
v5
9
v1
2
v3
7 10 v6
10
v4
v5
11
v9
v2
3 4
v8
5
v3
4 v7
v4
9
9 v6
v5
Figure 19: Scheme for broadcasting ve messages in the graph from Figure 15.
56
in MMBG(10; 2) is > 1. Let G be a graph on ten vertices. From Lemma 2.3 we have Pv2G sends(v) = 45. Let v be a vertex in G with d neighbors. Recall that d 2. From Lemma 2.4 and 2.5, if v is the originator then sends(v) min(5d; 11); otherwise, sends(v) min(5d ? 5; 7 ? rst(v)). Using these constraints, we can prove that any degree two vertex must have a degree three neighbor. By way of contradiction, consider a graph G on ten vertices fvi j 0 i 9g in which v0 has exactly two neighbors v1 and v2 each of degree two. Let v3 be the other neighbor of v1 and v4 be the other neighbor of v2. Without loss of generality, in any broadcast scheme in which v0 is the originator, rst(v1) 1, rst(v2) and rst(v3) are 2, rst(v4) and rst(v5) are 3, rst(v6), rst(v7) and rst(v8) are 4, and rst(v9) 5. Thus, sends(v0) 5(2) = 10, sends(v1) 5(2) ? 5 = 5, sends(v2) and sends(v3) are 7 ? 2 = 5, sends(v4) and sends(v5) are 7 ? 3 = 4, sends(v6), sends(v7) and sends(v8) are 7 ? 4 = 3, and sends(v9) 7 ? 5 = 2 meaning Pv2G sends(v) 10 + 5 + 2(5) + 2(4) + 3(3) + 2 = 44 but we should have Pv2G sends(v) = 45. Thus, every degree two vertex must have degree three neighbor. This is impossible to achieve with ten vertices and eleven edges so B5(10) 12. For the m 4(mod 5) case, we show that 12 Bm (10) 15. We prove that Bm(10) 15, m 4(mod 5), by de ning a scheme for the graph in Figure 15 similar to the scheme for m 3(mod 5). The scheme is illustrated in Figure 20. Note that for any i 0, T5i+4(K10) = 9i + 9. The scheme is valid for the same reasons that the m 3(mod 5) scheme is valid. As with the m 3(mod 5) case, the details can be found in Appendix A. To prove that Bm(10) 12, m 4(mod 5), we use nearly the same argument we used to prove that B5(10) 12. From Theorem 4.1, for any graph G on ten vertices with minimum degree one, T5i+4(G) 9i + 10 for any integer i 0. This is larger than T5i+4(K10) = 9i + 9 so every graph in MMBG(10; m), m 4(mod 5), must have minimum degree two. Second, the only graph on ten vertices and ten edges with minimum degree two is C10. Theorem 3.11 proves that T5i+4(C10) > 9i + 9 57
v0
v1
v0
1
v9
v2
v1
3i+7
v9
3i+10
6i+15 7
v8
v3
6i+4
4 4
v7
3i+11 v7
2
v0 v9
3i+9
v5
v6
msg = 1, 2, ... , i+2
1.
v4
3i+9
3 v6
2.
v0
3i+16
6i+21
3i+8
v5
msg = i+3, i+4
v1
3i+13
3
v1
9i+8*
5
v9
v2
v2
6i+4
6
3i+16
v8
3i+17
6i+10
v8
v3
3i+19
6i+20
v7
v3
3i+13
v4
3
3i+10
v8
5
v2
v7
v4
v3
3i+11
6i+7 v4
3i+15 v6
v6
3i+14v5
v0
3i
v0
3i+2
v9
9i+4
9i+2
3i+6 v3
9i+8*
6i+7
v4 v6
v5
msg = 3i+1
6.
6i+11
9i+4
v7
v4 v6
v2
v8
6i+8
v7
3i+5
6i+9*
v3
v8
v1
6i+8* 3i+3
6i+12
3i+3
v9
v2
9i+1
v5
msg = 2i+2, 2i+3, ... , 3i
v1
6i+11
5.
4.
msg = i+5, i+6, ... , 2i+1
3.
6i+5
v5
msg = 3i+2, 3i+3
Figure 20: (Part 1 of 2) Scheme for broadcasting 5i +4 messages in 9i +9 time units in the graph from Figure 15 where i is any integer greater than or equal to 0. 58
v0
3i+9
v1
v0
3i+11
6i+2 v9
3i+15 v3
v8
6i+17
v7
v2
6i*
v3
v8
9i+2
3i+14
v9
3i+12
6i+13
v1
6i-1*
v2
6i+3
3i+12
9i-1*
6i+1*
6i+16 v7
v4
v4
9i+9 v6
9i+6* v6
v5
msg = 3i+4
7.
v0
6i+6
msg = 3i+5, 3i+6, ... , 4i+2
8.
v1
v0
3i+5*
v2
3i+6*
9i+8 v2
6
6i+9 v3
9i+9 7
v8
v3
8
3i+8* v7
v4
9i+9*
v7
v5
v6
msg = 4i+3, 4i+4, ... , 5i+2
9.
v0
v4
6i+9
6i+12* v6
9i+9
10.
v1 v2
9i+7
3 4
v8
5
v3
4 v7
v4
6i+6 v6
9i+8
v5
msg = 5i+4
Figure 20: (Part 2 of 2) 59
9i+5
v5
msg = 5i+3
2 v9
11.
v1
v9
3i+7*
v8
9i+6
5
6i+8
v9
v5
for any i 0 so we need at least eleven edges. We then prove that Bm(10) > 11, m 4(mod 5). Recall the argument we used in the m = 5 case to show that every degree two vertex must have a degree three neighbor. We can reuse that argument here. As for m = 5, let G be a graph on ten vertices. From Lemma 2.3 we have P v2G sends(v ) = (5i + 4)9 = 45i + 36. Let v be a vertex in G with d neighbors. Recall that d 2. From Lemma 2.4 and 2.5, if v is the originator then sends(v) min((5i + 4)d; 9i + 9); otherwise, sends(v) min((5i + 4)(d ? 1); 4i + 6 ? rst(v)). As for m = 5, we consider a broadcast scheme in the same graph G on ten vertices where the originator and its two neighbors are degree two. Thus, for each v 2 G, rst(v) has the same value as above. Using these values we get sends(v0) 9i + 9, sends(v1) 4i + 6 ? 1 = 4i + 5, sends(v2) and sends(v3) are 4i + 6 ? 2 = 4i + 4, sends(v4) and sends(v5) are 4i + 6 ? 3 = 4i + 3, sends(v6), sends(v7) and sends(v8) are 4i +6 ? 4 = 4i +2, and sends(v9) 4i +6 ? 5 = 4i +1 meaning Pv2G sends(v) (9i +9)+(4i +5)+2(4i +4)+2(4i +3)+3(4i +2)+(4i +1) = 45i +35 but we should have Pv2G sends(v) = 45i + 36. Thus, every degree two vertex must have a degree three neighbor. This is impossible to achieve with ten vertices and eleven edges so Bm(10) 12 when m 4(mod 5). 2
60
5 Conclusions and Open Problems We have determined exact values for Tm for paths, complete d-ary trees, cycles on an even number of vertices and hypercubes when the number of messages is small. We have also proven bounds on Tm for trees, cycles on an odd number of vertices, grids and hypercubes. We have determined exact values for Bm (n) when n = 1; 2; 3; 4; 5; 6; 8, and n = 10 when m 6= 2; 5; 5i + 4 and bounds when n = 10 and m = 2; 5; 5i + 4. For general m and n we have proven that Bm(n) n for n 4. Many open problems remain:
Proving or disproving the conjecture relating to trees. Investigating other graphs such as cycles with chords. Finding exact values for Tm(Cn) when n is odd. Finding a lower bound for Tm(Gn;n ) and nding schemes for grids providing better upper bounds.
Generalizing the schemes presented in Theorem 3.22 for all hypercubes. Finding general bounds for Bm(n). Finding values for Bm (n) for speci c values of n, especially 7 and 9. A general conjecture follows from the values found for Bm(8) and Bm (10). It seems that if one can nd values for Bm(n) for enough small values of m then one should be able to easily extend those results for all m. For example, Bm(8) = 12 for m = 1; 5; 9; :::. The reason for this is that once one has a scheme for a small value of m certain parts of that scheme can simply be repeated to handle larger values of m.
61
References [1] A. Averbuch, Y. Roditty and B. Shoham. Computation of broadcasting multiple messages in a positive weighted tree. To appear in J. Combin. Math. Combin. Comput.. [2] A. Bar-Noy and C.-T. Ho. Broadcasting multiple messages in the multiport model. Proceedings 10th International Parallel Processing Symposium, 1996. [3] A. Bar-Noy and S. Kipnis. Broadcasting multiple messages in simultaneous send/receive systems. Discrete Applied Mathematics, 55:95-105, 1994. [4] A. Bar-Noy and S. Kipnis. Multiple message broadcasting in the postal model. Networks, 29:1-10, 1997. [5] A. Bar-Noy, S. Kipnis and B. Schieber. Optimal multiple message broadcasting in telephone-like communication systems. Proceedings of the 6th IEEE Symposium on Parallel and Distributed Processing, 216-223, 1994. [6] J.-C. Bermond, P. Fraigniaud and J. Peters. Antepenultimate broadcasting. Networks, 26:125-137, 1995. [7] J. Bruck, R. Cypher and C.-T. Ho. Multiple message broadcasting with generalized Fibonacci trees. Proceedings 4th IEEE Symposium on Parallel and Distributed Processing, 424-431, 1992. [8] P. Chinn, S. Hedetniemi and S. Mitchell. Multiple-message broadcasting in complete graphs. Proceedings 10th S-E Conference Combinatorics, Graph Theory, and Computing, 251-260, 1979. [9] E. Cockayne and A. Thomason. Optimal multi-message broadcasting in complete graphs. Utilitas Mathematica, 18:181-199, 1980. 62
[10] M. Dinneen, J. Ventura, M. Wilson, and G. Zakeri. Compound constructons of broadcast networks. Discrete Applied Mathematics, 93:205-232, 1999. [11] A. Farley. Broadcast time in communication networks. SIAM Journal of Applied Mathematics, 39:385-390, 1980. [12] P. Fraigniaud. Broadcasting in trees. Research Report 95-26, Ecole Normale Superieure de Lyon, 1995. [13] H. Harutyunyan and A. Liestman. More broadcast graphs. To appear in Discrete Applied Mathematics, 1999. [14] S. Hedetniemi, S. Hedetniemi, and A. Liestman. A survey of broadcasting and gossiping in communication networks. Networks, 18:319-349, 1988. [15] O.-H. Kwon and K.-Y. Chwa. Multiple message broadcasting in communication networks. Networks, 26:253-261, 1995. [16] A. Liestman and J .Peters. Minimum broadcast digraphs. Discrete Applied Mathematics, 37/38:401-419, 1992. [17] A. Liestman and D. Richards. Perpetual gossiping. Parallel Processing Letters, 3(4):347-355, 1994. [18] W. Luo and Z. Wang, private communication, 1999. [19] S. Mitchell and S. Hedetniemi. A census of minimum broadcast graphs. Journal of Comb., Inform. & Systems Sci. 5:141-151, 1980. [20] A. Proskurowski. Minimum broadcast trees. IEEE Transactions on Computers, C-30(5), May 1981.
63
[21] Y. Roditty and B. Shoham. On broadcasting multiple messages in a d-dimensional grid. Discrete Applied Mathematics, 75:277-284, 1997. [22] R. Subramonian and N. Venkatasubramanyan. Ecient multipleitem broadcast in the LogP model. Parallel Processing Letters, 3(4):407-417, 1993. [23] F. Van Scoy and J. Brooks. Broadcasting multiple messages in grids. Discrete Applied Mathematics, 53:321-336, 1994. [24] I. Wojciechowska and F. Van Scoy. Broadcasting multiple messages in grid graphs. 6th Lakeview Conference on Computational Research and Materials, Morgantown, West Virginia, May 8-10, 1996.
64
A Details for Proving B5i+3(10) 15 and B5i+4(10) 15
Table 1 and Table 2 are used to prove that the broadcast schemes described in Figure 16 and Figure 20, respectively, are correct. They use the descriptions to calculate the call times scheduled for each edge in the broadcast graph (Figure 15) in order to ensure that no vertex is scheduled to make more than one call per time unit. The integers in the leftmost column denote the trees in Figures 16 and 20. In the second column, the expression to the left of the `=' sign shows how the sequence of call times to the right of the `=' sign is calculated. For example, suppose we are calculating the call times for edge e in tree r in Figure 16. Let t be the time value noted next to edge e, kmin the minimum message sent in tree r and kmax the maximum message sent in tree r. Then, we would insert a row below edge e in the following table like the following:
r 3( kmin :::kmax ? kmin ) + t = t; 3 + t; :::; 3(kmax ? kmin ) + t In other words, tree r schedules calls along edge e at times t; 3 + t; :::; 3(kmax ? kmin ) + t. If t had an asterix next to it then we would insert a ? sign in front of 3( kmin :::kmax ? kmin ) and insert the following row below edge e:
r ?3( kmin :::kmax ? kmin ) + t = t ? 3(kmax ? kmin ); :::; t See Theorem 4.12 for more details.
65
Edge (v0; v5) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1 3 3( 2i + 2:::2i + 2 4 3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 Edge (v1; v6) 1 3( 1:::i + 1 5 3( 3i + 3:::3i + 3 6 3( 3i + 4:::4i + 2 7 3( 4i + 3:::4i + 3 8 3( 4i + 4:::5i + 3 Edge (v2; v7) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3 Edge (v3; v8) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3 Edge (v4; v9) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3
? ? ? ? ?
1) +1 i + 2) + 3i + 4 2i + 2) + 6i + 4 2i + 3) + 6i + 7 3i + 3) + 9i + 7
= = = = =
1; 4; :::; 3i + 1 3i + 4; 3i + 7; :::; 6i + 1 6i + 4 6i + 7; 6i + 10; :::; 9i + 4 9i + 7
? ? ? ? ?
1) +4 3i + 3) + 3i + 7 3i + 4) + 3i + 10 4i + 3) + 6i + 7 4i + 4) + 6i + 10
= = = = =
4; 7; :::; 3i + 4 3i + 7 3i + 10; 3i + 13; :::; 6i + 4 6i + 7 6i + 10; 6i + 13; :::; 9i + 7
? ? ? ?
1) +4 i + 2) + 3i + 7 4i + 3) + 9i + 7 4i + 4) + 9i + 4
= = = =
4; 7; :::; 3i + 4 3i + 7; 3i + 10; :::; 6i + 4 9i + 7 6i + 7; 6i + 10; :::; 9i + 4
? ? ? ?
1) + 3i + 7 i + 2) + 6i + 10 4i + 3) + 3i + 4 4i + 4) + 3i + 1
= = = =
3i + 7; 3i + 10; :::; 6i + 7 6i + 10; 6i + 13; :::; 9i + 7 3i + 4 4; 7; :::; 3i + 1
? ? ? ?
1) +4 i + 2) + 3i + 7 4i + 3) + 9i + 7 4i + 4) + 9i + 4
= = = =
4; 7; :::; 3i + 4 3i + 7; 3i + 10; :::; 6i + 4 9i + 7 6i + 7; 6i + 10; :::; 9i + 4
Table 1: (Part 1 of 4) Edge call times from scheme described in Figure 16. 66
Edge (v0; v1) 3 3( 2i + 2:::2i + 2 4 3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 3( 3i + 4:::4i + 2 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3 Edge (v1; v2) 2 3( i + 2:::2i + 1 3 3( 2i + 2:::2i + 2 4 3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 3( 3i + 4:::4i + 2 Edge (v2; v3) 2 3( i + 2:::2i + 1 3 3( 2i + 2:::2i + 2 4 3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 3( 3i + 4:::4i + 2 Edge (v3; v4) 1 3( 1:::i + 1 4 3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 3( 3i + 4:::4i + 2 Edge (v4; v5) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1
? ? ? ? ? ?
2i + 2) + 3 2i + 3) + 6 3i + 3) + 3i + 6 3i + 4) + 3i + 9 4i + 3) + 6i + 6 4i + 4) + 9i + 6
= = = = = =
3 6; 9; :::; 3i + 3 3i + 6 3i + 9; 3i + 12; :::; 6i + 3 6i + 6 6i + 9; 6i + 12; :::; 9i + 6
? ? ? ? ?
i + 2) + 6i + 8 2i + 2) + 5 2i + 3) + 8 3i + 3) + 3i + 8 3i + 4) + 3i + 11
= = = = =
6i + 8; 6i + 11; :::; 9i + 5 5 8; 11; :::; 3i + 5 3i + 8 3i + 11; 3i + 14; :::; 6i + 5
? ? ? ? ?
i + 2) + 6i + 9 2i + 2) + 6 2i + 3) + 9 3i + 3) + 3i + 9 3i + 4) + 3i + 12
= = = = =
6i + 9; 6i + 12; :::; 9i + 6 6 9; 12; :::; 3i + 6 3i + 9 3i + 12; 3i + 15; :::; 6i + 6
? ? ? ?
1) +5 2i + 3) + 3i + 8 3i + 3) + 6i + 8 3i + 4) + 6i + 11
= = = =
5; 8; :::; 3i + 5 3i + 8; 3i + 11; :::; 6i + 5 6i + 8 6i + 11; 6i + 14; :::; 9i + 5
? 1) +3 ? i + 2) + 3i + 6
= 3; 6; :::; 3i + 3 = 3i + 6; 3i + 9; :::; 6i + 3
Table 1: (Part 2 of 4) 67
3 3( 2i + 2:::2i + 2 8 ?3( 4i + 4:::5i + 3 Edge (v5; v6) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1 3 3( 2i + 2:::2i + 2 6 3( 3i + 4:::4i + 2 7 3( 4i + 3:::4i + 3 Edge (v6; v7) 1 3( 1:::i + 1 2 3( i + 2:::2i + 1 3 3( 2i + 2:::2i + 2 4 ?3( 2i + 3:::3i + 2 Edge (v7; v8) 4 ?3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 ?3( 3i + 4:::4i + 2 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3 Edge (v8; v9) 3 3( 2i + 2:::2i + 2 4 ?3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 ?3( 3i + 4:::4i + 2 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3
? 2i + 2) + 6i + 6 = 6i + 6 ? 4i + 4) + 9i + 6 = 6i + 9; 6i + 12; :::; 9i + 6 ? ? ? ? ?
1) +2 i + 2) + 3i + 5 2i + 2) + 6i + 5 3i + 4) + 6i + 8 4i + 3) + 9i + 5
= = = = =
2; 5; :::; 3i + 2 3i + 5; 3i + 8; :::; 6i + 2 6i + 5 6i + 8; 6i + 11; :::; 9i + 2 9i + 5
? ? ? ?
1) +3 i + 2) + 3i + 6 2i + 2) + 6i + 6 2i + 3) + 9i + 6
= = = =
3; 6; :::; 3i + 3 3i + 6; 3i + 9; :::; 6i + 3 6i + 6 6i + 9; 6i + 12; :::; 9i + 6
? ? ? ? ?
2i + 3) + 9i + 5 3i + 3) + 6i + 5 3i + 4) + 6i + 2 4i + 3) + 3i + 5 4i + 4) + 3i + 2
= = = = =
6i + 8; 6i + 11; :::; 9i + 5 6i + 5 3i + 8; 3i + 11; :::; 6i + 2 3i + 5 5; 8; :::; 3i + 2
? ? ? ? ? ?
2i + 2) + 9i + 6 2i + 3) + 9i + 3 3i + 3) + 6i + 3 3i + 4) + 6i 4i + 3) + 3i + 3 4i + 4) + 3i
= = = = = =
9i + 6 6i + 6; 6i + 9; :::; 9i + 3 6i + 3 3i + 6; 3i + 9; :::; 6i 3i + 3 3; 6; :::; 3i
Table 1: (Part 3 of 4) 68
Edge (v9; v0) 3 3( 2i + 2:::2i + 2 4 ?3( 2i + 3:::3i + 2 5 3( 3i + 3:::3i + 3 6 ?3( 3i + 4:::4i + 2 7 3( 4i + 3:::4i + 3 8 ?3( 4i + 4:::5i + 3
? ? ? ? ? ?
2i + 2) + 9i + 5 2i + 3) + 9i + 2 3i + 3) + 6i + 2 3i + 4) + 6i ? 2 4i + 3) + 3i + 2 4i + 4) + 3i ? 1
= = = = = =
9i + 5 6i + 5; 6i + 8; :::; 9i + 2 6i + 2 3i + 5; 3i + 8; :::; 6i ? 1 3i + 2 2; 5; :::; 3i ? 1
Table 1: (Part 4 of 4) Edge (v0; v5) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1 4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 6 3( 3i + 2:::3i + 3 Edge (v1; v6) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1 6 3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 8 3( 3i + 5:::4i + 2 Edge (v2; v7) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1
? ? ? ? ? ?
1) +1 i + 3) + 3i + 7 i + 5) + 3i + 13 2i + 2) + 6i + 4 3i + 1) + 9i + 1 3i + 2) + 9i + 4
= = = = = =
1; 4; :::; 3i + 4 3i + 7; 3i + 10 3i + 13; 3i + 16; :::; 6i + 1 6i + 4; 6i + 7; :::; 9i ? 2 9i + 1 9i + 4; 9i + 7
? ? ? ? ? ?
1) +4 i + 3) + 3i + 10 i + 5) + 3i + 16 3i + 2) + 6i + 7 3i + 4) + 6i + 13 3i + 5) + 6i + 16
= = = = = =
4; 7; :::; 3i + 7 3i + 10; 3i + 13 3i + 16; 3i + 19; :::; 6i + 4 6i + 7; 6i + 10 6i + 13 6i + 16; 6i + 13; :::; 9i + 7
? 1) +4 = 4; 7; :::; 3i + 7 ? i + 3) + 3i + 10 = 3i + 10; 3i + 13 ? i + 5) + 3i + 16 = 3i + 16; 3i + 19; :::; 6i + 4
Table 2: (Part 1 of 5) Edge call times from scheme described in Figure 20. 69
4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 11 3( 5i + 4:::5i + 4 Edge (v3; v8) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1 4 3( 2i + 2:::3i Edge (v4; v9) 1 3( 1:::i + 2 8 ?3( 3i + 5:::4i + 2 9 ?3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4 Edge (v0; v1) 4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 6 3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 8 3( 3i + 5:::4i + 2 9 3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4 Edge (v1; v2) 4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 6 3( 3i + 2:::3i + 3
? 2i + 2) + 6i + 7 ? 3i + 1) + 9i + 4 ? 5i + 4) + 9i + 7
= 6i + 7; 6i + 10; :::; 9i + 1 = 9i + 4 = 9i + 7
? ? ? ?
1) +7 i + 3) + 3i + 13 i + 5) + 3i + 19 2i + 2) + 6i + 10
= = = =
7; 10; :::; 3i + 10 3i + 13; 3i + 16 3i + 19; 3i + 22; :::; 6i + 7 6i + 10; 6i + 13; :::; 9i + 4
? ? ? ? ?
1) + 6i + 4 3i + 5) + 6i + 1 4i + 3) + 3i + 7 5i + 3) + 7 5i + 4) + 4
= = = = =
6i + 4; 6i + 7; :::; 9i + 7 3i + 10; 3i + 13; :::; 6i + 1 10; 13; :::; 3i + 7 7 4
? ? ? ? ? ? ? ?
2i + 2) + 3 3i + 1) + 3i 3i + 2) + 3i + 3 3i + 4) + 3i + 9 3i + 5) + 3i + 12 4i + 3) + 6i + 6 5i + 3) + 9i + 6 5i + 4) + 9i + 9
= = = = = = = =
3; 6; :::; 3i ? 3 3i 3i + 3; 3i + 6 3i + 9 3i + 12; 3i + 15; :::; 6i + 3 6i + 6; 6i + 9; :::; 9i + 3 9i + 6 9i + 9
? 2i + 2) + 5 ? 3i + 1) + 3i + 2 ? 3i + 2) + 3i + 5
= 5; 8; :::; 3i ? 1 = 3i + 2 = 3i + 5; 3i + 8
Table 2: (Part 2 of 5) 70
7 3( 3i + 4:::3i + 4 8 3( 3i + 5:::4i + 2 9 3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 Edge (v2; v3) 4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 6 3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 8 3( 3i + 5:::4i + 2 9 3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 Edge (v3; v4) 1 3( 1:::i + 2 3 3( i + 5:::2i + 1 4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 6 3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 Edge (v4; v5) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 7 3( 3i + 4:::3i + 4 8 ?3( 3i + 5:::4i + 2 9 ?3( 4i + 3:::5i + 2
? ? ? ?
3i + 4) + 3i + 11 3i + 5) + 3i + 14 4i + 3) + 6i + 8 5i + 3) + 9i + 8
= = = =
3i + 11 3i + 14; 3i + 17; :::; 6i + 5 6i + 8; 6i + 11; :::; 9i + 5 9i + 8
? ? ? ? ? ? ?
2i + 2) + 6 3i + 1) + 3i + 3 3i + 2) + 3i + 6 3i + 4) + 3i + 12 3i + 5) + 3i + 15 4i + 3) + 6i + 9 5i + 3) + 9i + 9
= = = = = = =
6; 9; :::; 3i 3i + 3 3i + 6; 3i + 9 3i + 12 3i + 15; 3i + 18; :::; 6i + 6 6i + 9; 6i + 12; :::; 9i + 6 9i + 9
? ? ? ? ? ?
1) +5 i + 5) + 6i + 20 2i + 2) + 3i + 11 3i + 1) + 6i + 8 3i + 2) + 6i + 11 3i + 4) + 6i + 17
= = = = = =
5; 8; :::; 3i + 8 6i + 20; 6i + 23; :::; 9i + 8 3i + 11; 3i + 14; :::; 6i + 5 6i + 8 6i + 11; 6i + 14 6i + 17
? ? ? ? ?
1) +3 i + 3) + 3i + 9 3i + 4) + 9i + 9 3i + 5) + 9i + 6 4i + 3) + 6i + 12
= = = = =
3; 6; :::; 3i + 6 3i + 9; 3i + 12 9i + 9 6i + 15; 6i + 18; :::; 9i + 6 3i + 18; 3i + 21; :::; 6i + 12
Table 2: (Part 3 of 5)
71
Edge (v5; v6) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1 4 3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4 Edge (v6; v7) 1 3( 1:::i + 2 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1 9 ?3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4 Edge (v7; v8) 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1 6 ?3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 8 ?3( 3i + 5:::4i + 2 9 ?3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4 Edge (v8; v9) 2 3( i + 3:::i + 4 3 3( i + 5:::2i + 1
? ? ? ? ? ? ?
1) +2 i + 3) + 3i + 8 i + 5) + 3i + 14 2i + 2) + 6i + 5 3i + 1) + 9i + 2 5i + 3) + 9i + 5 5i + 4) + 9i + 8
= = = = = = =
2; 5; :::; 3i + 5 3i + 8; 3i + 11 3i + 14; 3i + 17; :::; 6i + 2 6i + 5; 6i + 8; :::; 9i ? 1 9i + 2 9i + 5 9i + 8
? ? ? ? ? ?
1) +3 i + 3) + 3i + 9 i + 5) + 3i + 15 4i + 3) + 9i + 9 5i + 3) + 6i + 9 5i + 4) + 6i + 6
= = = = = =
3; 6; :::; 3i + 6 3i + 9; 3i + 12 3i + 15; 3i + 18; :::; 6i + 3 6i + 12; 6i + 15; :::; 9i + 9 6i + 9 6i + 6
? ? ? ? ? ? ? ?
i + 3) + 3i + 11 i + 5) + 3i + 17 3i + 2) + 9i + 8 3i + 4) + 9i + 2 3i + 5) + 9i ? 1 4i + 3) + 3i + 8 5i + 3) + 8 5i + 4) + 5
= = = = = = = =
3i + 11; 3i + 14 3i + 17; 3i + 20; :::; 6i + 5 9i + 5; 9i + 8 9i + 2 6i + 8; 6i + 11; :::; 9i ? 1 11; 14; :::; 3i + 8 8 5
? i + 3) + 6i + 15 = 6i + 15; 6i + 18 ? i + 5) + 6i + 21 = 6i + 21; 6i + 24; :::; 9i + 9 Table 2: (Part 4 of 5) 72
5 3( 3i + 1:::3i + 1 6 ?3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 8 ?3( 3i + 5:::4i + 2 9 ?3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4 Edge (v9; v0) 4 ?3( 2i + 2:::3i 5 3( 3i + 1:::3i + 1 6 ?3( 3i + 2:::3i + 3 7 3( 3i + 4:::3i + 4 8 ?3( 3i + 5:::4i + 2 9 ?3( 4i + 3:::5i + 2 10 3( 5i + 3:::5i + 3 11 3( 5i + 4:::5i + 4
? ? ? ? ? ? ?
3i + 1) + 6i + 12 3i + 2) + 6i + 9 3i + 4) + 6i + 3 3i + 5) + 6i 4i + 3) + 3i + 6 5i + 3) + 6 5i + 4) + 3
= = = = = = =
6i + 12 6i + 6; 6i + 9 6i + 3 3i + 9; 3i + 12; :::; 6i 9; 12; :::; 3i + 6 6 3
? ? ? ? ? ? ? ?
2i + 2) + 9i + 8 3i + 1) + 6i + 11 3i + 2) + 6i + 8 3i + 4) + 6i + 2 3i + 5) + 6i ? 1 4i + 3) + 3i + 5 5i + 3) + 5 5i + 4) + 2
= = = = = = = =
6i + 14; 6i + 17; :::; 9i + 8 6i + 11 6i + 5; 6i + 8 6i + 2 3i + 8; 3i + 11; :::; 6i ? 1 8; 11; :::; 3i + 5 5 2
Table 2: (Part 5 of 5)
73
![MASTER OF DATA SCIENCE [PDF]](https://m.moam.info/img/260x300/master-of-data-science-pdf_64822ae6098a9e2b3c8b4575.jpg)
