\documentclass[11pt, letterpaper, twoside]{article}
\usepackage{macros-course-lectures}
\author{Seth Gilbert}

\begin{document}

\lecture{notes17}{Applications of Sparse Covers}{November 5, 2002}

\section{Introduction}
\begin{itemize}
  \item Awerbuch and Peleg
  \item Presenting two algorithms
  \begin{enumerate}
    \item Routing (static)
    \item Tracking Mobile Users (dynamic)
  \end{enumerate}
  \item Application of Sparse Covers
  \item Focus on trade-off between degree and radius
\end{itemize}
\section{Routing}
\begin{itemize}
\item	Problem Statement:
\begin{itemize}
\item	Graph: $G = (G,E)$
\item	Edge weights: $w : E \to Z$
\item	Deliver messages from node $u \to v$
\end{itemize}
\item	Topology is known
\item	Trivial (optimal time) solution
\begin{itemize}
\item	Run all-pairs-shortest path
\item	Maintain next-hop routing table
\item	$O(n\cdot \log(n))$ space
\end{itemize}
\item	This gives optimal distance solution, but takes too much space
\item	Trivial space-efficient solution
\begin{itemize}
\item	Choose a leader L
\item	u sends message to L
\item	L sends message to v
\item	good space bound (only have to route to L)
\item	ITR (Interval Routing)
\end{itemize}
\item	Bad time bound
\item	At worst $2*diameter$
\item	Use hierarchical covers to find a mid-point
\item	Let $C$ be a cover
\begin{itemize}
\item	if $u,v$ in same cluster in $C$ then
\begin{itemize}
\item	deliver messages
\end{itemize}
\item	else
\begin{itemize}
\item	fail
\end{itemize}
\item	Use ITR as above:
\begin{itemize}
\item	For each cluster, choose a leader
\item	Route from u to leader, leader to v
\end{itemize}
\end{itemize}
\item	Good space bound: only route to leader
\item	Larger degree, larger space bound
\item	Must route to leader in each cluster
\item	Good time bound:  $2*diam(C)$
\item	Note: larger diameter, worse delivery time
\item	Can't deliver to all nodes!! (only nodes in cluster)
\item	Therefore: choose hierarchy of covers C(1),C(2),C(3),\ldots
\item	If $dist(u,v)<m$:
\begin{itemize}
\item	then u and v are in the same cluster in cover $C(\log(m))$
\item	$Radius(C(k)) = 2^k$
\end{itemize}
\item	Algorithm
\begin{itemize}
\item	Start at cluster C(1)
\item	If routes successfully, stop
\item	Else go to cluster C(2) and repeat
\end{itemize}
\item	Analysis
\begin{itemize}
\item	Let d = dist(u, v)
\item	Worst delivery time (at end of hierarchy): 4d
\item	Note: delivered over log(n) smaller levels of hierarchy as well
\item	Larger radius, worse delivery time
\item	Good space bounds: log(n) levels of routing information, instead of n table entries of routing information
\item	Larger degree, worse space bounds
\end{itemize}
\item	How to get such a cover?
\item	Can't get EXACTLY this good a cover, so results aren't as
  clean
\begin{itemize}
\item	Take one neighborhood cover of size $m$
\item	Coarsen until sets are about the right size
\item	If $dist(u, v) < m$:
\item	Take cover in $N_m(u)$
\item	We know $v$ is in $N_m(u)$
\item	By coarsening rules:
\item	$\exists S \in C st. N_m(u) \subseteq S$
\end{itemize}
\item	Final results:
\item	For all integers $k>0$:
\item	Delivery = $d*k^2$
\item	Space = $n^(\frac{1}{k})*\log(n)^2*\log(diam)$
\end{itemize}
\section{Tracking Mobile Users}
\begin{itemize}
\item	Warning:
\item	Slightly different presentation from the paper
\item	Emphasizes similarity to Routing problem
\item	(and slightly simpler)
\item	Problem Statement
\begin{itemize}
\item	Graph G=(V,E)
\item	Weights: $w:E \to Z$
\item	User, $u$, mobile
\item	User, $v$, fixed
\item	FIND: Send message from $v$ to $u$
\item	MOVE Allow $u$ to travel
\end{itemize}
\item	Assume no concurrency!
\item	Goal
\begin{itemize}
\item	Time to FIND should be proportional to $dist(u, v)$
\item	Time to MOVE should be proportional to $dist(u, u')$
\end{itemize}
\item	Assume a cover C
\begin{itemize}
\item	$u$ updates every leader, for all clusters, to its new location
\item	$v$ sends a message to the leader of its cluster
\item	leader sends message to $u$
\end{itemize}
\item	Note similarity to routing case!
\item	If $u$ and $v$ are in the same cluster, success!
\item	FIND(C) proportional to diameter
\item	MOVE(C) proportional to diameter*degree
\item	Use hierarchy of covers C(1), C(2), …
\item	Choose covers such that if:
\item	$d = dist(u,v)$
\item	$u$ and $v$ share a cluster in cover $C(\log(d))$
\item	Simple FIND algorithm:
\begin{itemize}
\item	Start a smallest cover, and incrementally search larger covers
  until u is found
\end{itemize}
\item	Good FIND time!
\item	Update all covers??
\item	Expensive to update high diameter covers
\item	Only update high diameter covers when moving far
\item	New Move algorithm:
\begin{itemize}
\item	Remember the location known to each cover:
\item	L(1), L(2), \ldots
\item	Remember how far you have traveled since you last updated it
\item	if $dist-traveled(L(i), u) > 2^i - 1$
\item	update cover $i$ (and all smaller)
\item	Only update covers when you move far
\end{itemize}
\item	Beware stale data!
\item	Some covers contain bad location
\item	At old location $L(i+1)$ store forwarding pointer
\item	New Find algorithm:
\begin{itemize}
\item	Start at smallest cover
\item	Incrementally search larger covers until u is found
\item	Follow forwarding pointers to u
\end{itemize}
\item	Search is fast:
\begin{itemize}
\item	if $d = dist(u, v)$
\item	then $u$ and $v$ share a cluster in cover $C(\log(d))$
\item	At most search $\log(d)$ covers
\item	Search takes time proportional to $d$
\item	Forwarding pointers are fast:
\item	Assume, $v$ finds $u$ in cover $C(i)$
\item	$i ~ \log(d)$
\item	Update rule: $dist-traveled(L(i), u) < 2^i$
\item	$dist-traveled(L(i), u) < d$
\end{itemize}
\item	Trade-off between diameter and degree
\item	Need small diameter, small degree
\item	Concurrent solutions:
\begin{itemize}
\item	Atomic updates of covers
\item	locking
\item	Ensure that v doesn't chase u forever down a forwarding path,
  as u keeps moving faster than v can search
\end{itemize}
\end{itemize}
\section{Conclusion}
\begin{itemize}
\item	Hierarchical use of covers provides good locality
\item	Interesting generalization to m-matching (locality sensitive quorums)
\item	No fault tolerance!
\item	Assume static network
\item	Section on dynamic network, but still much work to be done
\end{itemize}

\end{document}

