A Dynamic Separator Algorithm

Transcription

1 A Dyamic Separator Algorithm Degait Armo Joh Reif Departmet of Computer Sciece, Duke Uiversity Durham, NC Abstract Our work is based o the pioeerig work i sphere separators doe by Miller, Teg, Vavasis et al, [8, 12], who gave efficiet static (fixed iput) algorithms for fidig sphere separators of size s() = O( d 1 d ) for a set of poits i R d. We preset dyamic algorithms which maitai separators for a dyamically chagig graph. Our algorithms aswer queries ad process isertios ad deletios to the iput set, If the total iput size ad umber of queries is, our algorithm is polylog, that is, it takes (log) O(1) expected sequetial time per request to process worst case queries ad worst case chages to the iput set. This is the first kow polylog radomized dyamic algorithm for separators of a large class of graphs kow as overlap graphs [12], which iclude plaar graphs ad k-eighborhood graphs. We maitai a separator i expected time O(log ) ad we maitai a separator tree i expected time O(log 3 ). Moreover, our algorithm uses oly liear space. Supported by Natioal Sciece Foudatio Grat Number NSF-IRI ad Army Research Office cotract DAAH A prelimiary versio of this paper appeared as A Dyamic Separator Algorithm, i the proceedigs of the 3rd Aual WADS, Motreal, Quebec, August 1993, pp

2 We also give a geeral techique for trasformig a class of expected time radomized icremetal algorithms that use radom samplig to icremetal algorithms with high likelihood time bouds. I particular, we show how we ca maitai separators i time O(log 3 ) with high likelihood. Our results ca be applied to geerate dyamic algorithms for a wide variety of combiatorial ad umerical problems, whose uderlyig associated dyamic graph is a k- eighborhood graph, such as solvig liear systems ad mooid path problems. 1 Itroductio The otio of a separator i a graph was itroduced i the cotext of desigig efficiet divide-ad-coquer algorithms for graph problems. A graph separator is a set of graph vertices or edges whose removal from the graph partitios it ito two or more separate (i.e. ucoected) subgraphs. A good separator, for the purposes of divide-ad-coquer, is both small i size ad achieves a partitio of the graph ito subgraphs of roughly equal size. Clearly, ot all graphs have good separators. For example, cliques do ot have a separator set at all. There are, however, some importat classes of graphs that have good separators that ca be efficietly computed [6, 5, 3]. These iclude the classes of plaar ad almostplaar graphs. Miller, Teg, et al [7, 12] itroduced sphere separators, which are useful i fidig good separators for a much wider class of graphs called overlap graphs. Sphere separators are geometric etities, ad overlap graphs are geometrically defied, derived from sets of poits, ad special eighborhoods of these poits, i space. This makes them useful whe solvig problems i computatioal geometry, such as earest eighbor queries ([4, 12]), i umerical aalysis, such as ested dissectio problems with large scale 2

3 meshes i two ad three dimesios [7], ad i path algebra problems [10, 11]. The basis for all these algorithms is a separator-based search structure [12] a recursive structure which partitios the iput graph or set of poits usig sphere separators. This structure is a biary tree; iformatio about the separator is stored at the root, ad the two partitioed subsets are recursively stored i the subtrees. The separators themselves are foud usig a radomized algorithm that uses samplig. I this paper we describe a method for maitaiig such a separator structure for dyamically chagig iput. 1.1 Dyamizig Static Radomized Algorithms Dyamic (or icremetal) algorithms update their solutio to a problem whe the iput is dyamically modified. Usually it is ot efficiet to recompute the solutio from scratch, so the iput is stored i specialized data structures that ca be updated at small cost. Dyamic algorithms are very useful i iteractive applicatios, icludig etwork optimizatio, VLSI, ad computer graphics. May dyamic data structures have bee devised to deal with problems i computatioal geometry [9, 1]. I this sectio, we describe a useful techique for trasformig radomized algorithms that use samplig, so that they ca cope with dyamically chagig iputs. This techique may be applied to a wide rage of radomized algorithms. Throughout the rest of this paper we will refer to algorithms with fixed iput as static algorithms. Radomized algorithms that use samplig calculate a solutio by usig iformatio from a small subset of the iput. Give a iput set of size, a sample Σ of size σ is used to costruct a data structure for the iput set. May efficiet algorithms use such radom 3

4 samplig. Cosider a algorithm A that uses a sample Σ to costruct a data structure which will store the iput set. Let the time take by A be T(). Now cosider a additioal poit p which is preseted to the algorithm to be iserted ito the data structure. If a ew data structure is costructed for the + 1 poits, its shape would deped oly o the sample Σ. The probability that p is i Σ, ad therefore used to costruct the ew data structure is oly σ σ. Thus with probability whether p is i the iput set. the same data structure is produced regardless of By performig a sigle Beroulli trial, we ca decide whether or ot the output is affected by the isertio of p. If the aswer is yes, we recompute the data structure for the ew σ data set by callig A. The probability of recalculatig is. If the aswer is o, the ew +1 poit is added to a locatio i the data structure without otherwise chagig it. Sice the cost of ivokig A is at most T( + 1), the cost of processig a ew iput poit p is at most σ T( + 1). +1 The dyamic maiteace of the data structure proceeds iductively. At each step, the followig iductio hypothesis holds: After a sequece of ay umber of updates to its iput, the dyamic data structure output by the algorithm will have the same probability distributio as a data structure output by the static algorithm, had the updated iput bee preseted to it. With each ew isertio, with probability at most σ the etire data structure may be completely rebuilt by the static algorithm, usig ubiased idepedet radom samplig. After each step, the iductio still holds. Sectio 3 gives more details of this approach. Deletio of poits from the data set are hadled similarly, but here care must be take, depedig o the separator structure. If the data poits are stored oly i the leaves of 4

5 the structure, deletio ca be hadled i a idetical fashio to isertio. By performig a sigle Beroulli trial, we ca decide whether or ot the data structure is affected by the deletio of p. If the aswer is yes, we recompute the data structure for the ew data set by callig A. The probability of recalculatig is σ. If the aswer is o, the ew poit is deleted from the data structure without otherwise chagig it. Sice the cost of ivokig A is at most T( 1), the cost of deletig a poit p is at most σ T( 1). This method of deletig a poit is clearly more time cosumig tha simply removig it from the leaf cotaiig it, but the idea is to make sure that the iductio hypothesis stated above holds, i.e., that the data structure after deletio will come from the same probability distributio as a data structure output by the static algorithms give the data set without poit p. If poits are stored at itermediate odes i the data structure, deletio is slightly more ivolved (see details i sectio 3.3). However, the time bouds remai the same. I reality, static algorithms are costly. The static algorithms for fidig sphere separators [12] use recursive radomized samplig. Whe costructig a separator structure [4, 12], there is a cost ivolved i buildig the tree eve if the ew iput has o effect o the separator at the root. Noetheless, this geeral idea is the basis for desigig the dyamic algorithms i this paper, ad aalysis i all cases is similar. 1.2 Descriptio of Our Model Usig a radomized algorithm, we maitai a separator based search structure for a dyamically chagig set of poits P i R d. Our model assumes a adversary, who kows our radomized, dyamic algorithm but ot the radom choices which it makes. The adversary 5

6 presets a sequece of poits i advace which are the preseted to the algorithm, oe at a time. Note that this is ot a fully iteractive model, as the adversary does ot geerate ew poits oce the algorithm is ruig, ad caot take advatage of kowledge of choices the algorithm has already made. This feature of the model is importat oly while makig deletios to the poit set. Associated with each poit p is oe of the followig requests: 1. INSERT p ito the search structure. 2. DELETE p from the search structure. 3. Aswer a QUERY about p. Queries preseted are to determie if the query poit is iside or outside the separator, or to locate the poit i the separator tree. A query poit may or may ot be i P, but it ca be temporarily iserted, the deleted, if the applicatio allows queries to be aswered oly for poits from P (as i [4, 13]). 1.3 The Replicat Paradigm: Termiology Whe dealig with radomized algorithms we ca oly speak of expected bouds which ca be attaied with some probability. Oe method of attaiig the expected bouds with high probability is to repeat a process a umber of times. I Sectio 4 we preset a geeral techique for trasformig expected time bouds to high likelihood time bouds through the use of multiple, idepedet processes. This sectio itroduces the termiology relevat to this techique. The algorithm will maitai may idepedet processes, all of which carry out the same task. Each idepedet process ad its dyamically maitaied data structure is called a 6

7 replicat 1. Sice the processes use radom samplig, the replicats may create differet data structures from the same iput. Noetheless, all the structures will be from the same probability distributio. At ay give time, a replicat may be i oe of two states: 1. The replicat is activated. I this state, the iformatio i the replicat data structure is curret ad ca be used to process queries. 2. The replicat is i retiremet. I this case, the structure maitaied by the replicat is beig rebuilt, ad the iformatio it stores may ot be curret. A replicat i retiremet may ot be used to aswer queries. Retiremet for replicats i our algorithm is a temporary state. Each replicat repeatedly alterates betwee periods of activatio ad retiremet. A period of activatio begis at a icept date ad eds at a retiremet date. A activatio period s legth is the replicat s logevity. After a retiremet period, a replicat has o memory of previous activatio periods [ all those momets will be lost i time, like tears i the rai ], but does have a memory implat kowledge of the curret versio of the data structure, as it has bee built durig the most recet retiremet. 1.4 Orgaizatio of Our Paper Sectio 2 gives prelimiary defiitios ad related results. I sectio 3 we describe the process of covertig a radomized algorithm based o samplig to a dyamic radomized algorithm, ad give the details of the process of isertig ad deletig a poit from a separator structure. 1 I the descriptio that follows we used termiology (i italics) ad quotes (i square brackets) borrowed from the movie Blade Ruer. 7

8 Fially, i sectio 4 we discuss the use of replicats to trasform expected time bouds to high likelihood time bouds. 2 Defiitios ad Related Results 2.1 Neighborhood Systems Let P = {p 1... p } be a fiite set of geerally positioed poits i R d. A d-dimesioal eighborhood system i R d is a set of balls B = {B 1... B }, with ball B i cetered at p i. B is a k-eighborhood system if each B i cotais at most k poits from P. B is a k-ply eighborhood system if each p i is cotaied i at most k balls. Give ay set of poits P i R d, we ca easily costruct a k-eighborhood system by ceterig at each poit the largest ball that will cotai k + 1 poits from P. A k-ply eighborhood system is more difficult, but the followig lemma from [2] relates the two: Lemma 2.1 Each k-eighborhood system i R d is τ d k-ply, where τ d is the kissig umber i d dimesios, i.e. the maximum umber of o-overlappig uit balls i R d that ca be arraged so that they all touch a cetral uit ball. Note that τ d is idepedet of ad depeds oly o the dimesio d. While its exact value is ot kow for all d, the kow bouds are d(1+o(1)) τ d 2.401d(1+o(1)) [12]. The k-earest eighborhood digraph of the poits P = {p 1,..., p } i R d is a graph G k = (P, E), with vertex set P ad directed edge set E = {(p i, p j ) p j is oe of the k earest eighbors of p i } (i.e., there are directed edges from each poit to its k earest eighbors). We will call the 1-earest eighborhood graph the earest eighborhood graph. 8

9 Note that sice we require the poits to be i geeral positio, the k earest eighbors of a poit are uique. The outdegree of every vertex i the graph is k, ad by Lemma 2.1, the idegree is bouded by kτ d. 2.2 Sphere Separators of Poits i R d A sphere separator of a set of poits P i R d, is a sphere S that partitios P ito two sets: P I, the poits i the iterior of S; ad P E, the poits i its exterior. The iduced separator set of a eighborhood system B of P is the set of poits whose associated balls itersect the sphere separator. Let s() be a positive, mootoe fuctio of, such that s() <. Give a fiite set of poits P = {p 1,..., p } i R d, ad a costat 0 < δ 1, a (d 1)-sphere S i R d is a (s, δ)-separator of P if it partitios P ito two subsets, P I ad P E (the poits o the iterior ad the exterior of S respectively) such that: 1. P I δ, P E δ, ad 2. the iduced separator of the poit set is of size at most s(). δ is called the splittig ratio of P. A (s, δ)-separator tree of P is a biary tree. At the root is stored iformatio about a (s, δ)-separator of P. Poits i the iterior of the sphere are stored i a recursive structure i the left subtree, ad poits o its exterior are stored i a recursive structure i the right subtree. Recursio stops whe a subtree cotais less tha a pre-specified umber of poits. At each iteral ode of the tree, the sphere separator S is required to be a (s, δ)-separator of the subset of poits stored i the subtree. That is, if the set of poits separated by the 9

10 paret of the ode is, the S is required to be a (s( ), δ)-separatig sphere. I this paper, wherever s, δ are determied by cotext, we will simply call the (s, δ)-separatig sphere a good separatig sphere Space Complexity The separator tree cotais iformatio about the separators i its iteral odes, ad the poits of P i the leaves. If oly the ceter ad radius of the sphere is stored at each iteral ode, the space complexity for the etire tree is O(). This ca be easily see from the recurrece f() = f( I )+f( E ) where I ad E are the umber of poits i the iterior ad exterior of S respectively, ad I + E =. If iformatio about the iduced separator set is also stored i the iteral odes, this recurrece becomes f() = f( I )+f( E )+ s(). Thus if s() O( β ), where 0 β 1, the space is f() = O() [4]. Let G = (P, E) be a graph iduced by P, such as a earest eighbor graph. We say that S is a (s, δ)-separator of G, if it partitios the vertices of G ito two subsets, P I ad P E as above, ad the umber of edges that S itersects is o more tha s(). P I ad P E iduce two separate subgraphs, G I ad G E. The separator set of G is the subset of the vertices icidet o edges which itersect the separator. The size of the separator set is o more tha 2s(). A (s, δ)-separator tree of G is a biary tree. At the root is stored a separator set correspodig to a (s, δ)-separator of G. G I ad G E are stored recursively i the two subtrees. Note that each vertex i the separator set is also stored i oe of the subtrees. However, if G has a separator set of size O( d 1 d ), the the total storage required is O() [4]. 10

11 2.3 Graph Separators Let G = (V, E) be a graph or digraph. Give 0 < δ < 1, a (s, δ)-separator of G is a set of vertices S V such that deletig the vertices of S ad their icidet edges discoects G ito two subgraphs, G 0 ad G 1, where we require that 1. each separated subgraph G 0, G 1 cotais o more tha δ vertices 2. S is of size at most s. A (s, δ)-separator tree of a graph or digraph is a biary tree. At the root is stored iformatio about the separator. The two separated subgraphs are stored i recursive structures i the two subtrees. Recursio stops whe a subtree cotais less tha a pre-specified umber of vertices. As before, the space required to store this tree is liear if S O( β ), where 0 β 1. A (α, k)-overlap graph is a graph iduced by a eighborhood system B of a set of poits P. The vertex set of the graph is P, ad a edge exists betwee two vertices p i ad p j if αb(p i ) B(p j ) ad αb(p j ) B(p i ), where, if B be a ball cetered at p of radius r the αb is a ball cetered at p with radius αr. Note that k-eighborhood graphs are a special case of overlap graphs. 2.4 Algorithms for Fidig Sphere Separators Our work is based o the pioeerig work i sphere separators doe by Miller, Teg, et al [4, 8, 7, 12]. They showed that for ay (geerally positioed) set of poits P = {p 1,..., p } i R d, there is a sphere S which (s, δ )-separates P, with separator size s = O( d 1 d ) ad a splittig ratio δ = d+1 d+2 [8]. 11

12 Furthermore, Teg [12] showed a radomized, liear time algorithm based o samplig for fidig such a separator. His result states that: Lemma 2.2 [12] Let P = {p 1,..., p } be ay set of geerally positioed poits i R d, ad let ɛ be a costat 0 < ɛ < 1. Let Σ be a radom sample of poits i P of size d+2 σ() = O( d ɛ 2 (log ɛ + log η)). The there is a radomized, liear time algorithm SPHERE- SEPARATOR(Σ), with success probability of 1 1, which yields a (s, δ)-separator of P η with separator size s β, β = d 1 d + 2ɛ, ad splittig ratio δ = d+1 d+2 + ɛ. I particular, if we choose η = O(log ), the with a sample of size σ() = O(log ) the algorithm will have a probability of success 1 1 log. Note that the goodess of the sphere separator obtaied by SPHERE-SEPARATOR(Σ) is oly slightly o-optimal as compared with the existece results cited above. To avoid time bouds which are expoetial i d, the algorithm employs a method of recursive samplig. Sample sizes are carefully selected to be as stated i Lemma 2.2, ad smaller samples are used to verify the goodess of the iitial sample. For our purposes, it suffices to kow that a radom sample of the iput poits of size σ() provides us a good sphere separator with probability 1 1. I what follows, we will take σ() to be O(log ). σ() 3 Dyamic Maiteace of Sphere Separators For a dyamically chagig fiite set of poits P, we give algorithms for dyamic maiteace of a sphere separator of P, ad for dyamic maiteace of a separator-based search structure. The algorithms accept a sequece of requests from a adversary. Each request is a pair <poit, actio>, where a actio may be to INSERT or DELETE the iput poit 12

13 from P, or aswer a QUERY about the iput poit, e.g. determie whether it is iside or outside the sphere separator of P, or search for it i the separator structure. We show the followig result: Theorem 3.1 Let 0 < ɛ < 1, δ = d+1 d 1 +ɛ, β = +2ɛ, ad s d+2 d+2 d β. Dyamic maiteace of a (s, δ)-sphere separator of poits i R d with INSERT ad DELETE operatios, as well as queries about the separator, ca be doe i O(log ) icremetal expected time per request. Dyamic maiteace of a sphere-separator-based search tree with INSERT, DELETE ad QUERY requests ca be doe i O(log 3 ) icremetal expected time per request. The followig subsectios detail the proof of the theorem. Sectio 3.1 discusses the case where a separator is maitaied for the poit set, ad describes the algorithm for isertig ad deletig poits from the data set. Sectio 3.2 describes dyamically maitaiig seoarator trees ad the algorithms for isertig ad deletig poits from the data structure. Throughout, we use the paradigm of replicats, as defied i Sectio 1.3. I this sectio, we focus o the case where there is oly oe replicat, or process. We use the static algorithm for fidig a sphere separator as a subroutie i our dyamic algorithm. 3.1 Maitaiig a Separator Recall that the separator of a set of poits is determied by examiig a subset Σ of the poits of size σ() = O(log ). Our algorithm keeps track of the poits selected to be i the sample, Σ. The algorithm proceeds iductively. Give a poit set ad a separator for it, a chage to the iput set (INSERT ro DELETE) may cause the algorithm to calculate a ew separator. If this happes, we say that the replicat is beig retired for rebuildig. alterately, the 13

14 separator may remai the same, despite a additio or deletio of a poit. The key poit is that After a sequece of poit isertios ad m poit deletios, the separator calaculated by the dyamic algorithm comes from the same probability distributio of separators for the m poit i the poit set, had they bee preseted to the static algorithm. Specifically, if after a sequece of i updates the set of poits i the separator structure is P i, the separator output by the dyamic algorithm should come from the same probability distributio as the separator output by a static algorithm, give P i as iput. Note that oce we have a sphere separator for the poit set, we ca determie whether a query poit is iside or outside the separator i O(1) time Isertio We ow aalyze the time eeded to isert a sigle poit ito the poit set, subject to the coditio above. Whe a request for isertio arrives, the iput to that stage of the algorithm is a set of 1 poits P, a separator for P partitioig it ito P E ad P I (poits o the exterior ad iterior, respectively, ad oe additioal poit p. Cosider the situatio where all poits are preseted to the static algorithm. The oly step of the static algorithm which is importat for our purpose is selectig the set Σ which is used to determie the separatig sphere. If Σ = σ(), the probability that the ew poit had bee icluded i Σ is σ(). Thus we perform a sigle Beroulli trial, with probability of success 1 σ(). Success i the Beroulli trial meas that there will be o chage to the separator. The oly thig the algorithm does i this case is determie whether p is i P I or P E. That process 14

15 is straightforward. Look at the separatig sphere, ad determie whether p lies iside or outside it. Failure i this trial meas that p eeds to be icluded i the subset of poits that will determie the separatig sphere. I that case, we retire the replicat ad ivoke the static radomized liear time algorithm of Lemma 2.2 o the etire set of poits. That is, we perform SPHERE-SEPARATOR(Σ) o the set P {p}. Usig a sample of size σ() = O(log ) to calculate the separatig sphere, we get Lemma 3.1 Give a set P of 1 poits i R d ad a δ-splittig sphere separator S, the expected icremetal time to isert a ew poit p ito P is O(log ). Proof: The probability of eedig to recompute a sphere separator for P {p} is the same as the probability of icludig p i the sample used i selectig a separator, which is σ(). With that probability, we ivoke the static, liear time algorithm for computig a sphere separator for P {p}. Otherwise, we determie (i costat time) which side of S the poit lies i, ad add it to that set (agai i costat time). The expected update time is thus E[T()] σ() ( O() + 1 σ() ) O(1) σ() O() + O(1) = O(σ()) = O(log ) Deletio Usig very similar reasoig, the dyamic separator algorithm also supports poit deletio. Each poit i the structure which was used i the sample whe fidig the separator is tagged. Whe deletig a tagged poit, the separator eeds to be rebuilt. If we maitai 15

16 the etire search structure, a poit is tagged with the highest level umber i which it was used to fid a separator its highest ivolvemet level. Poits ot selected are ot tagged. Whe a poit is preseted for deletio, it is located i the separator structure dow to its ivolvemet level, the the subtree from that level dow is rebuilt. The proofs of the ext two lemmas are similar to the proofs of lemmas 3.1 ad 3.3. Lemma 3.2 Give a set P of poits i R d ad a δ-splittig sphere separator S, the expected time to delete a poit p from P is O(log ). 3.2 Maitaiig a Sphere Separator Tree If the etire separator structure is maitaied, the p is added recursively to the left subtree or right subtree, depedig o its locatio with respect to the separatig sphere. If the etire separator tree is maitaied, the algorithm keeps track of all samples used to fid separators at all levels of the tree. Thus a sigle poit may be tagged up to O(log ) times. The algorithm proceeds iductively. Give a separator search structure, the etire structure or a part of it may be completely rebuilt usig the static algorithm with each ew isertio or deletio. If this is the case, we say that the replicat structure is beig retired for rebuildig. After every step, the followig iductio hypothesis holds: Similarly, if the etire separator structure is maitaied, Lemma 3.3 The expected time to perform a isertio of a ew poit p ito a existig sphere separator tree of a set of 1 poits i R d, is O(log 3 ). Proof: At the top level, the probability of recalculatio of the sphere separator, which would cause us to rebuild the etire structure, is the same as the probability of icludig p 16

17 i the sample used i selectig a separator, which is σ(). With that probability, we ivoke the static algorithm which costructs a ew separator tree O( log ) time. Otherwise, the time required will be the expected time to rebuild a subtree. Sice the separators foud usig the static algorithm are guarateed to ( d+1 d+2 + ɛ) -split the poit set, the size of a subtree is at most δ, where δ = d+1 +ɛ. Thus we get the followig recurrece equatio for the expected d+2 time to maitai the separator tree: E[T()] σ() ( O( log ) + 1 σ() ) [T(δ)] σ() O( log ) + T(δ) = O(σ() log ) + T(δ) = O(log2 ) + T(δ) = O(log 3 ). 3.3 Deletio Lemma 3.4 The expected time to perform a deletio of a poit p from a existig sphere separator tree of a set of poits i R d is O(log 3 ). 4 High Likelihood Time Bouds I the previous sectio, we showed what the expected time bouds were for our dyamic algorithms. I this sectio, we ll show how to trasform these expected time bouds to high likelihood time bouds, usig the replicat paradigm. We defie high likelihood to be 1 1 α for some α 0 (where is the iput size). There are kow techiques for trasformig static (o-icremetal) algorithms from expected time bouds to high likelihood bouds. The mai idea is to repeat the executio of the algorithm a sufficiet umber of times to guaratee high likelihood time bouds. 17

18 For example, due to the radomized ature of the separator algorithm [4], usig a sample of size O(log ) meas that with probability 1 log the sphere separator will ot be good, i that it may itersect a large umber of balls. If that is the case, a slower O( log ) algorithm for the separator is ivoked to perform the correctio. This geerates a high likelihood time boud of O(log ), tradig time for a guaratee o the goodess of the separator. Probabilistic aalysis [4] shows that if the the slower, high likelihood O( log ) time algorithm is oly ivoked periodically (i.e. at the expected rate of failure 1 ), the log the etire algorithm is oly slowed dow by a costat factor; this yields a high likelihood time O() algorithm for the separator. Rather tha usig this method, we use multiple, idepedet processes, called replicats. Each replicat maitais its ow dyamic data structure as described i Sectio 3, which is either active up-to-date ad available to aswer queries, or i retiremet beig rebuilt. Whe the replicat is active, its data structure satisfies the iductio hypothesis specified i Sectio 3. Our goal is to have, at all times ad with high likelihood, eough active replicats that ca aswer queries about their data structure, such as whether a poit is stored i the structure, or where it is with respect to the separator. By dovetailig the work of the replicats, we slow dow the algorithm by a factor of the umber of replicats. This slowdow is the price we pay for obtaiig high likelihood bouds. I order for our idea to work, we eed to resolve two issues: 1. What happes whe a replicat is retired for rebuildig? Whe that happes, other active replicats cotiue to process requests. We eed to show that whe a replicat is retired, it will be able to catch up with the other replicats, makig up for the time lost whe the data structure is rebuilt. Otherwise, whe a replicat is retired, it is of 18

19 o further use to the algorithm. 2. How may replicats ecessary? We eed to guaratee that at ay poit i time there will be, with high likelihood, eough active replicats that ca aswer queries. The ext two subsectios deal with these issues. 4.1 Catchig up after retiremet The algorithm accepts a stream of updates (INSERT or DELETE) ad questios (QUERY), ad the goal is for each request to be processed withi a give time boud. INSERT ad DELETE requests modify the data structure, while QUERY searches through ad aswers questios about the data structures ad the poits stored i it. For example, if the replicats are maitaiig a separator for a poit set, a update takes expected time O(log ), ad a query ca be aswered i O(1)time. Our goal is to determie a high likelihood boud o the time it takes to process a request. Some requests will be processed withi this time boud. However, oce retiremet occurs, the replicat eeds to stop ad rebuild its data structure. As this is happeig, more requests arrive ad are processed by the active replicats. The retired replicat is i dager of fallig farther ad farther behid [ accelerated decrepitude ]. If it caot catch up with the request stream, it is of o further use to the algorithm. Retiremet happes with a positive probability, so if o catch-up occurs, after a fiite umber of requests o replicat will be able to process requests withi the desired time boud. The solutio to this problem of accelerated decrepitude is to double the speed of processig backlog. As each ew request arrives, the replicat stores the request but otherwise igores it. It the proceeds to process the backlog at double speed. While this is happeig 19

20 ew requests are still arrivig, ad a ew backlog is accumulatig. However, as we show below, the speedig up of the process esures that the ew backlog is smaller. The replicat cotiues to work through the backlog at double speed. After each batch is processed, there is less accumulated backlog, ad evetually the replicat is caught up. Lemma 4.1 Let R() be the time to build the data structure usig the static algorithm. A replicat that is retired for rebuildig ca be caught up with the request stream by processig the backlog accumulated at double speed, ad it will be reactivated after o more tha 6R() time. Proof: Let A() be the time to process a request with high likelihood, ad let R() be the time ecessary to rebuild the data structure. First, let us cosider a simplified sceario, i which oe of the accumulated requests require further retiremet for rebuildig. The replicat proceeds i stages through retiremet toward activatio. The first stage i the catch-up process is rebuildig the structure, which takes R() time. Durig this time, R() A() requests arrive ad are stored by the replicat. Whe rebuildig is doe, the replicat is out of date by at most R() A() requests. I the secod stage, the replicat processes this backlog, performig two operatios at a time. For each operatio performed by the active replicats, the retired replicat performs two operatios. The R() A() requests each take time to process, so the total time to process A() 2 this batch of backlog is R(). At the same time, ew requests arrive, ad are stored for further 2 referece. Because of the quickeed pace, there will be at most R() 2A() requests accumulatig. These requests will be processed i the ext catch-up stage. Cotiuig at this pace [ the light that burs twice as fast burs twice as bright ], after i catch-up stages the backlog 20

21 will be of size R() 2 i 1 A() ad will take R() 2 i+1 time to process. Whe the backlog is 1 or less, the replicat ca be reactivated. The total time i retiremet is therefore Σ i=0 R() 2 i 2R(). The simplifyig assumptio we made i the aalysis above is that there will be o further retiremet of the replicat while processig the backlog. This assumptio may ot always hold true. Retiremet may happe with probability σ(). Of the R() A() σ() R() requests that accumulate i the first stage of retiremet, A() may require rebuildig, with each rebuildig takig R() time. The remaiig ( σ()) R() A() ca be processed at double speed as above, each takig A() 2 time. Thus the total time to process the backlog accumulated durig the first stage of retiremet is σ() R() A() R() + ( σ()) R() A() A() 2 = 2σ()R()2 + ( σ()r()a(). 2A() The ew backlog accumulatig durig this time is 2σ()R()2 +( σ())r()a(). Agai, a small 2A() 2 fractio of this will require rebuildig. The time to complete the ith stage of retiremet is Thus the total time i retiremet is ( ) i 2σ()R() + ( σ())a() R(). 2A() ( ) i 2σ()R() + ( σ())a() Σ i=0 R(). 2A() This summatio coverges whe the term raised to the i is less tha 1. Give values for R() ad σ(), we ca fid out for which values of A() the summatio coverges. I particular, 2σ()R() + ( σ())a() 2A() < 1 21

22 whe A() > 2σ()R() + σ(). This gives us a lower boud o A(). Recall that A() is the high likelihood time boud for processig a request. Clearly, very large values of A() will yield short retiremet periods, but will defeat the purpose of fidig a quick way of performig updates. Values of A() that are very close to the lower boud will give very log retiremet periods, ecessitatig the use of may replicats, if we wat to esure that some are active with high likelihood. If we let A() = 3σ()R(), the base of the power term becomes +σ() 2σ()R() + ( σ()) 3σ()R() +σ() 2 3σ()R() +σ() ad the legth of each retiremet is bouded by = 5 σ() 6 R() σ() 6 6 = R() + σ() < 6R(). Note: larger values of A will result i a shorter retiremet periods. For example, for A() = 4σ()R(), the legth of a retiremet period is bouded by 4R(). Thus we ca state +σ() the followig corollary: Corollary 1 Let R() be the time to build the data structure usig the static algorithm. A replicat that is retired for rebuildig will be reactivated after O(R()) time. 4.2 Number of Replicats Now we come to the problem of determiig the umber of replicats ecessary to esure that with high likelihood there will be active replicats at all times. We would like the 22

23 probability of all replicats beig i retiremet at ay give time to be 1 α, a very low likelihood. Maitaiig more replicats requires extra time ad results i a slowdow of the algorithm. We ca place the followig bouds o the slowdow factor by carefully choosig the umber of replicats. Lemma 4.2 The umber of replicats ecessary to esure that, with high likelihood, there σ()r() log are active replicats at ay time, is O( ). Proof: Let the time per update or request if o retiremet occurs (i.e. durig activatio) be A() with high likelihood. If retiremet does occur, let the wait time util reactivatio be 6R() with high likelihood. The expected time per update is the T() = (1 σ() Assume for simplicity that this paper. σ()r() )A()+ σ() 6R(). = o(1). This is true for the applicatios described i As stated above, a replicat data structure eeds to be rebuilt after a sigle update with probability σ(). A sequece of i updates are just i idepedet trials followig a geometric distributio. Thus the expected logevity λ of a sigle replicat data structure is σ(). We costruct r idepedet replicats, each with its ow data structure. The logevity of each replicat is λ = σ(). Whe a replicat is retired, the others do t wait for it to recostruct its data structure. Rather, the recostructio happes while activated replicats cotiue processig requests. As a result, we eed to accout for catch-up time before reactivatio. Let the catch-up time for a retired replicat be 6R() (as described i the previous subsectio). The life of a replicat cosists of periods of activatio of expected legth λ, followed by periods of retiremet of legth 6R(). 23

24 Thus at ay give time, the probability that a sigle replicat is activated is γ = λ 6R() + λ = 6σ()R() +. Sice the r replicats are idepedet, the probability that at least oe replicat is curretly activated is 1 (1 γ) r. The value of r for which this traslates to a high likelihood evet, i.e. a evet with probability 1 1 α, is Sice σ()r() r α log log(1 γ). = o(1), as icreases γ 0, ad log(1 γ) γ. Cosequetly, r = α log log(1 γ) α log γ = α log (3σ()R() + ) = O( σ()r() log ). 4.3 Maitaiig Sphere Separators with High Likelihood The two results above ca be combied to give the followig theorem: Theorem 4.1 Give a icremetal, radomized algorithm with expected time T(), which uses a radom sample of size σ() of the iput, ad uses a static algorithm with time boud R() as a subroutie whe rebuildig its data structure, we ca trasform it to a icremetal σ()r() log algorithm with high likelihood time bouds with a slowdow factor of O( ). For the specific case of maitaiig sphere separators for a set of poits i R d, we ca determie the both the high likelihood time boud A() ad the umber of replicats r, give that R() is O(), ad σ() = O(log ). I order for the retiremet period to be fiite, we require, from Lemma 4.1 above, that A() > 2σ()R()/( + σ()). We ca satisfy this coditio by choosig A() = 2 log. 24

25 Note that this choice of A() meas that the legth of retiremet becomes 4R(). However, this has o sigificat effect o the umber of replicats. From Lemma 4.2 we kow that the umber of replicats ecessary to satisfy the high σ()r() log likelihood coditio is O( ). Sice R() = O(), ad σ() = O(log ) i our applicatio, the umber of replicats (which is the slowdow factor) is oly log 2. Combiig these two results, we get: Corollary 2 There exists a dyamic algorithm for maitaiig the sphere separator of a set of dyamically chagig poits which works with high likelihood time bouds of T() = O(log 3 ). 5 Applicatios ad Further Work Our results for dyamic separators ca be applied to geerate dyamic algorithms for a wide variety of combiatorial ad umerical problems which have a uderlyig associated k-eighborhood graph. For example, (i) Computatioal geometry problems, such as dyamic k-earest eighbor. (ii) Solutio of liear systems ad iverses of dyamic matrices, with chages both i the umeric values of etries i the matrix, as well as modificatios that chage the sparsity structure of the matrix. (iii) Mooid path problems o dyamic graphs, with vertex ad edge isertio ad deletio, as well chages to edge labels. 25

26 Refereces [1] Y. Chiag ad R. Tamassia. Dyamic algorithms i computatioal geometry. Tech Report CS 91 24, Departmet of Computer Sciece, Brow Uiversity, [2] R. Cole ad M.T. Goodrich. Optimal parallel algorithms for polygo ad poit-set problems. Tech Report 88 14, Departmet of Computer Sciece, Johs Hopkis Uiversity, [3] G. Frederickso. Plaar graph decompositio ad all pair shortest paths. JACM 38(1): , [4] A. Frieze, G.L. Miller ad S.-H. Teg. Separator based parallel divide-ad-coquer i computatioal geometry. Proceedigs, 4tyh Aual ACM Symposium o Parallel Algorithms ad Architectures, , [5] H. Gazit ad G.L. Miller A parallel algorithm for fidig a separator i plaar graphs. Proceedigs, 28th Aual Symposium o Foudatios of Computer Sciece, , [6] R.J. Lipto ad R.E. Tarja. A separator theorem for plaar graphs. SIAM J. Applied Math , [7] G.L. Miller, S.-H. Teg, W. Thursto ad S.A. Vavasis. Automatic mesh partitioig. i Sparse Matrix Computatios: Graph Theory Issues ad Algorithms A. George, J. Gilbert ad J. Liu, eds., IMA Volumes i Mathematics ad it Applicatios 56;57 84, Spriger-Verlag,

27 [8] G.L. Miller, S.-H. Teg, W. Thursto ad S.A. Vavasis. Separators for sphere-packigs ad earest eighbor graphs. JACM, 44(1):1 29, [9] M. Overmars. The desig of dyamic data structures. Lecture Notes i Computer Sciece, 156, Spriger-Verlag, [10] V. Pa ad J.H Reif. Extesio of the parallel ested dissectio algorithm to path algebra problems. Proc. Sixth Coferece o Foudatio of Software Techology ad Theoretical Computer Sciece, New Delhi, Idia, Lecture Notes i Computer Sciece, 241, 1986; full versio: Fast ad Efficiet Solutio of Path Algebra Problems. Joural of Computer ad Systems Scieces 38(3): , [11] V. Pa ad J.H. Reif. Acceleratio of miimum cost path calculatios i graphs havig small separator families. Techical Report, [12] S.-H. Teg. Poits, Spheres ad Separators: A Uified Geometric Approach to Graph Partitioig. PhD thesis, Caregie-Mello Uiversity, School of Computer Sciece, CMU-CS , [13] Vaidya PM. A optimal algorithm for the all-earest-eighbor problem. Proc 27th Aual Symposium o Foudatios of Computer Sciece ,