\documentstyle[12pt,epsf,fleqn]{article}
%\documentstyle[epsf,fleqn]{article}
\textwidth=7in
\textheight=9in

\evensidemargin=-0.1in
\oddsidemargin=-0.1in
\topmargin=-0.375in
%%\topskip=0pt
%\baselineskip=12pt
%\parskip=0pt
%\parindent=0em

\newcommand{\eS}{\emptyset}
\newcommand{\ovl}{\overline}
\newcommand{\hsp}{\hspace*}
\newcommand{\vsp}{\vspace*}
\newcommand{\lam}{\lambda}
\newcommand{\ct}{\cite}
\newcommand{\mc}{\multicolumn}
\newcommand{\noi}{\noindent}

\pagestyle{myheadings}
\markboth{{\bf A Low-Cost Algorithm for Multicast Routing }}
{{\bf A Low-Cost Algorithm for Multicast Routing} }


\begin{document}
\thispagestyle{empty}
\Huge

	%
	% Title Slide
	%

%	\vspace*{\fill}
	\underline{\hspace {7in}}
	\vspace{0.3in}
	\begin{center}
	A Low-Cost Algorithm for Multicast Routing

	\quad \\
	\quad \\
	Pingyan Tan \\
	Frederick C. Harris, Jr.\\
	\quad \\

	Department of Computer Science\\
	University of Nevada\\
	Reno, Nevada 89557\\
	fredh@cs.unr.edu
	\end{center}
	\vspace{0.3in}
	\underline{\hspace {7in}}
	\vspace*{\fill}

\newpage
	%
	% ABSTRACT
	%
	\begin{center}
	Abstract
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	
	{ \LARGE
	\begin{itemize}
	\item This paper presents a low-cost algorithm for multicast
	routing in computer networks.

	\item For performance evaluation, it is compared with Link-State
	multicast routing, which is a low-delay algorithm used by the
	Internet MOSPF protocol~\cite{HUITEMA}.

	\item This new algorithm supports the {\it group} concept and 
	the {\it unknown-destination} delivery.  It
	uses a {\it minimum average distance} method to select the
	forwarding links to achieve the low-cost goal.  

	\item Another
	important feature of this algorithm is that no delivery tree
	has to be maintained, which eliminates the problem of memory
	and CPU congestion. Moreover, its computation time complexity
	is only linear in the group size. 

	\item Simulation study shows that
	this algorithm can lower delay by as much as 40 percent for the
	same offered load, compared with the low-delay algorithm.

	\end{itemize}
	}
\newpage
	%
	% Outline Slide
	%
	\vspace*{-0.4in}

	\begin{center}
	Outline of the Talk
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}

	{\LARGE
	\begin{itemize}
	\item A brief review of routing
	\item A short description of our algorithm
	\item Presentation of a simple example
	\item The simulation model
	\item Simulation results
	\item Conclusions and Future Work
	\end{itemize}
	}
	\vspace*{\fill}

\newpage
	%
	%
	%
	\begin{center}
	A {\it BRIEF} Review of Routing
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item Routing is one of the most important aspects of computer
		networks.
	\item Multicast Routing can be defined as follows: 
		\begin{itemize}
		\item Given a network $(N,L)$, where $N$ is a set of
			nodes and $L$ a set of links,
		\item a source node $s\in N$, 
		\item and a set of destination nodes $G{\subseteq} N$ 
			(the subset $G$ is called a {\it group}), 
			\begin{itemize}
			\item If $1<|G|<|N|-1$, then the problem is a
				multicast problem.
			\item If $|G|=1$, it is a unicast problem and 
			\item If $|G| = |N|-1$, it is a broadcast 
				problem. 
			\end{itemize}
		\end{itemize}
	\end{itemize}
	}
\newpage
	%
	%
	%
	\begin{center}
	A {\it BRIEF} Review of Routing (cont.)
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item Algorithms for solving the multicast routing problem can be
	divided into two categories: 
		\begin{itemize}
		\item Low-delay routing algorithms  
			\begin{itemize}
			\item minimize the path
			length from the source to every destination
			node. This usually requires that the message be
			sent to every destination along the shortest path.
			\end{itemize}
		\item Low-cost routing algorithms 
			\begin{itemize}
			\item minimize the total
			traffic. The total traffic is equivalent to
			the total length of the paths in a delivery
			tree. (this is equivalent to solving for the 
			Steiner Tree in a graph)
			\end{itemize}
		\end{itemize}
	\end{itemize}
	}

\newpage
	%
	%
	%
	\begin{center}
	A Short Description of our Algorithm
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
		\begin{itemize}
		\item 
	The main idea behind our algorithm is that we use the {\em
	minimum average distance} method to select the forwarding
	links. 
		\begin{itemize}
		\item When a packet arrives at a node, the algorithm
		computes the average distance for each neighbor of the
		current node, where the {\em average distance} is the
		average distance from the neighbor node to all nodes in
		its {\em responsible destination set}.

		\item Then we select the neighbor node which has the
		minimum average distance to forward the packet.

		\item This procedure continues until all destination
		members are processed.

		\end{itemize}
		\end{itemize}
	}

\newpage
	%
	% A Simple Example
	%
	\vspace*{-0.4in}

	\begin{center}
	A Simple Example
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
        \begin{figure}[h]
        %\epsfxsize=18em      
        \epsfxsize=15em      
        \centerline{\epsffile{../example.ps}}
        %\caption{Example Network} \label{example1}
        \end{figure}                              

	\begin{itemize}
        \item Assume that the source node is $S$, 
	\item The destination set    $G = \{E, F, M \}$.  
	\item Each node in the graph has a letter which is the name of the
	node and numbers which represent an ordering of their neighbors.
	\item The result shows that the cost generated by our                 
        algorithm is 11, but with shortest path algorithm, the total
        cost is 13.                                                 
	\end{itemize}
	}
        %                                                           
        %                                         
  

\newpage
	%
	% Example -- At Node S
	%
	\vspace*{-0.4in}

	\begin{center}
	A Simple Example: At node $S$
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\vspace{-0.2in}
	{\LARGE
        \begin{figure}[h]
        %\epsfxsize=18em      
        \epsfxsize=13em      
        \centerline{\epsffile{../example.ps}}
        %\caption{Example Network} \label{example1}
        \end{figure}                              
	\vspace{-0.7in}

	{\large
	\begin{tabbing}
	%\hsp{1.5em}\={\bf At node $S$}\\ 
	\hsp{1.5em}\={\bf }\\ 
	\hsp{1.5em}\>\hsp{1.5em}\=\hsp{2em}\=\hsp{1.5em}\=\hsp{2em}\=\hsp{2em}\=
	\hsp{2em}\=\hsp{2em}\=\\
	\>1.\>The packet is generated, $R=\infty$, and $A_S = \emptyset$. \\
	\\
	\>2.\>$G_S = \{E,F,M\}$ \\
	\\
	\>3.\>$N_S = \{H,C,B,M\}$,  $A_S = \emptyset$ \\
	\>  \>$D_H = \{E\}$    \>\>\>\> $L_H = 3 + 2 =5$ \\
	\>  \>$D_C = \{E,F\}$  \>\>\>\> $L_C = (3 + 4 + 2)/2 = 4.5$ \\
	\>  \>$D_B = \{F,M\}$  \>\>\>\> $L_B = (2+2+3)/2=3.5$ \\
	\>  \>$D_M = \{M,F\}$  \>\>\>\> $L_M=(4+0+2)/2=3$ \\
	\\
	\>4.\>$J=M$, $R_J=2$  \\
	\>  \>---{\bf send packet $p$ to $M$ with $p.radius=2$} \\
	\\
	\>5.\>$G_S=\{E\}$, $A_S = \{M\}$ --- go to step 3 \\
	\\
	\>  \> \>3.\> $N_S - A_S = \{H, C, B\}$ \\
	\>  \> \>\> $D_H=\{E\}$ \>\>\>$L_H=5$ \\
	\>  \> \>\> $D_C=\{E\}$ \>\>\>$L_C=7$ \\
	\>  \> \>\> $D_B=\emptyset$ \>\>\>$L_B = \infty$ \\
	\\
	\>  \> \>4.\> $J=H$, $R_J=2$ \\
	\>  \> \>\>---{\bf send packet $p$ to $H$ with $p.radius=2$}\\
	\\
	\>  \> \>5.\> $G_S = \emptyset$ --- stop
	\end{tabbing}
	}
	}
\newpage
	%
	%EXAMPLE -- At Node M
	%
	\vspace*{-0.4in}

	\begin{center}
	A Simple Example: At node $M$
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\vspace{-0.2in}
	{\LARGE
        \begin{figure}[h]
        %\epsfxsize=18em      
        \epsfxsize=13em      
        \centerline{\epsffile{../example.ps}}
        %\caption{Example Network} \label{example1}
        \end{figure}                              
	\vspace{-0.7in}

	{\large
	\begin{tabbing}
	%\hsp{1.5em}\={\bf At node $M$} \\ 
	\hsp{1.5em}\={\bf } \\ 
	\hsp{1.5em}\>\hsp{1.5em}\=\hsp{2em}\=\hsp{1.5em}\=\hsp{2em}\=\hsp{2em}\=
	\hsp{2em}\=\hsp{2em}\=\\
	\>1.\>$G=\{E,F,M\}$,  $R=2$,  $A_M=\{S\}$ \\
	\\
	\>2.\>$G_M=\{M,F\}$ \\
	\\
	\>3.\>$N_M=\{B,S,F\}$, $A_M=\{S\}$, $N_M-A_M=\{B,F\}$ \\
%	\>  \>$D_H = \{E\}$    \>\>\>\> $L_H = 3 + 2 =5$ \\
	\>  \>$D_B=\emptyset$  \>\>\>\> $L_B=\infty$ \\
	\>  \>$D_F=\{F\}$      \>\>\>\> $L_F=2/1=2$ \\
	\\
	\>4.\>$J=F$,  $R_J=0$ \\
	\>  \>---{\bf send packet $p$ to $F$ with $p.radius=0$} \\
	\\
	\>5.\>$G_M=\{M\}$, $A_M=\{S,F\}$ ---  go to step 3 \\
	\\
	\>  \> \>3.\>$N_M-A_M=\{B\}$ \\
	\>  \> \>  \>$D_B=\emptyset$ ---  stop
	\end{tabbing}
	}
	}
\newpage
	%
	% EXAMPLE -- At node H
	%
	\vspace*{-0.4in}

	\begin{center}
	A Simple Example: At node $H$
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\vspace{-0.2in}
	{\LARGE
        \begin{figure}[h]
        %\epsfxsize=18em      
        \epsfxsize=13em      
        \centerline{\epsffile{../example.ps}}
        %\caption{Example Network} \label{example1}
        \end{figure}                              
	\vspace{-0.7in}

	{\large
	\begin{tabbing}
	%\hsp{1.5em}\={\bf At node $H$} \\ 
	\hsp{1.5em}\={\bf } \\ 
	\hsp{1.5em}\>\hsp{1.5em}\=\hsp{2em}\=\hsp{1.5em}\=\hsp{2em}\=\hsp{2em}\=
	\hsp{2em}\=\hsp{2em}\=\\
	\> 1.\>$G=\{E,F,M\}$, $R=2$,  $A_H=\{S\}$ \\
	\\
	\> 2.\>$G_H=\{E\}$ \\
	\\
	\> 3.\>$N_H=\{E,S\}$, $N_H-A_H=\{E\}$ \\
	\>   \>$D_E=\{E\}$ \>\>\>\>$L_E=2$ \\
	\\
	\> 4.\>$J=E$, $R_J=0$ \\
	\>   \>---{\bf send packet $p$ to E with $p.radius=0$} \\
	\\
	\> 5.\>$G_H=\emptyset$ --- stop
	\end{tabbing}
	}
	}
\newpage
	%
	%
	%
	\begin{center}
	Simulation Studies
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item Simulation studies were performed on our algorithm and
		the Link-State multicast algorithm described in
		\cite{DEERING}, which is a low-delay algorithm.

	\item The Link-State multicast	algorithm was chosen because
		it assumes roughly the same network information as does
		our algorithm and because it is the multicast version
		of the Internet standard protocol OSPF and is used in
		the experimental MOSPF protocol~\cite{HUITEMA}.

	\item Also, by comparing with a low-delay algorithm, we were
		able to study the impact on delay by traffic reductions.
	\end{itemize}
	}

\newpage
	%
	%
	%
	\begin{center}
	Simulation Studies (cont.)
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item We studied two relationships:
		\begin{itemize}
		\item Delay vs. Offered load
		\item 	Utilization vs. Offered load
		\end{itemize}
	\item Informal Definitions:
		\begin{itemize}
		\item Delay -- the interval between the time a packet
		is generated and the time the pacet arrives at the
		destination.
			\begin{itemize}
			\item In a multicast environment, the delay is 
			the average delay for all destinations. 
			\end{itemize}
		\item Offered Load -- the rate of packet generation.
		\item Utilization -- the average utilization of all
			links.
		\end{itemize}
	\end{itemize}
	}
\newpage
	%
	%
	%
	\begin{center}
	Simulation Testbed
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item We randomly generated four networks with 40, 75, 97, and 123
		nodes respectively. 
	\item  We selected parameters that were reasonable and made the
		Link-State Algorithm perform well.
		\begin{itemize}
		\item  The key for the Link-State Algorithm is the group
			birth/death rate, since this causes a
			reconstruction of a group delivery tree.
		\end{itemize}
	\item The first 3,000 packets (on average) received at each node
		were discarded to ensure that the network reaches a
		steady state;
	\item Then statistics are collected for the subsequent 10,000
		packets (on average) received at each node.

	\end{itemize}
	}
\newpage
	%
	%
	%
	\begin{center}
	Results: Delay
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\begin{figure}[h]
	\vsp{-4ex}
	\epsfxsize=18em
	\centerline{\epsffile{../xdelayhigh.ps}}
	\vsp{-7ex}
	%\caption{Delays (higher message rates)} \label{xdelayhigh} 
	\end{figure}

\newpage
	%
	%
	%
	\begin{center}
	Results: Utilization
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\begin{figure}[h]
	\vsp{-4ex}
	\epsfxsize=18em
	\centerline{\epsffile{../xload.ps}}
	\vsp{-7ex}
	%\caption{Utilizations} \label{xload} 
	\end{figure}

\newpage
	%
	%
	%
	\begin{center}
	Results: Reductions
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\begin{figure}[h]
	\vsp{-4ex}
	\epsfxsize=18em
	\centerline{\epsffile{../xreduce.ps}}
	\vsp{-7ex}
	%\caption{Reductions} \label{xreduce} 
	\end{figure}


\newpage
	%
	%
	%
	\begin{center}
	Conclusions \& Future Work
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item It is known that a low-cost algorithm can reduce traffic
		and delay.
	\item This study shows that with our simple algorithm that
	requires only a linear time complexity, the delay can be
	substantially lower than that offered by always taking the
	shortest path, and yet this algorithm has all the elements that
	are required for multicasting, such as efficient computation,
	group addressing, and compatibility with unicasting. 

	\item For more efficiency, we can allow the packet to carry a limited
	number of member addresses. Suppose we let the packet carry the
	addresses of the four most remote members, the radius $R$ will be
	smaller and the algorithm will converge faster. As shown by
	Aguilar~\cite{AGUILAR} the IP header usually has 40 bytes for
	optional use; therefore, such consideration is highly
	feasible.

	\end{itemize}
	}
%%
%%
%%	This is really the end of the talk, but..
%%
%%  	Extra Stuff I may want goes here ...
%%
%%
\newpage
	%
	%
	%
	\begin{center}
	Results(cont.)
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\begin{figure}[h]
	\vsp{-4ex}
	\epsfxsize=18em
	\centerline{\epsffile{../xdelaylow.ps}}
	\vsp{-7ex}
	\caption{Delays (lower message rates)} \label{xdelaylow} 
	\end{figure}

\newpage
	%
	%
	%
	\begin{center}
	Results(cont.)
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\begin{figure}[h]
	\vsp{-4ex}
	\epsfxsize=18em
	\centerline{\epsffile{../xdelay40.ps}}
	\vsp{-7ex}
	\caption{Delays for $N=40$} \label{xdelay40} 
	\end{figure}

\newpage
	%
	%
	%
	\begin{center}
	Results(cont.)
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	\begin{figure}[h]
	\vsp{-4ex}
	\epsfxsize=18em
	\centerline{\epsffile{../xload40.ps}}
	\vsp{-7ex}
	\caption{Utilizations for $N=40$} \label{xload40} 
	\end{figure}
 

%%%%%%%%%%%%%%%%%%%%%


\newpage
	\begin{center}
	{\Huge Multicast Routing Algorithm Requirements}
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
		\begin{itemize}
		\item 
                For a general multicast routing algorithm, some basic
                requirements should be considered:

		\begin{enumerate}
		\item The algorithm should be computationally efficient:
                an algorithm is not useful if it requires  more than
                linear time to determine to which link a packet is to
                be sent.  A constant-time complexity is preferred.

		\item The algorithm should be scalable: it should not
		be heavily dependent on network size, group size, etc.

		\item The algorithm should be compatible with unicast
                routing: it should not require excessive information
                when compared with unicast routing and should not change
                dramatically from the unicast environment.

		\item The algorithm should seek a minimization of delay
                and traffic: these two goals may or may not conflict
                with each other. A minimum-cost tree may require
                packets to reach some member host along a path that is
		not the shortest
                path. But when the minimum-cost tree is utilized, the
                entire traffic is reduced, which may help reduce the
                delay.
		\end{enumerate}
		\end{itemize}

	}
\newpage
	\begin{center}
	{\Huge Algorithm Description - Preliminaries}
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\Large

	\begin{itemize}
	\item To describe the algorithm, we first define the following 
	variables:
	\begin{list}{}{
              \setlength{\leftmargin}{4em} 
              \setlength{\itemsep}{0pt}
              %\setlength{\partopsep}{0pt}
              \setlength{\parsep}{0pt}
              \setlength{\topsep}{1ex}
              %\setlength{\labelsep}{1em}
              \renewcommand{\makelabel}[1]{#1{\hfill}}
              }
	\item[{$G$}]    The destination set, that is, a group.
	\item[{$G_i$}]  Node $i$'s responsible destination set. It is
		the subset of $G$ to which node $i$ is responsible for
		delivering the message.
	\item[$N_i$]    Node $i$'s open neighborhood set, i.e., all of
		node $i$'s neighbor nodes except for node $i$ itself.
	\item[$D_j$]    Neighbor $j$'s responsible destination set. 
	\item[$L_j$]    Average distance from neighbor node $j$ to
		$j$'s responsible destination set.
	\item[$A_i$]    The assigned neighbor set, i.e., the subset of
		$G_i$ that has been assigned to a link.
	\item[$d_{ij}$] The shortest path distance from node $i$ to node $j$.
	\end{list}

	\item 
	In addition to the routing table of its own, each node also
	keeps the routing table of its neighbors, which is the common
	practice in the distributed Bellman-Ford
	algorithms~\cite{BERTSEKAS}. As usual, the routing table at each
	node is assumed to contain the following entries that are related
	to our work:
	\\
        \noindent\hspace*{0.2in}$\bullet$ destination\\
        \noindent\hspace*{0.2in}$\bullet$ shortest distance\\
        \noindent\hspace*{0.2in}$\bullet$ next hop
	
	\noindent
	where ``next hop'' tells which link to take to reach the
	destination on the shortest path from the current node. We do
	not use the tabled next hop directly, but compute the next hop
	based on our algorithm. In the algorithm, each packet $p$ is
	required to carry a small integer $p.radius$ that is used in 
	conjunction with the next-hop entries to compute the routing
	path.
	\end{itemize}
	}

\newpage
	\begin{center}
	An Informal Algorithm Description
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\LARGE
	\begin{itemize}
	\item When a packet arrives at a node $i$ and is addressed
	to group $G$, we give a condition to limit the size of the
	destination set -- that is, to decide to which members of group
	$G$ should be sent the packet from the current node $i$.

	\item We use a variable $p.radius$ as the condition. The value
	of $p.radius$ is the path distance between the current node
	and the most remote destination member. That is, the current
	node $i$ sends packets only to those members (in $G_i$) whose
	shortest-path distance from node $i$ is less than or equal to
	$p.radius$.
		\begin{itemize}
		\item If node $i$ is the source node, then we set 
			$p.radius$ $=\infty$.  This means that at the
			beginning, we consider all members of the group
			$G$ as the destination set.

		\item If node $i$ is not the source node, the packet must
			have come from its parent node; the packet then
			carries a radius with it which was computed at
			the parent node.
		\end{itemize}
	\end{itemize}
	}
\newpage
	\begin{center}
	{\Huge The Formal Algorithm Description}
	\end{center}
	\vspace{-0.3in}
	\underline{\hspace {7in}}
	{\large
	Suppose packet $p$ arrives at node $i$ via a neighbor node $k$
	or is generated at node $i$. The description of the algorithm
	is as follows:
	\newcounter{xdb}
	\begin{list}{\arabic{xdb}.}
            {\usecounter{xdb}
              \setlength{\leftmargin}{3.25em} 
              %\setlength{\partopsep}{0pt}
              \setlength{\parsep}{0pt}
              \setlength{\topsep}{1ex}
              \setlength{\itemsep}{0.0ex}
              \setlength{\labelsep}{1em}
            }
	\item If $i$ is the source node,  \\
      		\hsp{\mathindent}$R = \infty$;\hsp{1em} $A_i = \emptyset$;\\
      		else \\
      		\hsp{\mathindent}$R = p.radius$;\hsp{1em} $A_i$ = $\{k\}$;\\
      		If $R=0$, \  stop. 
	\item Compute node $i$'s responsible set
	%\begin{equation}
  	\[G_i = \{g\,|\,g\in G,\  d_{ig} \leq R\ {\rm and}\ g\neq i\} \]
	%\label{one}
	%\end{equation}
	\item For each $j\in N_i$ and $j\not\in A_i$, compute $j$'s 
		destination set
		\begin{equation}
  		D_j = \{g | g \in G_i\ {\rm and}\  d_{jg} < d_{ig} \}
		\label{two}
		\end{equation}
  		and the average length
		\begin{equation}
  	L_j = (d_{ij} + \sum_{g \in D_j} d_{jg} - \hat{L}_j ) /|D_j|
		\label{three}
		\end{equation}
  		where $\hat{L}_j$ is the sum of the overlapping next-hop 
		links, defined as
  		\[ \hat{L}_j = \sum_{n_{jk} > 1} (n_{jk}-1) l_{jk}\] 
  		where $n_{jk}$ is the number of members in $D_j$ that 
		will be sent via link $jk$ from node $j$ to node $k$, 
		and $l_{jk}$ is the length of the link. 
  		If (all $D_j = \emptyset$) or ($N_i = A_i$), \ stop.
	\item  Let $J$ be the subscript such that 
		\[L_J=\min_{j\in N_i, j\not\in A_i} L_j\]
		 and define
		\begin{equation}
		R_J = \max_{g\in D_J} d_{Jg}         \label{eqRJ}\label{four}
		\end{equation}
		Send a packet with radius $R_J$ to node $J$.
	\item  $G_i = G_i - D_J \hsp{\mathindent}  A_i = A_i \cup \{J\}$ \\
  		If $G_i = \emptyset$\\
  		\hsp{\mathindent} stop \\
  		else\\
  		\hsp{\mathindent} go to step 3.  \hfill $\Box$
	\end{list}
	}

\newpage
\large
\bibliographystyle{ieee}
\bibliography{bib}
\end{document}
