Proc. 31'st IEEE Symp. on Foundations of Computer Science, October 1990, St. Louis 1Sparse Partitions(Extended Abstract1)Baruch Awerbuch � David Peleg yAbstract: This abstract presents a collection of cluster-ing and decomposition techniques enabling the construc-tion of sparse and locality preserving representations forarbitrary networks. These new clustering techniques havealready found several powerful applications in the area ofdistributed network algorithms. Two of these applicationsare described in this abstract, namely, routing with poly-nomial communication-space tradeo� and online trackingof mobile users.1 Introduction1.1 MotivationAs networks grow larger, various control and manage-ment functions become increasingly more complex andexpensive. Traditional protocols, based on a global ap-proach, require all sites to participate in their activi-ties, and to maintain considerable amounts of globalinformation (e.g. topological data, status tables etc).This becomes problematic due to space considerations,the complexity of maintaining and updating this globalinformation and the increasing work loads on partici-pating sites.This realization has led to the development of sys-tems based on clustered (and hierarchical) representa-tions of networks. Such methods allow processors tomaintain only limited (local) knowledge regarding the�Department of Mathematics and Lab. for Com-puter Science, M.I.T., Cambridge, MA 02139; ARPANET:baruch@theory.lcs.mit.edu. Supported by Air Force Con-tract TNDGAFOSR-86-0078, ARO contract DAAL03-86-K-0171, NSF contract CCR8611442, DARPA contract N00014-89-J-1988, and a special grant from IBM.yDepartment of Applied Mathematics, The Weizmann In-stitute, Rehovot 76100, Israel; BITNET: peleg@wisdom. Sup-ported in part by an Allon Fellowship, by a Walter and EliseHaas Career Development Award and by a Bantrell Fellowship.Part of the work was done while visiting IBM T.J. Watson Re-search Center.1Full details for most of the results of this abstract can befound in [AP89b, AP89a, Pel89, Pel90]

state of the network. In particular, the representationmethod considered in this paper is based on breakingthe network G(V;E) into connected regions, or clus-ters, and thus obtaining a cover for the network, i.e., acollection of clusters that covers the entire set of ver-tices V . (A partition is a cover consisting of disjointclusters.) Informally speaking, a protocol based onsuch a cover will require a vertex to participate onlyin those activities that occur in the cluster(s) it be-longs to. Consequently, the cost of a task tends todepend on its locality properties in the clustered repre-sentation: a task involving a single cluster is relativelycheap, whereas a task requiring cooperation betweensites from di�erent clusters would be more expensive.A potential problem with a naive implementation ofthe cluster cover approach is that the resulting rep-resentation might not necessarily conform with thetopological structure of the network, and particularly,that it might have di�erent locality properties. For in-stance, it is possible that two neighboring nodes will�nd themselves in di�erent clusters in the cover (whichwould make tasks requiring information exchange be-tween these nodes more complex). Clearly, it is de-sirable that the performance of a task depend on itslocality properties in the real network. This translatesinto the following requirements. First, when the giventask concerns only a subset of the sites, located in asmall region in the network, one would like the execu-tion of the task to involve only sites in or around thatregion. Further, it is desirable that the cost of the taskbe proportional to its locality level.The above discussion motivates the need for localitypreserving network covers, whose structure faithfullycaptures the topology of the network itself. This ab-stract supplies the graph-theoretic tools for achievingthis goal, by presenting a collection of clustering anddecomposition techniques enabling the construction ofe�cient cover-based locality preserving representationsfor arbitrary networks. Some applications for thesetechniques are described as well.

1.2 Basic parametersLet us �rst attempt to identify the appropriate criteriafor evaluating the quality of a cluster cover. There aretwo inherent criteria of interest for cluster design. The�rst is the \size" of the clusters; intuitively, small clus-ters require less internal communication and providefaster response. The second criterion is the level of\interaction" between clusters. This notion is meantto capture the extent to which individual vertices be-longing to one cluster need to be involved in the a�airsof other (neighboring or overlapping) clusters.Next, let us discuss the technical manifestations ofthe two qualitative criteria de�ned above in our cover-based representations. The \size" of the cluster is cap-tured by its radius. As for the \interaction level" cri-terion, we refer to the technical measures related tothis notion as the sparsity of the cover. There are sev-eral plausible de�nitions for this sparsity measure, andthe ones considered in this abstract are those proveduseful in various applications. All of these de�nitionsrely on the degrees of vertices or clusters in either thecover, the graph itself or the induced cluster graph.For one concrete example, a possible sparsity measurefor a cover S (with cluster overlaps), denoted �(S),is the maximum number of occurrences of a vertex inclusters S 2 S, (i.e., the maximum degree of a vertexin the hypergraph (V;S)). In a sense, this measurecaptures the extent of the overlaps existing betweenthe clusters in the given cover.The crucial point we would like to stress is that thecriteria of cluster radius and sparsity are tightly relatedto the signi�cant complexity measures of distributednetwork algorithms. In all applications considered inthe sequel, smaller cluster radii in a given cover di-rectly translate into lower time complexities, due tothe fact that computations are performed inside clus-ters, on shortest path trees spanning the clusters. Atthe same time, low sparsity (to be speci�c, low de-grees of vertices in the cover) guarantees low memoryrequirements, since each vertex is actively involved in(and thus stores information for) only the clusters itbelongs to. Finally, and perhaps most importantly,the communication complexity of cover-based proto-cols strongly depends on both parameters (typically intheir product).It is therefore worthwhile to attempt to devise graphcovers that are e�cient in both parameters. The keyproblem we are faced with lies in the fact that thetwo parameters apear to be inherently con icting, andimproving one of them usually results in degrading theother. Our task therefore becomes that of striking abalance between the two parameters, and seeking theappropriate break-point for each of our applications.

Note that if one ignores the sparsity requirement, itis a simple matter to design a locality preserving covereven for arbitrary networks: for any desirable radius m(serving as the \locality" parameter), select the coverNm containing all the radius m neighborhoods of everynode in the network. This guarantees that if two nodesare at distance at most m of each other, there exists acommon cluster containing both of them. The obviousproblem with this cover is that it might not be sparse;it may be that some nodes occur in many clusters,incurring high costs.1.3 ConstructionsAll the algorithms presented in this abstract for con-structing good (namely, sparse) covers are based on thecentral idea of coarsening. These algorithms share thefollowing overall structure. We are given some initialcover S, dictated by the application. This will usuallybe some natural cover (for instance, the neighborhoodcover Nm for some m), that is not necessarily sparse.The goal of our algorithm is to construct, via repeatedcluster merging, a coarsening cover T (namely, withthe property that each original cluster is fully sub-sumed in one of the clusters of T ) that is relativelysparse on the one hand, and whose cluster radii arenot much larger than those of S on the other hand.(We refer to the ratio between the respective radii ofS and T clusters as the radius ratio of the coarsening.)Our results exhibit a tradeo� between the two param-eters: better sparsity implies worse radius ratio, andvice versa. For example, one may get coarsening cov-ers with radius ratio O(k) and average degree O(n1=k),for every 1 � k � logn. (Throughout, n denotes thenumber of vertices in the network.) The lower boundsestablished in Thm. 5.4 imply that these tradeo�s arenearly tight.When addressing our sparsity criteria, it is possibleto consider either the maximum or the average spar-sity. The algorithms for reducing the average sparsityare simpler, and in fact, for some applications theysu�ce to enable considerable reduction in space andcommunication complexities. However, our strongestalgorithms manage to bound also the maximum spar-sity measure (albeit with somewhat inferior bounds).The special signi�cance of bounding the maximumde-grees is that this typically enables us to bound thespace and communication costs of individual processes,rather than just the total costs, and therefore enableus to balance both the memory loads and the workinvested in communication among the processors in asatisfactory manner.Clustering techniques become most potent whenused in conjunction with a hierarchical structure. The

idea is to construct a hierarchy of covers, with higherlevels using larger radii clusters. This enables com-munication and data structures to be organized at theappropriate level according to the \locality level" ofthe application itself: an application that only calls forneighboring vertices to communicate with each othercan be carried out at the lowest level of the hierar-chy, incurring the lowest costs possible. On the otherhand, tasks involving distant vertices will be performedon higher levels of the hierarchy, and will cost accord-ingly. These ideas are demonstrated in the applicationspresented in the sequel.We shall also discuss several other graph-theoreticstructures that are strongly related to covers. Theseinclude sparse spanners (cf. [PS89]), tree covers ofgraphs (cf. [AKP90]), and the new concepts of regionalmatchings and diameter-based separators. All of thesestructures are constructible using one of our clusteringalgorithms, and each of them has proved to provide aconvenient representation for handling certain networkapplications.Another related graph structure is the network de-composition de�ned in [AGLP89]. Linial and Saks[LS90] have given the best known sequential algorithmfor constructing such a decomposition, which is relatedto diameter-based separators, and also devised an in-genious randomized distributed implementation.1.4 ApplicationsThe new clustering techniques described herein havealready found several applications in the area of dis-tributed network algorithms. One such application isthat of maintaining locality preserving distributed datastructures, particularly directories. This application ishandled in [Pel90] using the average cover algorithmAV COVER described in Section 5.Another application involves the classical problemof deadlock-free routing. In [AKP90], it is shown howto use the tree covers of Section 6.4 in order to devisea deadlock-free routing scheme using fewer bu�ers atthe cost of increasing the route length. Speci�cally,the resulting routing requires O(k �n1=k � logDiam(G))bu�ers per vertex, where Diam(G) denotes the diam-eter of the network, and the routes are at most O(k)longer than optimal.In [AP] we use regional matchings to construct anovel synchronizer, with only O(log3 n) communica-tion overhead; this is a signi�cant improvement overprevious solutions which have �(n) overhead. Astraightforward distributed implementation of algo-rithm MAX PARTc can also be used in order to yield afast (polylog time) preprocessing algorithm for settingup synchronizer of [Awe85].

Other applications related to our covering tech-niques are described in [AR90, LS90].In the sequel we present in detail two powerful ap-plications, for designing e�cient routing and trackingmechanisms.RoutingDelivering messages between pairs of processors is aprimary activity of any distributed communicationnetwork. Naturally, it is desirable to route messagesalong short paths. The straightforward approach ofstoring a complete routing table in each vertex v in thenetwork guarantees optimal routes, but requires a totalof O(n2 logn) memory bits in the network. Thus, onebasic goal in large scale communication networks is thedesign of routing schemes that produce e�cient routesand have relatively low memory requirements. Evi-dently, locality-preserving representations of the net-work play an important role in this task.The problem of e�ciency-memory tradeo�s for rout-ing schemes was �rst raised in [KK77], and laterstudied extensively (e.g. [BJ86, Per82, FJ88, SK85,vLT86, PU89a, ABLP89, Pel90]). It turns out thatthis e�ciency-memory tradeo� is strongly related tothe radius-sparsity tradeo� of neighborhood covers.This observation served as the basis of the previoussolutions to the routing problem in [PU89a, ABLP89,Pel90], although the particular clustered representa-tions used in these papers, as well as the resultingrouting procedures, are considerably di�erent than ourcurrent ones.Let us brie y compare the properties of our newscheme with previous ones. The e�ciency of a rout-ing scheme is measured in terms of its stretch, namely,the maximum ratio between the length of a routeproduces by the scheme for some pair of processorsand their distance. The family of hierarchical rout-ing schemes (for every integer k � 1) presented in[PU89a] guarantee stretch O(k) and require storinga total of O�k3n1+1=k logn� bits of routing informa-tion in the network. This behavior is almost optimalas far as total memory requirements are concerned,as implied from a lower bound given in [PU89a] onthe space requirement of any scheme with a givenstretch. However, this scheme does not bound the in-dividual memory requirements of each vertex, and itis also limited to unit cost edges. The schemes pro-posed in [ABLP89, Pel90] bound the worst-case in-dividual memory requirements of vertices, but at thecost of an inferior e�ciency-space tradeo�. In particu-lar, in an n-processor network G of weighted diameterDiam(G), the schemes HSk of [ABLP89], for k � 1,use O(k �logn�n 1k ) bits of memory per vertex and guar-

antee a stretch of O(k2 � 9k), while the schemes Rk of[Pel90], for k � 1, use O(logDiam(G)�logn�n 1k ) bits ofmemory per vertex and guarantee a stretch of O(4k).Thus the stretch becomes exponential in k, in contrastwith the linear dependency achieved in [PU89a].Our new schemes remedy this situation. For ev-ery (weighted) network G and every integer k �1, we construct a name independent hierarchi-cal routing scheme Hk with stretch O(k2) usingO(kn1=k logn logDiam(G))) memory bits per vertex.Thus the new scheme regains the polynomial depen-dency of the stretch factor on k. We comment that theschemes of [ABLP89] have the advantage of a purelycombinatorial space complexity, i.e., complexity thatdoes not depend on the edge weights.Online tracking of mobile usersWhen users in a distributed communication networkare mobile, i.e., are allowed to move from one networkvertex to another, it is necessary to have a mechanismenabling one to keep track of them and contact themat their current residence. Our purpose is to designe�cient tracking mechanisms, based on distributed di-rectory structures (cf. [LEH85]), minimizing the com-munication redundancy involved.There are many types of network activities that mayfall under the category of mobile users. A prime ex-ample is that of cellular phone networks. In fact, onemay expect that in the future, all telephone systemswill be based on \mobile telephones numbers," i.e.,ones that are not bound to any speci�c physical loca-tion. Another possible application is a system one maycall \distributed yellow pages," or \distributed match-making" [MV88]. Such a system is necessary in an en-vironment consisting of mobile \servers" and \clients."The system has to provide means for enabling clientsin need of some service to locate the whereabouts ofthe server they are looking for.In essence, the tracking mechanism has to supporttwo operations: a \move" operation, causing a user tomove to a new destination, and a \�nd" operation, en-abling one to contact the current address of a speci�eduser. However, the task of minimizing the communi-cation overheads of the \move" and \�nd" operationssimultaneously appears di�cult, as can be realized byexamining the following two extreme strategies (con-sidered in [MV88]). The full-information strategy re-quires every vertex in the network to maintain a com-plete directory containing up-to-date information onthe whereabouts of every user. This results in cheap\�nd" operations, but very expensive \move" opera-tions. In contrast, the no-information strategy per-forms no updates following a \move," thus abolishing

altogether the concept of directories and making the\move" operations cheap. However, establishing a con-nection via a \�nd" operation becomes very expensive,as it requires a global search over the entire network.Alternatively, it is possible to require that whenever auser moves, it leaves a \forwarding" pointer at the oldaddress, pointing to its new address. Unfortunately,this heuristic still does not guarantee any good worst-case bound for the \�nd" operations.Our purpose is to design some intermediate \partial-information" strategy, that will perform well for any�nd/move pattern. This problem was tackled alsoby [MV88]. However, their approach considers onlythe worst-case performance, and the schemes designedthere treat all requests alike, and ignore locality consid-erations. Our goal is to design more re�ned strategiesthat take into account the inherent costs of the particu-lar requests at hand, which in many cases may be lowerthan implied by the worst-case analysis. In particular,we would like moves to a near-by location, or searchesfor near-by users, to cost less. Thus we are interestedin the worst case overhead incurred by a particularstrategy. This overhead is evaluated by comparing thetotal cost invested in a sequence of \move" and \�nd"operations against the inherent cost (namely, the costincurred by the operations themselves, assuming fullinformation is available for free.) This comparison isdone over all sequences of \move" and \�nd" oper-ations. The strategy proposed guarantees overheadsthat are polylogarithmic in the size and the diameter ofthe network. Again, our strategy is based on a locality-preserving hierarchical representation of the network,which forms the structural skeleton for the data struc-tures maintained by the tracking mechanism. Theoverheads of the \move" and \�nd" operations growsas the product of the radius and the maximum degreeof the underlying hierarchy of neighborhood covers.2 De�nitionsWe consider an arbitrary weighted graph G(V;E;w),where V is the set of vertices, E is the set of edgesand w : E ! R+ is a weight function, assigning anon-negative weight w(e) to every edge e 2 E.For two vertices u;w in G, let distG(u;w) denotethe (weighted) length of a shortest path in G betweenthose vertices, where the length of a path (e1; : : : ; es)isP1�i�sw(ei). (We sometimes omit the subscript Gwhere no confusion arises.) This de�nition is general-ized to sets of vertices U;W in G in the natural way,by lettingdistG(U;W ) = minfdistG(u;w) j u 2 U;w 2Wg.The j-neighborhood of a vertex v 2 V is de�ned

as Nj(v) = fw j dist(w; v) � jg. Given a subsetof vertices R � V , denote Nm(R) = fNm(v) j v 2Rg. Let Diam(G) denote the (weighted) diameter ofthe network, i.e., maxu;v2V (distG(u; v)). For a ver-tex v 2 V , let Rad(v;G) = maxw2V (distG(v; w)).Let Rad(G) denote the radius of the network, i.e.,minv2V (Rad(v;G)). In order to simplify some of thefollowing de�nitions we avoid problems arising from 0-diameter or 0-radius graphs, by de�ning Rad(G) =Diam(G) = 1 for the single-vertex graph G =(fvg; ;). Observe that for every graph G, Rad(G) �Diam(G) � 2Rad(G).Given a set of vertices S � V , let G(S) denote thesubgraph induced by S in G. A cluster is a subset ofvertices S � V such that G(S) is connected. Through-out we denote clusters by capital P;Q;R etc., and col-lections of clusters by calligraphic type, P;Q;R etc.We use Rad(v; S) (respectively, Rad(S), Diam(S))as a shorthand for Rad(v;G(S)) (resp., Rad(G(S)),Diam(G(S))). A cover is a collection of clustersS = fS1; : : : ; Smg such that Si Si = V . A parti-tion of G is a cover S with the additional propertythat S \ S0 = ; for every S; S0 2 S. Given a collec-tion of clusters S, let Diam(S) = maxiDiam(Si) andRad(S) = maxiRad(Si).We use the following measures for the sparsity (or\interaction level") of covers and partitions. Firstconsider a cover S. For every vertex v 2 V , letdeg(v;S) denote the degree of v in the hypergraph(V;S), i.e., the number of occurrences of v in clustersS 2 S. The maximum degree of a cover S is de�nedas �(S) = maxv2V deg(v;S). The average degree of acover S is de�ned as ��(S) = (Pv2V deg(v;S))=n.For partitions we may be interested in several dif-ferent measures, based on the neighborhood relationsamong clusters or between clusters and individual ver-tices. Given a partition S and a cluster S 2 S, let usde�ne the vertex-neighborhood of S as �v(S) = N1(S),and the cluster-neighborhood of S as �c(S) = fS0 jS0 2 S; dist(S; S0) = 1g. The maximum and aver-age vertex-degree and cluster-degree of the partition Sare de�ned accordingly as �v(S) = maxS2S j�v(S)j,��v(S) = (PS2S j�v(S)j)=n, �c(S) = maxS2S j�c(S)jjSj ,and ��c(S) = (PS2S j�c(S)j)=jSj.Given two covers S = fS1; : : : ; Smg and T =fT1; : : : ; Tkg, we say that T coarsens S if for everySi 2 S there exists a Tj 2 T such that Si � Tj . Inthis case, we refer to the ratio Rad(T )=Rad(S) as theradius ratio of the coarsening.

3 Sparse coarsening coversThis section describes an algorithm for the construc-tion of a sparse coarsening cover, i.e., a cover with lowmaximum degree. The main result is:Theorem 3.1 Given a graph G = (V;E), jV j = n, acover S and an integer k � 1, it is possible to construct acoarsening cover T that satis�es the following properties:(1) Rad(T ) � (2k � 1)Rad(S), and(2) �(T ) � 2kjSj1=k.Let us remark that it is possible to replace the degreebound of Property (2) with O(k � n1=k). This requiresa more complex algorithm and analysis, and thereforewe prefer to state the theorem as above. In most ofour applications there is no real di�erence, as jSj = n.We also mention that this result is close to optimal insome cases, as implied from Thm. 5.4.The coarsening problem is handled by reducing it tothe sub-problem of constructing a partial cover. Theinput of this problem is a graph G = (V;E), jV j = n, acollection of (possibly overlapping) clusters R and aninteger k � 1. The output consists of a collection ofdisjoint clusters, DT , that subsume a subset DR � Rof the original clusters. The goal is to subsume \many"clusters of R while maintaining the radii of the outputclusters in DT relatively small. We now describe aprocedure Cover(R) achieving this goal.Procedure Cover(R) starts by setting U , the collec-tion of unprocessed clusters, to equal R. The proce-dure operates in iterations. Each iteration constructsone output cluster Y 2 DT , by merging together someclusters of U . The iteration begins by arbitrarily pick-ing a cluster S in U and designating it as the kernel ofa cluster to be constructed next. The cluster is thenrepeatedly merged with intersecting clusters from U .This is done in a layered fashion, adding one layer ata time. At each stage, the original cluster is viewed asthe internal kernel Y of the resulting cluster Z. Themerging process is carried repeatedly until reaching acertain sparsity condition (speci�cally, until the nextiteration increases the number of clusters merged intoZ by a factor of less than jRj1=k). The procedure thenadds the kernel Y of the resulting cluster Z to a collec-tion DT . It is important to note that the newly formedcluster consists of only the kernel Y , and not the en-tire cluster Z, which contains an additional \externallayer" of R clusters. The role of this external layeris to act as a \protective barrier" shielding the gener-ated cluster Y , and providing the desired disjointnessbetween the di�erent clusters Y added to DT .

Throughout the process, the procedure keeps alsothe \unmerged" collections Y;Z containing the origi-nal R clusters merged into Y and Z. At the end of theiterative process, when Y is completed, every clusterin the collection Y is added to DR, and every clusterin the collection Z is removed from U . Then a newiteration is started. These iterations proceed until U isexhausted. The procedure then outputs the sets DRand DT .Note that each of the original clusters in DR is cov-ered by some cluster Y 2 DT constructed during theexecution of the procedure. However, some original Rclusters are thrown out of consideration without beingsubsumed by any cluster in DT ; these are precisely theclusters merged into some external layer Z � Y.Procedure Cover is formally described in Figure 2.Its properties are summarized by the following lemma.Lemma 3.2 Given a graph G = (V;E), jV j = n, acollection of clusters R and an integer k, the collectionsDT and DR constructed by Procedure Cover(R) satisfythe following properties:(1) DT coarsens DR,(2) Y \ Y 0 = ; for every Y; Y 0 2 DT ,(3) jDRj � jRj1�1=k, and(4) Rad(DT ) � (2k � 1)Rad(R).Proof: First let us note that since the elements ofU at the beginning of the procedure are clusters (i.e.,their induced graphs are connected), the constructionprocess guarantees that every set Y added to DT isa cluster. Property (1) now holds directly from theconstruction.Let us now prove Property (2). Suppose, seeking toestablish a contradiction, that there is a vertex v suchthat v 2 Y \ Y 0. Without loss of generality supposethat Y was created in an earlier iteration than Y 0.Since v 2 Y 0, there must be a cluster S0 such thatv 2 S0 and S0 was still in U when the algorithm startedconstructing Y 0. But every such cluster S0 satis�esS0 \ Y 6= ;, and therefore the �nal construction stepcreating the collection Z from Y should have added S0into Z and eliminated it from U ; a contradiction.Property (3) is derived as follows. It is imme-diate from the termination condition of the inter-nal loop that the resulting pair Y;Z satis�es jZj �jRj1=kjYj. Therefore jRj =PZ jZj �PY jRj1=kjYj =jRj1=kjDRj, which proves Property (3).Finally we analyze the increase in the radius of clus-ters in the cover. Consider some iteration of the mainloop of Procedure Cover starting with the selectionof some cluster S 2 R. Let J denote the number of

R S; T ;repeat(DR;DT ) Cover(R)T T [DTR R n DRuntil R = ;Figure 1: Algorithm MAX COVER.times the internal loop was executed. Denote the ini-tial set Z by Z0. Denote the set Z (respectively, Y;Y)constructed on the i'th internal iteration (1 � i � J)by Zi (resp., Yi;Yi). Note that for 1 � i � J , Ziis constructed on the basis of Yi, Yi = Zi�1 andYi = SS2Yi S. We proceed along the following chainof claims. We �rst observe that jZij � jRji=k for every0 � i � J � 1, and strict inequality holds for i � 1.This implies J � k. Finally, we prove that for every1 � i � J , Rad(Yi) � (2i� 1)Rad(R). It follows fromthe last two claims that Rad(YJ ) � (2k � 1)Rad(R),which completes the proof of the last property of theLemma.We now present the algorithm MAX COVER, whosetask is to construct a cover as in Theorem 3.1. Theinput to the algorithm is a graph G = (V;E), jV j = n,a cover S and an integer k � 1. The output collectionof cover clusters, T , is initially empty. The algorithmmaintains the set of \remaining" clusters R. These arethe clusters not yet subsumed by the constructed cover.Initially R = S, and the algorithm terminates onceR = ;. The algorithm operates in phases. Each phaseconsists of the activation of the procedure Cover(R),which adds a subcollection of output clusters DT to Tand removes the set of subsumed original clusters DRfrom R.Algorithm MAX COVER is formally described in Fig.1. We are now ready to prove Theorem 3.1 itself. Weneed to prove that given a graph G = (V;E), jV j = n,a cover S and an integer k � 1, the cover T constructedby Algorithm MAX COVER coarsens S and satis�es thetwo properties of the Theorem.Let Ri denote the contents of the set R at the be-ginning of phase i, and let ri = jRij. Let DT i denotethe collection DT added to T at the end of phase i,and let DRi be the set DR removed fromR at the endof phase i.The fact that T coarsens S follows from the factthat T = SiDT i, S = SiDRi and by Property (1)of Lemma 3.2, DT i coarsens DRi for every i. Prop-erty (1) follows directly from Property (4) of Lemma

U R; DT ;; DR ;repeatSelect an arbitrary cluster S 2 U .Z fSgrepeatY ZY SS2Y SZ fS j S 2 U ; S \ Y 6= ;g.until jZj � jRj1=kjYjU U �ZDT DT [ fY gDR DR[Yuntil U = ;Output (DR;DT ).Figure 2: Procedure Cover(R).3.2. It remains to prove Property (2). This propertyrelies on the fact that by Property (2) of Lemma 3.2,each vertex v participates in at most one cluster ineach collection DT i. Therefore it remains to boundthe number of phases performed by the algorithm.This bound relies on the following observations. ByProperty (3) of Lemma 3.2, in every phase i, at leastjDRij � jRij1�1=k clusters of Ri are removed from theset Ri, i.e., ri+1 � ri � r1�1=ki .Claim 3.3 Consider the recurrence relationxi+1 = xi � x�i , for 0 < � < 1. Let f(n) denote theleast index i such that xi � 1 given x0 = n. Thenf(n) < ((1 � �) ln 2)�1n1��.Proof: It follows from the de�nition of f(n) thatf(n) � n=2(n=2)� + f(n=2):From this we getf(n) � n1�� lognXj=1 �2��1�j < n1�� Z 1x=0�2��1�xdx= ((1� �) ln 2)�1n1��:Consequently, since r0 = n, S is exhausted after nomore than kln 2 jSj1=k phases of Algorithm MAX COVER,and hence �(T ) � 2kjSj1=k. This completes the proofof Theorem 3.1.Algorithm MAX COVER as described here requiresO(n2) steps, and its straightforward distributed imple-mentation has communication cost O(n2). In [AP90]we describe a more e�cient distributed algorithm.

4 Sparse coarsening partitionsIn this section we discuss algorithms for the construc-tion of sparse coarsening partitions, according to themaximum vertex- and cluster-degree measures.Our �rst result concerns a maximum vertex-degreepartition algorithm MAX PARTv. This is the only algo-rithm in which our tradeo� deviates considerably fromthe known lower bound, in that the radius ratio is ex-ponential in k.Theorem 4.1 Given a graph G = (V;E), jV j = n, apartition S and an integer k � 1, it is possible to con-struct a coarsening partition T that satis�es the followingproperties:(1) Rad(T ) � 2 � 5k �Rad(S), and(2) �v(T ) = O(k � n1=k).The algorithm and the proof of the theorem will bepresented in the full paper (see also [Pel89]).Our next result concerns a maximum cluster-degreepartition algorithm MAX PARTc. The polynomial boundobtained for the radius ratio here is the result of theweaker sparsity criterion.Theorem 4.2 Given a graph G = (V;E), jV j = n, apartition S and an integer k � 1, it is possible to con-struct a coarsening partition T that satis�es the followingproperties:(1) Rad(T ) � 2 � klog 7Rad(S), and(2) �c(T ) = O(log k � n1=k).The algorithm and the proof of the theorem will bepresented in the full paper.5 Average degree clusteringIn this section we consider algorithms for construct-ing coarsening covers and partitions with low averagedegree. Generally speaking, we expect to get bettertradeo�s in this case. Let us �rst consider the case ofcovers.Theorem 5.1 Given a graph G = (V;E), jV j = n, acover S and an integer k � 1, it is possible to construct acoarsening cover T that satis�es the following properties:(1) Rad(T ) � (2k + 1)Rad(S), and(2) ��(T ) = O(n1=k).

The algorithm AV COVER can be thought of as basedon a single application of Procedure Cover (used in al-gorithm MAX COVER), taking the entire clusters Z pro-duced by the procedure (including the external layers)as output clusters. A formal description of the algo-rithm and a proof of the lemma are omitted from theabstract (see [Pel89, Pel90]).Next let us consider partitions. For the cluster-degree measure, a minor modi�cation of AlgorithmAV COVER yields Algorithm AV PARTc for this problem.This algorithm is in fact a natural extension of thealgorithm for constructing synchronizer in [Awe85].We thus haveTheorem 5.2 Given a graph G = (V;E), jV j = n, apartition S and an integer k � 1, it is possible to con-struct a coarsening partition T that satis�es the followingproperties:(1) Rad(T ) � (2k + 1)Rad(S), and(2) ��(T ) = O(n1=k).The situation is again harder with the vertex de-gree measure, since the radius ratio guaranteed by al-gorithm MAX PARTv is exponential. In the full paperwe describe a simple variant of algorithm AV COVER,named AV PARTv, that solves a weaker problem, inwhich the output clusters are allowed to be discon-nected. (It is necessary to de�ne cluster radius in thiscase based on distances in the entire graph G.) We re-fer to this problem as the problem of \weak partitions"with low average vertex-degree. We getTheorem 5.3 Given a graph G = (V;E), jV j = n,a partition S and an integer k � 1, it is possible toconstruct a weak coarsening partition T that satis�es thefollowing properties:(1) Rad(T ) � (2k + 1)Rad(S), and(2) ��(T ) = O(n1=k).Let us now turn our attention to the question oflower bounds for clustering algorithms. Relying on thelower bound of [PS89] for spanners (see Sec. 6.2), andon the relationships between spanners and covers, weshow the following.Theorem 5.4 For every k � 3, there exist unweightedn-vertex graphs G = (V;E) for which(a) for every cover T coarsening N1(V ), if Rad(T ) � kthen ��(T ) = (n1=k).(b) for every partition T coarsening N0(V ), if Rad(T ) �k then ��c(T ) = (n1=k).These bounds clearly imply similar bounds for theaverage vertex-degree partition problem, as well as forall maximum degree problems.

6 Related graph structures6.1 Regional MatchingsIn [MV88], Mullender and Vit�anyi proposed a gen-eral paradigm for distributed match-making betweenclients and servers in a distributed network. Intu-itively, a match-making system is a speci�cation ofrendezvous locations in the network, enabling users tolocate and communicate with one another.Since our goal is to reduce storage and communica-tion costs, it is desirable to keep topological considera-tions in mind, and devise a match-making mechanismtaking locality into account. In this subsection we in-troduce the concept of a regional matching, geared to-wards this goal.The basic components of our construction are a readset Read(v) � V and a write set Write(v) � V , de�nedfor every vertex v. Consider the collection RW of allpairs of sets, namelyRW = f Read(v); Write(v) j v 2 V g.De�nition 6.1 The collection RW is an m-regionalmatching (for some integer m � 1) if for all v; u 2 Vsuch that dist(u; v) � m, Write(v)TRead(u) 6= ;.The relevant parameters of a regional matching areits radius, which the maximal distance from a vertex toany other vertex in its read or write set, and its degree,which is the maximal number of vertices in any read orwrite set. Formally, for any m-regional matching RWde�ne the following four parameters:Degread(RW) = maxv2V jRead(v)j,Radread(RW) = 1m maxu;v2V fdist(u; v) j u 2 Read(v)g,and Degwrite(RW), Radwrite(RW) are de�ned anal-ogously based on the sets Write(v). Again, there ap-pears to be a trade-o� between these two parameters,making simultaneous minimization of both of them anontrivial task. Using algorithm MAX COVER we get thefollowing result, whose proof is deferred to the full pa-per (see also [AP89a]).Theorem 6.2 For all m; k � 1, it is possible to con-struct an m-regional matching RWm;k withDegread(RWm;k) � 2k � n1=kDegwrite(RWm;k) = 1Radread(RWm;k) � 2k + 1Radwrite(RWm;k) � 2k + 16.2 SpannersSpanners [PU89b, PS89, ADDJ90] appear to be theunderlying graph structure in various constructions indistributed systems and communication networks.

De�nition 6.3 Given a connected simple graph G =(V;E), a subgraph G0 = (V;E0) is a t-spanner of G iffor every u; v 2 V , distG0 (u; v) � t � distG(u; v). Werefer to t as the stretch factor of the spanner G0.Using the average cluster-degree partition algorithmAV PARTc (or in fact, its variant from [Awe85]), it isshown in [PS89] thatLemma 6.4 [PS89] For every unweighted n-vertexgraph G and for every �xed k � 1, there exists a(polynomial-time-constructible) (4k + 1)-spanner withO(n1+1=k) edges.Using algorithm AV COVER, it is possible to derivea similar result for weighted graphs, although withan additional logarithmic factor based on the edgeweights. Recently, a more e�cient algorithm for con-structing spanners for weighted graphs was proposedin [ADDJ90].6.3 Low diameter separatorsSeparators (cf. [LT79]) are traditionally based on car-dinality considerations. For arbitrary networks it isnot always possible to construct separators of this na-ture. However, for various distributed applications itmay be useful to have separators based on diameterparameters.De�nition 6.5 Given a graph G(V;E), a subset of thevertices V 00 � V is an (m; �; )-separator if the subgraphG0 induced by V 0 = V � V 00 in G has the following twoproperties:1. every two connected components in G0 are at dis-tance m or more of each other.2. every connected component in G0 has diameter ofO(m � �) in G, and3. The fraction of nodes in V 0 is at least O( 1 ).Intuitively, one should view the set V 00 as the smallcardinality separator and set V 0 as the \nicely-packed"interior of the network. The typical goal is to remainwith most of the nodes being in the interior, and atthe same time to keep �; small for all �xed m.Using a single application of the inner loop of Pro-cedure Cover in Figure 2, and taking the vertices in allthe output clusters in DT as V 0 (and the rest of thevertices as V 00), we getLemma 6.6 For every graph G, for all m > 0 and k �1, it is possible to construct an (m; k; n1=k) separator.

6.4 Tree CoversAnother useful structure involves constructing a sparsetree collection in a graph.De�nition 6.7 Given an undirected graph G(V;E), an(r;m)-tree cover is a collection F of trees in G, thatsatis�es the following properties:1. For every two nodes u; v 2 V , there exists a treeF 2 F such that distF (u; v) � r � distG(u; v).2. Every node belongs to at mostm di�erent trees.Thm. 3.1 is used in [AKP90] to proveLemma 6.8 For every undirected graph G(V;E) andinteger k � 1, it is possible to construct an (r;m)-tree cover Fk for G, with r = 8k and m = k � n1=k �logDiam(G).7 Applications7.1 RoutingA routing scheme RS for the (weighted) network G isa mechanism for delivering messages in the network.It can be invoked at any origin vertex u and be re-quired to deliver a message to some destination vertexv (speci�ed by a �xed name) via a sequence of messagetransmissions.We now give precise de�nitions for our complexitymeasures for stretch and memory. The communicationcost of transmitting an O(logn) bit message over edgee is the weight w(e) of that edge. Let Cost(RS; u; v)denote the communication cost of the routing schemewhen invoked at an origin u, w.r.t. a destination v andan O(logn) bit message, i.e., the total communicationcost of all message transmissions associated with thedelivery of the message. Given a routing scheme RSfor an n-processor network G = (V;E), we de�ne thestretch factor of the scheme RS to beStretch(RS) = maxu;v2V �Cost(RS; u; v)dist(u; v) �:The memory requirement of a protocol is the max-imum amount of memory bits used by the protocolin any single processor in the network. We denotethe memory requirement of a routing scheme RS byMemory(RS).Our solution is based on constructing a hierarchyof covers in the network, and using this hierarchy forrouting. In each level, the graph is covered by clusters,each managed by a center vertex. Each cluster has its

own internal routing mechanism enabling routing toand from the center. Messages are always transferredto their destinations using the internal routing mecha-nism of some cluster, along a route going through thecluster center. It is clear that this approach reduces thememory requirements of the routing schemes, since onehas to de�ne routing paths only for cluster centers, butit increases the communication cost, since messagesneed not be moving along shortest paths. Through anappropriate choice of the cluster cover we guaranteethat both overheads are low.The routing component used inside clusters is basedon a variant of the interval routing scheme, or ITR[SK85, PU89a, ABLP89], that uses a shortest path treerooted at a vertex r and spanning the cluster.Each level in our hierarchy constitutes a regional(C;m)-routing scheme, which is a scheme with the fol-lowing properties. For every two processors u; v, ifdist(u; v) � m then the scheme succeeds in deliveringmessages from u to v. Otherwise, the routing mightend in failure, in which case the message is returned tou. In either case, the communication cost of the entireprocess is at most C.We construct a regional (O(k2m);m)-routingscheme, for any integers k;m � 1. The main stageof the construction involves an application of Theorem3.1. We start by setting S = Nm(V ) and construct-ing a coarsening cover T as in the theorem. Next, weprovide internal routing services in each cluster T byselecting a center `(T ) and constructing a tree routingcomponent for T rooted at this center. We associatewith every vertex v 2 V a home cluster, home(v) 2 T ,which is the cluster containing Nm(v). (In case thereare several appropriate clusters, select one arbitrarily.)A processor v routes a message by sending it to itshome cluster leader, `(home(v)). The leader uses theITR mechanism to forward the message to its desti-nation. If that destination is not found in the cluster,the message is returned to the root and from there tothe originator.Finally we present our family of hierarchical rout-ing schemes. For every �xed integer k � 1, con-struct the hierarchical scheme Hk as follows. Let� = dlogDiam(G)e. For 1 � i � � construct a re-gional (O(k22i); 2i)-routing scheme Ri. Each proces-sor v participates in all � regional routing schemes Ri.In particular, v has a home cluster homei(v) in eachRi, and it stores all the information it is required tostore for each of these schemes.The routing procedure operates as follows. Supposea vertex u wishes to send a message to a vertex v. Thenu �rst tries using the lowest-level regional scheme R1,i.e., it forwards the message to its �rst home clusterleader, `(home1(v)). If this trial fails, u retries sending

its message, this time using regional scheme R2, andso on, until it �nally succeeds.In the full paper (see also [AP89b]) we analyze thescheme and prove (relying on Thm. 3.1):Theorem 7.1 For every graph G and every �xedinteger k � 1 it is possible to construct (inpolynomial time) a hierarchical routing scheme Hkwith Stretch(Hk) = O(k2) using Memory(Hk) =O(n1=k log2 n logDiam(G)) bits per vertex.7.2 Online tracking of mobile usersDenote by Addr(�) the current address of a speci�cuser �. A directory D with respect to the user � is adistributed data structure which enables the followingtwo operations.Find(D; �; v) : invoked at the vertex v, this operationdelivers a search message from v to the locations = Addr(�) of the user �.Move(D; �; s; t) : invoked at the current location s =Addr(�) of the user �, this operation moves � to anew location t and performs the necessary updatesin the directory.We are interested in measuring the communicationcomplexity overheads incurred by our Find and Movealgorithms, compared to the minimal \inherent" costsassociated with these operations. Let Cost(F ) (re-spectively, Cost(M )) denote the actual communica-tion cost of the operation F (resp., M ). For a Findinstruction F = Find(D; �; v), de�ne the optimal costof F as Opt cost(F ) = dist(v;Addr(�)). For a Moveinstruction M = Move(D; �; s; t), let Reloc(�; s; t) de-note the actual relocation cost of the user � from s tot. We de�ne the optimal cost of M as Opt cost(M ) =Reloc(�; s; t), which is the inherent cost assuming noextra operations, such as directory updates, are taken.This cost depends on the distance between the old andnew location, and we assume it satis�es Reloc(�; s; t) �dist(s; t). (In fact, the relocation of a server is typi-cally much more expensive than just sending a singlemessage between the two locations.)We would like to de�ne the \amortized overhead"of our operations, compared to their optimal cost.For that purpose we consider mixed sequences ofMove and Find operations. Given such a sequence�� = �1; : : : ; �`, let F(��) denote the subsequenceobtained by picking only the Find operations from��. De�ne the optimal cost and the cost of thesubsequence F(��) = (F1; : : : ; Fq) in the naturalway, setting Opt cost(F(��)) =Pqi=1Opt cost(Fi) andCost(F(��)) =Pqi=1 Cost(Fi).

The �nd-stretch of the directory with respect to agiven sequence of operations �� is de�ned asStretchfind(��) = Cost(F(��))Opt cost(F(��)) :The �nd-stretch of the directory, denoted Stretchfind,is the least upper bound on Stretchfind(��), taken overall �nite sequences ��.De�ne the subsequence M(��),the costs Opt cost(M(��)) and Cost(M(��)) and themove-stretch factors Stretchmove(��) and Stretchmoveanalogously.Our tracking mechanism is based on a hierarchy of2i-regional matchings plus several additional controlmechanisms. In the full paper (see also [AP89a]) weprovide a detailed description of the solution and prove(using Thm. 6.2):Theorem 7.2 For every graph G and every �xed integerk � 1 it is possible to construct (in polynomial time) adirectory D that satis�es Stretchfind = O(log2 n) andStretchmove = O(log2 n) and uses a total of O(N �log2 n+ n � log3 n) memory bits for handling N users.AcknowledgmentsWe are grateful to Yehuda Afek, Steve Ponzio, MotiRicklin and an anonymous referee for pointing outsome errors in previous versions of the paper. Wealso thank Michael Fischer for stimulating discussions,and Oded Goldreich and Richard Karp for their helpfulcomments.References[ABLP89] Baruch Awerbuch, Amotz Bar-Noy, Nati Linial,and David Peleg. Compact distributed datastructures for adaptive network routing. InProc. 21st ACM Symp. on Theory of Comput-ing, pages 230{240, ACM, May 1989.[ADDJ90] I. Alth�ofer, G. Das, D. Dobkin, and D.Joseph. Generating sparse spanners forweighted graphs. In Proc. 2nd ScandianvianWorkshop on Algorithm Theory, July 1990.[AGLP89] Baruch Awerbuch, Andrew Goldberg, MichaelLuby, and Serge Plotkin. Network decompo-sition and locality in distributed computation.In Proc. 30th IEEE Symp. on Foundations ofComputer Science, IEEE, May 1989.[AKP90] Baruch Awerbuch, Shay Kutten, and David Pe-leg. On bu�er-economical store-and-forwarddeadlock prevention. March 1990. Unpublishedmanuscript.

[AP] Baruch Awerbuch and David Peleg. Networksynchronization with polylogarithmic overhead.These proceedings.[AP89a] Baruch Awerbuch and David Peleg. OnlineTracking of mobile users. Technical Memo TM-410, MIT, Lab. for Computer Science, August1989.[AP89b] Baruch Awerbuch and David Peleg. Routingwith Polynomial Communication - Space Trade-O�. Technical Memo TM-411, MIT, Lab. forComputer Science, September 1989.[AP90] Baruch Awerbuch and David Peleg. E�-cient Distributed Construction of Sparse Cov-ers. Technical Report CS90-17, The WeizmannInstitute, July 1990.[AR90] Y. Afek and M. Ricklin. Sparser: a paradigmfor running distributed algorithms. April 1990.Unpublished manuscript.[Awe85] Baruch Awerbuch. Complexity of network syn-chronization. J. of the ACM, 32(4):804{823, Oc-tober 1985.[BJ86] Alan E. Baratz and Je�rey M. Ja�e. Establish-ing virtual circuits in large computer networks.Computer Networks, :27{37, December 1986.[FJ88] Greg N. Frederickson and Ravi Janardan. De-signing networks with compact routing tables.Algorithmica, 3:171{190, August 1988.[KK77] L. Kleinrock and F. Kamoun. Hierarchical rout-ing for large networks; performance evaluationand optimization. Computer Networks, 1:155{174, 1977.[LEH85] K.A. Lantz, J.L. Edigho�er, and B.L. Histon.Towards a universal directory service. In Pro-ceedings of 4th PODC, pages 261{271, Calgary,Alberta, Canada, August 1985.[LS90] N. Linial and M. Saks. Finding low-diametergraph decompositions distributively. April1990. Unpublished manuscript.[LT79] Richard J. Lipton and Robert E. Tarjan. Aseparator theorem for planar graphs. SIAM J.on Applied Math., 36(2):177{189, April 1979.[MV88] S.J. Mullender and P.M.B. Vit�anyi. Distributedmatch-making. Algorithmica, 3:367{391, 1988.[Pel89] D. Peleg. Sparse Graph Partitions. Techni-cal Report CS89-01, The Weizmann Institute,February 1989.[Pel90] D. Peleg. Distance-dependent distributed direc-tories. Info. and Computation, 1990. To appear.Also in Tech. Report CS89-10, The WeizmannInstitute, May 89.[Per82] R. Perlman. Hierarchical networks and the sub-network partition problem. In 5th Conferenceon System Sciences, 1982.

[PS89] David Peleg and Alejandro A. Sch�a�er. Graphspanners. J. of Graph Theory, 13:99{116, 1989.[PU89a] D. Peleg and E. Upfal. A tradeo� between sizeand e�ciency for routing tables. J. of the ACM,36:510{530, 1989.[PU89b] David Peleg and Je�rey D. Ullman. An optimalsynchronizer for the hypercube. SIAM J. onComput., 18(2):740{747, 1989.[SK85] N. Santoro and R. Khatib. Labelling and im-plicit routing in networks. The Computer Jour-nal, 28:5{8, 1985.[vLT86] J. van Leeuwen and R.B. Tan. Routing withcompact routing tables. In G. Rozenberg andA. Salomaa, editors, The Book of L, pages 259{273., Springer-Verlag, New York, New York,1986.