Title: Faster Query Times for Fully Dynamic $k$-Center Clustering with Outliers
Venue: NeurIPS 2023
Accepted: yes
Keywords: $k$-center clustering

outliers

dynamic algorithms
Abstract: Given a point set $P\subseteq M$ from a metric space $(M,d)$ and numbers $k, z \in N$, the *metric $k$-center problem with $z$ outliers* is to find a set $C^\ast\subseteq P$ of $k$ points such that the maximum distance of all but at most $z$ outlier points of $P$ to their nearest center in ${C}^\ast$ is minimized. We consider this problem in the fully dynamic model, i.e., under insertions and deletions of points, for the case that the metric space has a bounded doubling dimension $dim$. We utilize a hierarchical data structure to maintain the points and their neighborhoods, which enables us to efficiently find the clusters. In particular, our data structure can be queried at any time to generate a $(3+\varepsilon)$-approximate solution for input values of $k$ and $z$ in worst-case query time $\varepsilon^{-O(dim)}k \log{n} \log\log{\Delta}$, where $\Delta$ is the ratio between the maximum and minimum distance between two points in $P$. Moreover, it allows insertion/deletion of a point in worst-case update time $\varepsilon^{-O(dim)}\log{n}\log{\Delta}$. Our result achieves a significantly faster query time with respect to $k$ and $z$ than the current state-of-the-art by Pellizzoni, Pietracaprina, and Pucci, which uses $\varepsilon^{-O(dim)}(k+z)^2\log{\Delta}$ query time to obtain a $(3+\varepsilon)$-approximation.

Faster Query Times for Fully Dynamic k-Center Clustering with Outliers

Abstract

Given a point set P ⊆ M from a metric space ( M,d ) and numbers k, z ∈ N , the metric k -center problem with z outliers is to find a set C ∗ ⊆ P of k points such that the maximum distance of all but at most z outlier points of P to their nearest center in C ∗ is minimized. We consider this problem in the fully dynamic model, i.e., under insertions and deletions of points, for the case that the metric space has a bounded doubling dimension dim . We utilize a hierarchical data structure to maintain the points and their neighborhoods, which enables us to efficiently find the clusters. In particular, our data structure can be queried at any time to generate a (3 + ε ) -approximate solution for input values of k and z in worst-case query time ε -O (dim) k log n log log ∆ , where ∆ is the ratio between the maximum and minimum distance between two points in P . Moreover, it allows insertion/deletion of a point in worst-case update time ε -O (dim) log n log ∆ . Our result achieves a significantly faster query time with respect to k and z than the current state-of-theart by Pellizzoni, Pietracaprina, and Pucci [18], which uses ε -O (dim) ( k + z ) 2 log ∆ query time to obtain a (3 + ε ) -approximate solution.

1 Introduction

Clustering is a fundamental problem in machine learning and it has applications in many areas ranging from natural to social sciences. As a basic unsupervised learning method, it allows us to find structure in data. Classical center-based clustering methods for objectives like k -means, k -median and k -center have been around for many decades [9, 13, 16]. Since the beginning of clustering, the data to be analyzed has changed dramatically, raising new challenges for clustering methods. Data nowadays comes in large to huge batches and is often prone to inherent change: Content on social media platforms is constantly added, re-organized or deleted, streaming services handle an always ongoing flow of people starting and stopping to watch, tweets are the fastest method to distribute news - and delete them later if desired. Data analysis methods thus face the challenge of analyzing huge amounts of data, ideally permanently updating their solution.

In this paper, we consider the problem of dynamic k -center clustering with outliers . The (metric) k -center problem is to find a set C ∗ ⊆ P of k points such that the maximum distance of all points of P to their nearest center in C ∗ is minimized. This objective is well understood, 2 -approximations for the problem are known [9, 13] and better approximations are not possible unless P equals NP [14].

Considering outliers for k -center is very natural. Since k -center minimizes the maximum radius, a single measuring error can destroy the structure completely. Thus, the ( k, z ) -center problem allows us to ignore z points. These belong to no clusters but are deemed to be outliers , and so they are ignored when determining the maximum radius of a cluster. The concept was introduced in 2001 by Charikar, Khuller, Mount, and Narasimhan [6] who as one result provide a 3 -approximation for k -center with outliers. This variant has since been the subject of many papers, and the best-known approximation algorithm for it, which gives a 2 -approximation, was derived as recently as 2016 [2].

In parallel, fully dynamic k -center algorithms (without outliers) have been developed [1, 3, 8, 10] which work with a changing point set given as a stream of insertions and deletions. All these maintain a data structure that allows for continual updates to keep adapting to the changing data. An overview is given in Table 1. All results in this table support some form of membership queries : Given a point, return the cluster / center of the cluster of that point in the approximate solution. This type of query can typically be answered in time O (1) . Reporting the centers takes more time or is not necessarily explained how to do.

Now the challenge is to combine the two parallel developments into a fully dynamic algorithm for ( k, z ) -center clustering. We discuss the setting more precisely and then our results and related work.

̸

Our setting We say that a metric space has doubling dimension dim if dim is the smallest positive integer such that any ball of radius r can be covered by at most 2 dim balls of radius r/ 2 . For an overview of this concept, we also refer the reader to [12, 11]. Let ( M,d ) denote such a metric space and let P ⊆ M be a set of points. By d min := inf { d ( x, y ) | x, y ∈ P, x = y } and d max := sup { d ( x, y ) | x, y ∈ P } we denote the minimum and maximum inter-point distance within P , respectively. Without loss of generality, we assume that d min = 2 . Let ∆ := d max / d min be the aspect ratio of P .

We are observing a dynamic stream, i.e., we start with a point set P = ∅ and then process a sequence of operations whose length is unknown a priori. Each operation either adds a point from M to P or it deletes a point which is currently in P from P . We assume only deletions of points that are currently present are allowed, and we also assume that we can always compute d in time O (1) (otherwise, multiply all times mentioned in this paper by the time necessary to make one distance computation). We refer to the point set after time t (i.e., after t operations happened) as P t . If it is clear from the context, we will sometimes drop the subscript. We assume that d max and d min are fixed throughout the whole sequence of updates, i.e. d max = sup { d ( x, y ) | x, y ∈ P t , t ≥ 0 } , and analogously for d min . Therefore, ∆ is an upper bound on the aspect ratio over all updates and is known in advance. This is in accordance with a sequence of other works [1, 4, 3, 7, 10, 19].

The problem that we address is the dynamic k -center problem with z outliers or in short ( k, z ) -center problem : Given P t and numbers k and z , produce a set C ⊆ P t of size at most k such that the maximum distance of all but at most z points to their nearest neighbor is minimized. More formally, min Z ⊆ P t , | Z |≤ z max x ∈ P t \ Z min c ∈ C d ( x, c ) is minimized among all possible choices of C with | C | ≤ k . 1

Our focus is on building a dynamic algorithm that has a low update time for insertion and deletions. We are allowed to store P (and additional information). Our aim is to achieve an update time for our data structure that is independent of k and a query time that is at most linear in k . For this, it is necessary to consider a restricted model, as Bateni et al. [1] showed that in arbitrary metric spaces, an update time of Ω( k ) is necessary. We consider metric spaces of bounded doubling dimension . Obviously, time Θ( k ) is necessary to return an actual solution, so we distinguish between update time for insertion and deletions of points and query time for obtaining a solution from the data structure.

Our result compared to related work We present a deterministic (3+ ε ) -approximation algorithm for the k -center problem with z outliers in bounded doubling dimension that is fully dynamic, i.e., points can be inserted and deleted. Our algorithm is based on a data structure that requires space linear in n and does not need to know k and z in advance. As a result, we can answer queries for all k and z , or in other words, k and z can be part of the query. Moreover, our algorithm does not require knowledge of the doubling dimension dim of the underlying metric space, and it only appears in the analysis.

Theorem 1.1 (Main theorem) . Let ( M,d ) be a metric space of bounded doubling dimension dim , and let ε > 0 be an error parameter. There exists a deterministic dynamic algorithm that allows the insertion or deletion of points from M using worst-case ε -O (dim) log n log ∆ update time. Moreover, at any time t , it can be queried by parameters k and z to compute a (3 + ε ) -approximate solution for the k -center problem with z outliers of P t using worst-case ε -O (dim) k log n log log ∆ query time, where P t is the set of points that are inserted but not deleted up to time t , and n is the size of P t .

The first approximation algorithm for this problem has been obtained by Chan, Lattanzi, Sozio, and Wang in 2022 [4], which has an approximation ratio of 14 + ε . Very recently and in independent work, Pellizzoni, Pietracaprina, and Pucci [18] derived an algorithm with approximation ratio 3 + ε . For the problem of distributed k -center with outliers, De Berg, Biabani, and Monemizadeh [7] give a randomized dynamic algorithm that also achieves a guarantee of 3 + ε with failure probability δ . Both of these and also we develop algorithms that answer solution queries rather than membership queries, i.e., they can produce a center set at any time and this set is an approximately good solution for the current k -center with outliers instance. We state the update times (for insertions and deletions of points) and the query times (for reporting the current approximate solution) of these and our approaches in Table 2.

All three known results have a dependency on ( k + z ) 2 in their query time which we improve to a linear dependence on k and no dependence on z . This gives our approach an advantage even if k or z are only mildly dependent on n : Already for k ∈ O (log n ) and z ∈ O ( √ n ) , the query complexity of [18] would be linear in n compared to the poly-logarithmic dependency in terms of n for our query time. More interestingly, for a realistic regime where z is an epsilon-fraction of n , the query time of the dynamic algorithm presented in [18] has quadratic dependency in terms of n while our query time still has a logarithmic dependency in terms of n and linear dependency in terms of k . [4] also states a bicriteria approximation where the number of outliers can be violated with improved running time, but the dependency on k is still quadratic. When comparing to [7], it should be noted that their algorithm is only applicable to the Euclidean metric space, is randomized and only works against oblivious adversaries. Further, the coreset size (and the space complexity) of the algorithm in [7] is x = O ( kϵ -dim log ∆ + z ) . In the streaming model, in order to extract the solution, one needs to run an offline algorithm on the coreset. In this way, the query time of this algorithm is O ( kx 2 log x ) = O ( k ( z 2 + k 2 ) ϵ -2 dim log 2 ∆) which is significantly worse than the query time of our algorithm.

The main difference of our approach is that it makes the greedy algorithm for k -center with outliers dynamic while the previous dynamic algorithms extract a coreset and run the greedy algorithm on this coreset. Known dynamic algorithms [4, 7, 18] for the k -center problem with outliers maintain a coreset after every update. In particular, in [18], they extract the coreset by simply reading the solution from the cover tree. To extract an approximate solution for this problem, one needs to run a known (offline) greedy algorithm on this coreset. In this way, the query complexities of those algorithms are dominated by the running time of the greedy algorithm. The novelty of our dynamic algorithm is that we make the greedy algorithm itself dynamic. To this end, we use heap data structures to compute a ball that covers the maximum number of points, and dynamic neighborhood sets to obtain points in the expanded maximum ball and update their corresponding keys in the heap to recursively find the next maximum balls.

Navigating nets. The state-of-the-art algorithm for the fully dynamic k -center problem (without outliers) in doubling metrics, developed by Goranci et al. [10] uses navigating nets originally introduced by Krauthgamer and Lee [15]. The basic idea of a navigating net is to start with the point set P t as the base net N 1 and then compute coarser and coarser variants of it, resulting in a hierarchy of nets N 1 , N 2 , . . . , N 2 i , . . . . For every level in this hierarchy, the points are good representatives of the points in the level below but the higher we get in the net, we have fewer points that are better separated. More precisely, following Krauthgamer and Lee [15], every level is a so-called r -net of the level below it. An r -net on a set X is a subset Y ⊆ X that satisfies two properties:

∀ p ∈ X ∃ y ∈ Y : d ( p, y ) < r (Covering)

∀ x, y ∈ Y : d ( x, y ) ≥ r (Packing)

In a navigating net, one always assures that N r is an r -net of N r/ 2 . Assume that the minimum inter-point distance d min satisfies d min = 2 and that the ratio between maximum and minimum inter-point distance is ∆ . Then a navigating net with O (log ∆) levels can be computed in a greedy fashion. Intriguingly, one can show that in the resulting navigating net, the lowest level with | N r | ≤ k provides an 8 -approximation for the k -center problem (without outliers, i.e., z = 0 ). This was first observed (in the context of streaming algorithms and there known as the doubling algorithm ) by Charikar, Chekuri, Feder, and Motwani [5]. An additional trick to improve the approximation ratio was discovered by McCutchen and Khuller [17] (again, in the setting of streaming). They observed that the quality of the solutions depends heavily on what the radius of the lowest level is, and that this radius can be shifted by small amounts, and one of the shifted versions will give a 2 + ε approximation. By maintaining the navigating net structure and using a similar shifting trick, dynamic k -center algorithms maintain enough information to answer queries by checking one or a few levels of the resulting navigating net and reporting the points on that level as the solution, as for example in [1, 10].

Challenges with outliers. For the ( k, z ) -center problem, the challenge is that net which provides a good solution in itself.

OPT

there is no level in the navigating We know that an optimal ( k, z ) -center solution has a radius that lies between the radius of a k -center solution (because any k -center solution is feasible for the ( k, z ) -center problem) and the radius of a ( k + z ) -center solution (because any ( k, z ) -center solution is feasible for the ( k + z ) -center problem). But as Figure 1 shows, neither of the two choices may provide a good estimate for the optimum ( k, z ) -center solution. Say level r 1 is the first to satisfy | N r 1 | ≤ k + z and level r 2 is the first to satisfy | N r 2 | ≤ k . Then the points in N r 2 are a feasible solution for the ( k, z ) -center problem, but their radius may be too large, while the radius of the solution in N r 1 is guaranteed to be small enough, but these points may not constitute a feasible solution for ( k, z ) -center. This is because every point in N r represents several points in the levels below it. So we cannot simply divide the k + z

points into k centers and z outliers (see Figure 1). Therefore, there is no individual level which we can query to obtain a solution. Instead, we need to compute a solution from the navigating net levels while making sure not to lose too much in terms of quality and query time.

Pellizzoni et al. [18] base their approach on the so-called 'cover tree' data structure, which is similar to that of a navigating net, to compute a coreset from which they construct the final solution. In their approach, they find the lowest level with | N r | ≤ 2 O (dim) ε -dim ( k + z ) and demonstrate that such N r serves as an ε -coreset for ( k, z ) -center. However, since it is not a feasible solution, they utilize a 3 -approximation greedy algorithm to obtain a (3 + ε ) -approximate clustering, which requires a time complexity of Ω( ε -2 dim ( k + z ) 2 ) . In this paper, we strategically integrate additional information at each level to directly emulate the offline 3 -approximation greedy algorithm by Charikar et al. [6] in the dynamic setting. This approach enables us to achieve a time complexity that is linearly dependent on k and remarkably independent of z .

2 Our data structure

In this section, we describe our data structure, which has O (log ∆) levels. In each level r , we have net N r , which is an r -net of N r/ 2 . For each point p ∈ N r , we keep its weight w r ( p ) and local neighborhoods B 1 p,r and B 3 p,r , which are balls of radius (1 + O ( ε )) r and (3 + O ( ε )) r respectively. Then we maintain max-heap H r which is designed to store the total weights of neighborhoods B 1 p,r for all p ∈ N r . We also keep rep r ( p ) for each point p ∈ P , which is the representative of p in N r . Below, we provide a detailed explanation for elements of our data structure.

Input and set R . To start building our data structure, we require three input parameters: ∆ , ε ′ , and β , where 0 < ε ′ < 1 , and 1 2 < β ≤ 1 . ∆ denotes the spread ratio of the underlying point set P and ε ′ is the given error parameter. We utilize β to define R := { 0 }∪{ β · 2 ℓ | 0 ≤ ℓ ≤ ⌈ log 2 ∆ ⌉ +1 , ℓ ∈ Z } as a set of levels. Additionally, we define ε := 2 ⌊ log ε ′ ⌋ . This implies that ε ′ / 2 < ε ≤ ε ′ . Furthermore, if r ∈ R , then either εr ∈ R or εr < β .

Nets N r . We maintain net N r for each r ∈ R , satisfying the following conditions: N 0 = N β = P t , where P t is the set of points at time t , and for r > β , N r is an r -net of N r/ 2 . For p ∈ N r and q ∈ N r/ 2 , we say p is a parent of q (and q is a child of p ) if d ( p, q ) ≤ r . In our data structure, we store all the parents and children for each point for all the nets. It is important to note that each point can have at most 2 O (dim) parents or children. In the full version, we explain how to handle each insert/delete in time 2 O (dim) log ∆ .

During the paper, we may refer to N εr for 0 < εr < β , which means εr / ∈ R . Besides, note that since d min = 2 and β < 2 , P t is an r -net for any 0 ≤ r ≤ β . To solve this issue, we define N r := P t for any 0 < r < β , however, we do not explicitly keep any r -nets for 0 < r < β in our data structure to prevent redundancy.

Representatives rep r and weights w r . For all r ∈ R , we inductively define functions rep r : P t → N r such that each point p ∈ P t has a unique representative rep r ( p ) in net N r . To define rep r ( p ) , we consider three cases. First, if p ∈ N r , then we define rep r ( p ) := p . Second, if p / ∈ N r but p ∈ N r/ 2 , we uniquely choose one of the parents of p in N r as rep r ( p ) . Third, if p / ∈ N r/ 2 and therefore p / ∈ N r , we define rep r ( p ) = rep r ( rep r/ 2 ( p )) . Again to avoid inconsistency, we define rep r ( p ) := p for any 0 < r < β , but we do not store this explicitly. We show in Lemma 2.1 that the distance between each point p and its representative in N r is at most 2 r .

Next, we define a weight function w r for every level. For every point p ∈ N r , its weight w r ( p ) denotes the number of points that p is representing in N r . More formally, w r ( p ) = ∣ ∣ { q ∈ P t | rep r ( q ) = p } ∣ ∣ . For a set X ⊆ N r , we define w r ( X ) := ∑ p ∈ X w r ( p ) . Equivalently, w r ( X ) = ∣ ∣ { y ∈ P t | rep r ( y ) ∈ X } ∣ ∣ . Note that the sum of weights of all representatives at any level is equal to the total number of points, so w r ( N r ) = | P t | for all r ∈ R .

Since we store all the parents and children, we can easily update the representatives and therefore the weights after each insert/delete. The details are presented in the full version.

Balls B 1 and B 3 . Let r ∈ R . For every point p ∈ N εr , we maintain the close neighborhood B 1 p,r := Ball( p, (1 + 4 ε ) r ) ∩ N εr and the extended neighborhood B 3 p,r := Ball( p, (3 + 8 ε ) r ) ∩ N εr , where Ball( p, λ ) = { q ∈ M | d ( p, q ) ≤ λ } denotes the ball of radius λ around p in the metric space M . Then B 1 := { B 1 p,r | r ∈ R, p ∈ N εr } and B 3 := { B 3 p,r | r ∈ R, p ∈ N εr } are the collections of local neighborhoods at different scales. As mentioned in Lemma 2.2, the size of each of these neighborhoods is at most 2 O (dim) /ε dim . We also show that we can update these neighborhoods in time 2 O (dim) ε -2 dim log ∆ after each insert/delete in the proof of Lemma 2.3.

Heaps H r . For every r ∈ R , we maintain a max-heap H r of the set { ( p, w εr ( B 1 p,r )) | p ∈ N εr } representing the weight of the close neighborhood of any point in level r . With H r [ p ] we denote the value of the max heap element with key p . Since B 1 p,r might change, we need to find the position of the respective heap element by its key p . Hence, for any level r , we keep a pointer from every element in N r to its corresponding element in H r .

Whenever an update happens to a set B 1 p,r for some point p ∈ N εr , we need to update the value of w εr ( B 1 p,r ) as well as the value of H r [ p ] . Each update in the max-heap H r can be done in O (log n ) time using the standard max-heap operations. In the full version, we show that 2 O (dim) ε -dim log ∆ updates happen to set B 1 . Therefore, we need 2 O (dim) ε -dim log ∆ log n time to update the heaps.

A few lemmas about our data structure. Now we mention a few useful lemmas about our data structure. The formal proofs can be found in the full version. The first lemma is about the distance of each point to its representative, which is bounded because of a geometric series argument.

Lemma 2.1. Let p ∈ P t and r ∈ R . Then d ( p, rep r ( p )) ≤ 2 r . In particular, d ( p, rep εr ( p )) ≤ 2 εr , where ε = 2 ⌊ log ε ′ ⌋ for the error parameter ε ′ .

We next discuss the size of close neighborhoods and extended neighborhoods.

Lemma 2.2. Let r ∈ R and p ∈ N εr . The sets B 1 p,r and B 3 p,r defined above are of size at most 2 O (dim) ε -dim . In particular, the size is O ( ε -dim ) for a constant doubling dimension dim .

In the next lemma, we show that the update time is logarithmic in the spread ratio and the size of P t .

Lemma 2.3. Let n be the size of point set P t . Then after insertion/deletion of any point to P t , we can update our data structure in time 2 O (dim) ε -2 dim log ∆ log n .

Besides insertion and deletion updates, our data structure supports solution queries: in every time step, it can produce a solution in the form of a center set and a radius. We will discuss this in more detail and present an algorithm that outputs a (3 + O ( ε )) -approximation in time ε -O (dim) k log n log log ∆ in the following section.

3 Our algorithm

Overview For a given level r in R and a number of centers k , the main procedure MAXCOVERAGE produces a set of k centers and a value outliersWeight . One run of this procedure is deemed successful if outliersWeight ≤ z at the end. Indeed, we will later show that outliersWeight is an upper bound on the actual number of outliers in the clustering with centers C and radius (3 + 10 ε ) r , which implies that this is a feasible solution. The algorithm FINDCENTERS finds one such level for which MAXCOVERAGE is successful. We also ensure that this level is chosen such that MAXCOVERAGE is not successful on the next lower level r/ 2 , which guarantees that the radius of our solution does not deviate from the optimal solution by too much.

In our algorithm, we repeatedly find areas that subsume the most points. In order to do this efficiently, we maintain the collections of close neighborhoods and their weights in max-heaps. Fix a level r ∈ R . For k iterations, the root node of the current heap corresponds to the next center of our solution. After picking it, we mark points in the extended neighborhood because our final approximate solution will cover these points and they should not contribute to the weight of other neighborhoods anymore.

As these points are now covered, we decrease the weights of heap elements representing points therein accordingly. These steps are performed by MAXCOVERAGE. Note that for maintenance reasons, one run of FINDCENTERS should leave the original heaps unchanged. We could make a copy of the heap before processing it in MAXCOVERAGE, but it is faster to work on the original heaps and just roll back all the updates done during MAXCOVERAGE at the end of the algorithm, as described in Lemma 3.8.

It remains to find a good value for r . By applying a binary search, we find a radius r such that the value of outliersWeight outputted by MAXCOVERAGE( k , r ) is at most z , while the respective output on the lower level r/ 2 is more than z . Note that it is possible to find such a pair of subsequent radii via binary search although the search space might

Procedure MAXCOVERAGE( k , r )

1 C ←∅ , Marked ←∅ , outliersWeight ← n

2 Let H be a copy of H r

3

for

i

= 1

to

k

do

4

Let

c

i

be the key with maximum value in heap

H

5

C

C

∪ {

c

i

}

6

for

each

y

∈

B

3

c

i

,r

such that

y /

∈

Marked

do

7

Marked

Marked

∪{

y

}

8

for

each

x

∈

B

1

y,r

do

9

Decrease

H

[

x

]

by

w

εr

(

y

)

10

outliersWeight

outliersWeight

-

w

εr

(

y

)

11 return C , outliersWeight

Algorithm 1: FINDCENTERS ( k, z )

Output: Centers C of a (3 + 10 ε ) ρ -approximation for ( k, z ) -center

1 if MAXCOVERAGE ( k, 0) . outliersWeight ≤ z then

2 return MAXCOVERAGE ( k, 0)

3 By performing a binary-search on R , find ˆ r such that MAXCOVERAGE ( k, ˆ r ) . outliersWeight ≤ z , and MAXCOVERAGE ( k, ˆ r/ 2) . outliersWeight > z if ˆ r > 2

4 return MAXCOVERAGE ( k, ˆ r )

not be monotone. In the special case that there are at most z points in total, we can just set the radius to 0. This is done in Algorithm 1 (FINDCENTERS ( k, z ) ).

Analysis Next, we prove the approximation guarantee and time complexity of our algorithm.

Let r and k be fixed, and let i ∈ [1 , k ] be an integer. For any point y ∈ N εr , we say y is marked after the i -th iteration of the loop in Line 3 of MAXCOVERAGE, if y ∈ ⋃ i j =1 B 3 c j ,r , and we say it is unmarked if it is not the case. For simplicity, we may refer to a point as marked or unmarked without specifying the iteration if it is clear from the context. We define set U i := { y ∈ N εr | y / ∈ ⋃ i j =1 B 3 c j ,r } as the set of unmarked points after the i -th iteration. We next define O i := { p ∈ P t | rep εr ( p ) / ∈ ⋃ i j =1 B 3 c j ,r } as the set of points that are considered outliers after the i -th iteration of the loop. Equivalently, O i := { p ∈ P t | rep εr ( p ) ∈ U i } . After the i -th iteration of the loop in Line 3, for each y ∈ N εr , H r [ y ] is the total weight of unmarked points in B 1 y,r .

Lemma 3.1 (Invariant for heaps) . Let k be an integer, 0 ≤ i ≤ k , and r ∈ R . Then for any y ∈ N εr it holds H r [ y ] = w εr ( B 1 y,r ∩ U i ) after the i -th iteration.

FINDCENTERS ( k, z ) returns a solution when outliersWeight ≤ z . To show that this solution is feasible, it remains to prove that outliersWeight is an upper bound on the actual number of outliers of this solution.

Lemma 3.2 (Feasible solution) . Consider a radius r ∈ R , and an integer k . Then MAXCOVERAGE ( k, r ) returns k centers and a value outliersWeight , such that the total number of points in P t that are not within distance (3 + 10 ε ) r of these k centers is at most outliersWeight .

Proof. Let outliersWeight denote MAXCOVERAGE ( k, r ) . outliersWeight . We want to prove that MAXCOVERAGE ( k, r ) returns { c 1 , . . . , c k } such that | P t \ ⋃ j ≤ k Ball( c j , (3 + 10 ε ) r ) | ≤ outliersWeight . In every iteration i , outliersWeight is decreased by w εr ( y ) for every y ∈ B 3 c i ,r \ Marked. After processing y , we add it to Marked. This way, we ensure that no y is charged twice. Therefore, by the end of the algorithm, outliersWeight is decreased by w εr ( ⋃ j ≤ k B 3 c j ,r ) .

Hence, in the end, the value of outliersWeight is

For all p ∈ P t , if rep εr ( p ) ∈ ⋃ j ≤ k B 3 c j ,r , then d ( c j , rep εr ( p )) ≤ (3 + 8 ε ) r holds for at least one j ≤ k by definition of B 3 c j ,r . Using Lemma 2.1, this implies d ( c j , p ) ≤ d ( c j , rep εr ( p )) + d ( rep εr ( p ) , p ) ≤ (3 + 8 ε ) r +2 εr = (3 + 10 ε ) r . Hence, { p ∈ P t | rep εr ( p ) ∈ ⋃ j ≤ k B 3 c j ,r } ⊆ { p ∈ P t | ∃ j ≤ k : d ( c j , p ) ≤ (3 + 10 ε ) r } and therefore

Consider a fixed optimal solution. The following insight is crucial for our proof: In every iteration of MAXCOVERAGE ( k, r ) for r ≥ OPT , we select a ball that covers a sufficient number of unmarked points. To be precise, it exceeds the number of currently considered outliers in any optimal cluster.

Lemma 3.3 (Invariant for picking c i ) . Let r ≥ OPT , where r ∈ R , and let c ∗ ∈ P t be a center of an optimal solution for k -center with z outliers. Assume that we execute MAXCOVERAGE ( k, r ) . Then for any i ∈ [1 , k ] , the c i picked in Line 4 is such that | Ball( c ∗ , OPT ) ∩ O i -1 | ≤ w εr ( B 1 c i ,r ∩ U i -1 ) .

Proof. We define ˆ c := rep εr ( c ∗ ) , the representative of c ∗ in N εr . Recall that B 1 ˆ c,r = { y ∈ N εr | d (ˆ c, y ) ≤ (1 + 4 ε ) r } . Lemma 3.1 states that H [ y ] = w εr ( B 1 y,r ∩ U i -1 ) holds for all y ∈ N εr after the ( i -1) -th iteration. Since c i is on top of the max-heap H , we have w εr ( B 1 ˆ c,r ∩ U i -1 ) ≤ w εr ( B 1 c i ,r ∩ U i -1 ) . Therefore, it remains to show that | Ball( c ∗ , OPT) ∩ O i -1 | ≤ w εr ( B 1 ˆ c,r ∩ U i -1 ) .

According to the definition of representative and weight function, we first have

We next show that for any point p ∈ Ball( c ∗ , OPT) ∩ P t , its representative on level εr lies in B 1 ˆ c,r , i.e. rep εr ( p ) ∈ B 1 ˆ c,r . Let p ∈ Ball( c ∗ , OPT) ∩ P t be an arbitrary point, then d ( c ∗ , p ) ≤ OPT ≤ r . By the triangle inequality, d (ˆ c, rep εr ( p )) ≤ d (ˆ c, c ∗ ) + d ( c ∗ , p ) + d ( p, rep εr ( p )) . Besides, Lemma 2.1 implies that d (ˆ c, c ∗ ) ≤ 2 εr and d ( p, rep εr ( p )) ≤ 2 εr . Putting everything together we have

Besides, p ∈ O i -1 is equivalent to rep εr ( p ) ∈ U i -1 . Therefore, p ∈ Ball( c ∗ , OPT) ∩ O i -1 implies rep εr ( p ) ∈ B 1 ˆ c,r ∩ U i -1 , and we have rep εr (Ball( c ∗ , OPT) ∩ O i -1 ) ⊆ B 1 ˆ c,r ∩ U i -1 . Thus,

which finishes the proof.

Utilizing Lemma 3.3, we can now show that the weight of the final output of MAXCOVERAGE ( k, r ) with r ≥ OPT is at least the number of points covered by any optimal solution.

Lemma 3.4 (Invariant for coverage weight) . Let C ∗ be the set of k centers of an optimal solution for k -center with z outliers on P t , and let OPT be the radius of this solution. Let r ≥ OPT , where r ∈ R . Then,

(recall that B 3 c j ,r = Ball( c j , (3 + 8 ε ) r ) ∩ N εr and w εr ( B 3 c j ,r ) = |{ y ∈ P t | rep εr ( y ) ∈ B 3 c j ,r }| ).

Proof. To prove the lemma, we show that for any i ∈ [0 , k ] , there is a charging that satisfies the following conditions: 1) There is a set { c ∗ 1 , . . . , c ∗ i } ⊆ C ∗ and a function that charges each point in ⋃ i j =1 Ball( c ∗ j , OPT ) ∩ P t to a point y ∈ ⋃ i j =1 B 3 c j ,r , and 2) for any point y ∈ ⋃ i j =1 B 3 c j ,r , at most w εr ( y ) points from ⋃ i j =1 Ball( c ∗ j , OPT ) ∩ P t are mapped to y .

We prove this claim by induction on i . The base case i = 0 trivially holds. Assume that i ≥ 1 and the induction hypothesis holds for i -1 . That is, there is a charging satisfying conditions 1 and 2 for i -1 . Then, we prove that these conditions hold for i .

To define center c ∗ i , we consider two cases:

Case 1: there exists a center c ∗ ∈ C ∗ \ { c ∗ 1 , . . . , c ∗ i -1 } for which B 1 c i ,r hits the set of representatives of Ball( c ∗ , OPT) . That is, we have rep εr (Ball( c ∗ , OPT)) ∩ B 1 c i ,r = ∅ . We then let c ∗ i = c ∗ . We map every point of Ball( c ∗ , OPT) to its unique representative.

̸

Case 2: the first case is not correct. Then, we let c ∗ i be any arbitrary point in C ∗ \ { c ∗ 1 , . . . , c ∗ i -1 } . In this case, we charge the uncharged points of Ball( c ∗ i , OPT) to B 1 c i ,r .

We first consider Case 1. We charge each point p ∈ Ball( c ∗ i , OPT ) to its representative rep εr ( p ) . We next prove the following claim:

Claim. Let p ∈ Ball( c ∗ i , OPT ) . If Case 1 happens, then for every point q ∈ P t that is charged to rep εr ( p ) , it holds that rep εr ( q ) = rep εr ( p ) .

̸

Proof. For the sake of contradiction, assume that there is a point q ∈ P t such that q is charged to rep εr ( p ) and rep εr ( q ) = rep εr ( p ) . It means that at an iteration j < i , Case 2 happened and q is charged to rep εr ( p ) . Since Case 2 happened at iteration j , we have rep εr (Ball( c ∗ i , OPT )) ∩ B 1 c j ,r = ∅ and also q is charged to a point in B 1 c j ,r . Adding it to the assumption that q is charged to rep εr ( p ) we have rep εr ( p ) ∈ B 1 c j ,r . Besides, p ∈ Ball( c ∗ i , OPT ) and therefore we have rep εr ( p ) ∈ rep εr (Ball( c ∗ i , OPT )) . This implies that rep εr ( p ) ∈ rep εr (Ball( c ∗ i , OPT )) ∩ B 1 c j ,r , which is a contradiction to rep εr (Ball( c ∗ i , OPT )) ∩ B 1 c j ,r = ∅ . ◁

The claim implies that for each point p ∈ Ball( c ∗ , OPT ) , at most w εr ( rep εr ( p )) points are charged to rep εr ( p ) . See Figure 2, where the left blue ball represents B 1 c i ,r , the right blue one indicates the area that points from rep εr (Ball( c ∗ , OPT)) can lie in, and the orange circle represents Ball( c ∗ , OPT) . For each point p ∈ Ball( c ∗ , OPT ) , we have rep εr ( p ) ∈ B 3 c i ,r : Let q ∈ Ball( c ∗ , OPT) be such that rep εr ( q ) ∈ rep εr (Ball( c ∗ , OPT)) ∩ B 1 c i ,r . The distance of c i to any

c

i

c

∗

rep

εr

(

q

)

q

p

rep

εr

(

p

)

B

1

c

i

,r

rep

εr

c

∗

,

OPT))

c

∗

,

OPT)

representative of a point p ∈ Ball( c ∗ , OPT) is

implying that rep εr ( p ) ∈ B 3 c i ,r .

For Case 2: note that if p ∈ P t \ O i -1 , then by definition of O i -1 , we have rep εr ( p ) / ∈ U i -1 , and hence rep εr ( p ) ∈ ∪ i -1 j =1 B 1 c j ,r by definition of U i -1 . So, by induction hypothesis, p is already charged to rep εr ( p ) . Therefore, we only need to charge each point p ∈ Ball( c ∗ , OPT ) ∩ O i -1 . By Lemma 3.3 we have | Ball( c ∗ , OPT ) ∩ O i -1 | ≤ w εr ( B 1 c i ,r ∩ U i -1 ) . Also, we only charged to

the points in ∪ i -1 j =1 B 3 , which means that no point is charged a point in U i -1 . Therefore, points in Ball( c ∗ , OPT ) ∩ O i -1 can be charged to points in B 1 c i ,r ∩ U i -1 .

Lemma 3.5. Let r ∈ R and OPT be the optimal radius for k -center clustering of P t with z outliers. Then if r ≥ OPT , the value outliersWeight returned by MAXCOVERAGE ( k, r ) is at most z .

Proof. Let C = { c 1 , . . . , c k } be the set of centers returned by MAXCOVERAGE ( k, r ) and C ∗ be the set of centers of an optimal k -center clustering of P t with z outliers. By the same reasoning as in the proof of Lemma 3.2, it is

Besides, Lemma 3.4 states that w εr ( ∪ k i =1 B 3 c i ,r ) ≥ | ∪ c ∗ ∈ C ∗ Ball( c ∗ , OPT ) ∩ P t | . Moreover, as C ∗ are the centers of an optimal solution, n -| ∪ c ∗ ∈ C ∗ Ball( c ∗ , OPT ) ∩ P t | ≤ z . Putting everything together, we have

which finishes the proof.

Lemma 3.2 and Lemma 3.5 together imply that the solution returned by Algorithm 1 is feasible. Further, it can be shown that the level ˆ r at which FINDCENTERS ( k, z ) becomes successful, fulfills ˆ r ≤ r ∗ . Together, this implies the following statement.

Lemma 3.6 (Approximation guarantee) . Let OPT > 0 be the optimal radius for the k -center clustering of P t with z outliers, and let r ∗ be the minimum number in R such that r ∗ ≥ OPT . Then FINDCENTERS ( k, z ) returns a (3 + 10 ε ) ρ -approximate solution for k -center clustering problem with z outliers, where ρ = r ∗ OPT .

For ρ defined in Lemma 3.6, 1 ≤ ρ < 2 holds according to the definition of R . It immediately leads to a (6 + O ( ε )) -approximation algorithm. Next in Lemma 3.7, we show how to get ρ ≤ (1 + ε ) , which improves the approximation ratio of our algorithm to 3 + O ( ε ) . The idea is to run parallel instances of our data structure with different values for parameter β , so that always OPT ≤ r < (1 + ε ) OPT holds for a r ∈ R in one of the instances.

Lemma 3.7 (Optimizing the approximation ratio) . Let OPT > 0 , and let ε > 0 be fixed. We define m := ⌈ 1 / log 2 (1 + ε ) ⌉ . Suppose we have m parallel instances of our data structure with parameter β = 2 i/m -1 for the i -th instance. Then in at least one of the instances, we find a (3 + O ( ε )) -approximation solution for k -center clustering with z outliers by calling FINDCENTERS ( k, z ) .

The procedure MAXCOVERAGE ( k, r ) needs to temporarily edit the heap H r . This can be done by working on a copy of the heap, as indicated in line 2. The following result describes how this can be done faster, without actually copying the heap. The idea is to work in place and roll back all changes in the end. The formal proof is given in the full version.

Lemma 3.8 (Imitating of copying H r ) . Let u be the number of times that MAXCOVERAGE ( k, r ) updates heap H . Then copying heap H r in Line 2, as well as all these u updates, can be handled in total time O ( u log n ) .

By using Lemma 3.8 and Lemma 2.2, we get the query time in Lemma 3.9.

Lemma3.9 (Query time) . Let k and z be two given parameters. Then FINDCENTERS ( k, z ) described in Algorithm 1 has a time complexity of 2 O (dim) ε -2 dim k log n log log ∆ .

4 Conlusion

We developed a data structure for the fully dynamic k -center with z outliers problem in metrics of bounded doubling dimension. As compared to other works, the algorithm exhibits an improved query time while achieving the currently best-known approximation ratio of 3 + ε . The query time is optimal with respect to the dependency on k . Although the exponential dependency on the doubling dimension in the running times seems necessary, it is actually not clear if this could be improved to tackle even wider classes of metric spaces. This would be an interesting aspect for future work. However, Chan et al. [4] show that an amortized running time of Ω( z ) would be needed in general metric spaces.

References

MohammadHossein Bateni, Hossein Esfandiari, Hendrik Fichtenberger, Monika Henzinger, Rajesh Jayaram, Vahab Mirrokni, and Andreas Wiese. Optimal fully dynamic k -center clustering for adaptive and oblivious adversaries. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA) , pages 2677-2727. Society for Industrial and Applied Mathematics, 2023.

Deeparnab Chakrabarty, Prachi Goyal, and Ravishankar Krishnaswamy. The non-uniform k -center problem. In Proceedings of the 43rd International Colloquium on Automata, Languages, and Programming (ICALP) , volume 55 of LIPIcs. Leibniz Int. Proc. Inform. , pages Art. No. 67, 15. Schloss Dagstuhl. Leibniz-Zent. Inform., Wadern, 2016.

T-H. Hubert Chan, Arnaud Guerqin, and Mauro Sozio. Fully dynamic k -center clustering. In Proceedings of the 2018 World Wide Web Conference , pages 579-587, 2018.

T-H. Hubert Chan, Silvio Lattanzi, Mauro Sozio, and Bo Wang. Fully dynamic k -center clustering with outliers. In Computing and Combinatorics: 28th International Conference, COCOON2022, Shenzhen, China, October 22-24, 2022, Proceedings , pages 150-161. Springer, 2023.

Moses Charikar, Chandra Chekuri, Tomás Feder, and Rajeev Motwani. Incremental clustering and dynamic information retrieval. In Proceedings of the twenty-ninth annual ACM symposium on Theory of computing , pages 626-635, 1997.

Moses Charikar, Samir Khuller, David M. Mount, and Giri Narasimhan. Algorithms for facility location problems with outliers. In S. Rao Kosaraju, editor, Proceedings of the Twelfth Annual Symposium on Discrete Algorithms, January 7-9, 2001, Washington, DC, USA , pages 642-651. ACM/SIAM, 2001.

Mark de Berg, Leyla Biabani, and Morteza Monemizadeh. k -center clustering with outliers in the MPC and streaming model. CoRR , abs/2302.12811, 2023.

Hendrik Fichtenberger, Monika Henzinger, and Andreas Wiese. On fully dynamic constantfactor approximation algorithms for clustering problems. CoRR , abs/2112.07217, 2021.

Teofilo F Gonzalez. Clustering to minimize the maximum intercluster distance. Theoretical computer science , 38:293-306, 1985.

Gramoz Goranci, Monika Henzinger, Dariusz Leniowski, Christian Schulz, and Alexander Svozil. Fully dynamic k -center clustering in low dimensional metrics. In 2021 Proceedings of the Workshop on Algorithm Engineering and Experiments (ALENEX) , pages 143-153. SIAM, 2021.

Anupam Gupta, Robert Krauthgamer, and James R Lee. Bounded geometries, fractals, and low-distortion embeddings. In Proceedings of the 44th Annual IEEE Symposium on Foundations of Computer Science, 2003 , pages 534-543. IEEE, 2003.

Juha Heinonen. Lectures on analysis on metric spaces . Springer Science & Business Media, 2001.

Dorit S Hochbaum and David B Shmoys. A unified approach to approximation algorithms for bottleneck problems. Journal of the ACM (JACM) , 33(3):533-550, 1986.

Wen-Lian Hsu and George L. Nemhauser. Easy and hard bottleneck location problems. Discrete Applied Mathematics , 1(3):209-215, 1979.

Robert Krauthgamer and James R Lee. Navigating nets: Simple algorithms for proximity search. In Proceedings of the fifteenth annual ACM-SIAM symposium on Discrete algorithms , pages 798-807. Citeseer, 2004.

Stuart P. Lloyd. Least squares quantization in PCM. IEEE Transactions on Information Theory , 28(2):129-137, 1982. Originally published in 1957 as Bell Laboratories Technical Memorandum.

Richard Matthew McCutchen and Samir Khuller. Streaming algorithms for k -center clustering with outliers and with anonymity. In Approximation, Randomization and Combinatorial Optimization. Algorithms and Techniques , pages 165-178. Springer, 2008.

Paolo Pellizzoni, Andrea Pietracaprina, and Geppino Pucci. Fully dynamic clustering and diversity maximization in doubling metrics. CoRR , abs/2302.07771, 2023.

Melanie Schmidt and Christian Sohler. Fully dynamic hierarchical diameter k -clustering and k -center. arXiv preprint arXiv:1908.02645 , 2019.

A Maintaining the data structure

As we explained in Section 2, our data structure consists of O (log ∆) levels R := { 0 } ∪ { β · 2 ℓ | ℓ ∈ Z , 0 ≤ ℓ ≤ ⌈ log 2 ∆ ⌉ +1 } , where 1 2 < β ≤ 1 is a given parameter. Similar to Krauthgamer and Lee [15], on each level r , we maintain net N r , which is an r -net of N r/ 2 . In this section, we explain how to maintain our data structure after each insert/delete update, and analyze the update time.

For every point p ∈ N r , we maintain the sets of all its parents and all its children. We start by bounding the number of children and parents of each point. Recall that p ∈ N r is called a parent of q ∈ N r/ 2 if d ( p, q ) ≤ r . We first show that the number of children for each point is of size 2 O (dim) .

Lemma A.1 (Number of children) . Let p ∈ N r . The number of children of p is at most 2 2 dim .

Proof. For every child q ∈ N r/ 2 of p it is d ( p, q ) ≤ r . Therefore, the set of children is covered by Ball( p, r ) . Using the definition of doubling dimension twice, it follows that the set of children can be covered by 2 2 dim balls of radius r/ 4 . As any two points in N r/ 2 have distance at least r/ 2 , the claim follows.

Then, in a similar fashion, we can deduce the number of parents.

Lemma A.2 (Number of parents) . Let p ∈ N r . The number of parents of p is bounded by 2 O (dim) .

A.1 Finding the neighbours

In this section, we explain FindNeighbours, which takes as input a value γ ≥ 2 and a point p ∈ P t and returns for every r ∈ R \ { 0 } the set of neighbors of p within distance γr . Later, we use this procedure to maintain our data structure after insertions and deletions.

Lemma A.3. Let p ∈ P , and γ ≥ 2 . Then, for all r ∈ R \ { 0 } , set S r that we compute in FindNeighbours ( p, γ ) consists of all elements in N r within distance γ · r of p .

Proof. We show the statement via induction on r . For r = r max = β · 2 ⌈ log ∆ ⌉ , line 3 implies S r = N r and therefore the statement is trivially fulfilled. Now assume the statement holds for 2 r , where r < r max . Consider x ∈ N r such that d ( p, x ) ≤ γr . Then, d ( p, rep 2 r ( x )) ≤ d ( p, x ) + d ( x, rep 2 r ( x )) ≤ γr +2 r ≤ 2 γr , hence, by induction hypothesis, rep 2 r ( x ) ∈ S 2 r . This means, x is a child of an element in S 2 r , and the condition of the for loop in line 8 holds. As further d ( p, x ) ≤ γr by assumption, x is added to S r in line 10.

Next, we bound the size of set S r in Lemma A.4.

Lemma A.4. Let r ∈ R . Then, set S r computed in FindNeighbours ( p, γ ) is of size γ dim 2 O (dim) .

Proof. The condition in Line 9 of FindNeighbours implies that any point x ∈ S r is within distance γ · r of p . Hence, S r is covered by Ball( p, γ · r ) . Besides, S r ⊆ N r , which means that the distance between any two points in S r is more than r . By applying the definition of doubling dimension, it

follows that Ball( p, γ · r ) can be covered by γ dim · 2 O (dim) balls of radius r/ 2 . Adding it to S r ⊆ N r implies that each of these balls of radius r/ 2 contains at most one point from S r . Therefore, S r is of size γ dim · 2 O (dim) .

Lemma A.5. Let p ∈ P and γ ≥ 2 be given. Then, the procedure FindNeighbours ( p, γ ) runs in time 2 O (dim) γ dim log ∆ .

Proof. The while loop in Line 4 iterates backward through all the O (log ∆) levels. On every level, all children of all s ∈ S 2 r are examined. By Lemma A.4, | S 2 r | ∈ γ dim 2 O (dim) and by Lemma A.1, every s ∈ | S 2 r | has 2 2 dim children. Multiplying these terms yields the claim.

A.2 Insertion

In this section, we show how to maintain our data structure after the insertion of point p . As described in Algorithm 2, we start by calling FindNeighbours, which goes through the levels from top to bottom (high to low) and recursively computes set S r for each level r . Lemma A.3 implies that for any point q ∈ N r , if d ( p, q ) ≤ r , then S r contains q . This guarantees that later we can find all parents and children of p using these S r sets. Next, we go through the levels from bottom to top to find the lowest level ˆ r , in which we can find a representative for p , or in other words, there is a q ∈ N ˆ r within distance ˆ r of p . Then, we add p to all levels lower than ˆ r . For levels r > ˆ r , we do not need to add p to N r because there is already a point in level r that can represent p by the definition of ˆ r . We determine this representative recursively according to rep ˆ r ( p ) . Finally, we increase the weight for the respective representative of p in each level by one.

Algorithm 2: INSERT ( p )

After inserting the point p to N εr , we need to compute B 1 p,r and B 3 p,r . Besides, for any point q ∈ B 1 p,r ( q ∈ B 3 p,r similarly), we need to add p to B 1 q,r ( B 3 q,r similarly). We perform this operation

Procedure UPDATENEIGHBOURHOODADD( p , ˆ r ): a procedure to update neighbourhoods after adding p to all levels below N ˆ r

in Procedure UpdateNeighbourhoodAdd. In Lemma A.6, we analyze the correctness and update time of this procedure.

Lemma A.6. Let p be a point to be inserted and ˆ r as in the algorithm after execution of the while loop in Line 5. Then, UPDATENEIGHBOURHOODADD ( p, ˆ r ) that we invoke in Line 18 of Algorithm 2, finds B 1 p,r and B 3 p,r for any r ∈ R such that εr < ˆ r . Besides, the total update time of this procedure is 2 O (dim) ε -dim log ∆ .

Proof. By Lemma A.3, T r ′ contains all points of N r ′ within distance (3 + 8 ε ) r ′ /ε of p . Then if we define r := r ′ /ε , it holds that T r ′ contains all points of N εr within distance (3+8 ε ) r ′ /ε = (3+8 ε ) r of p . This means that we can find B 3 p,r by exploring T r ′ , which we do in Line 8 of the procedure. By restricting to points q in T r ′ such that d ( p, q ) ≤ (1 + 4 ε ) r , we find all the points that belong to B 1 p,r .

We next discuss the running time. Lemma A.5 states that the running time of FindNeighbours ( p, (3 + 8 ε ) /ε ) is 2 O (dim) ε -dim log ∆ . Then, we iterate over T r ′ for at most O (log ∆) values of r ′ , which takes O ( | T r ′ | ) for each iteration. Lemma A.4 shows that T r ′ is of size ((3 + 8 ε ) /ε ) dim 2 O (dim) = 2 O (dim) ε -dim . Therefore, the total running time of these O (log ∆) iterations is also 2 O (dim) ε -dim log ∆ , which finishes the proof.

Updating the heaps. To avoid redundancy, we do not include updating Heaps H r in the pseudocodes. However, it can be easily handled. Note that neighborhoods B 1 x,r and B 1 y,r are balls of the same size. Therefore, y ∈ B 1 x,r is equivalent to x ∈ B 1 y,r . Hence, whenever the weight of a point x in N r is changed, it is enough to update the weight of all points in B 1 x,r and their corresponding element in heap H r . The size of B 1 x,r is 2 O (dim) ε -dim by Lemma 2.2, and we can do each heap update in O (log n ) time. Therefore, an extra 2 O (dim) ε -dim log n factor will be multiplied by the running time of Algorithm 2 due to maintaining the heaps.

Lemma A.7. Let n be the size of point set P t . Then after insertion of any point to P t , we can update our data structure in time 2 O (dim) ε -2 dim log ∆ log n .

Proof. As we discussed above, a 2 O (dim) ε -dim log n factor will be multiplied by the running time of Algorithm 2 due to maintaining the heaps. Therefore, it is enough to show that the running time of Algorithm 2 is 2 O (dim) ε -dim log ∆ .

In Algorithm 2, we first call FindNeighbours ( p, 2) , which takes 2 O (dim) log ∆ according to Lemma A.5. To find ˆ r , we next iterate over S r for at most O (log ∆) values of r . Then, we add p to all levels lower than ˆ r , which takes time log ∆ . We next invoke UpdateNeighbourhoodAdd ( p, ˆ r ) , which is done in time 2 O (dim) ε -dim log ∆ according to Lemma A.6. This takes 2 O (dim) log ∆ , since S r is of size 2 O (dim) by Lemma A.4. Finally, we update the representatives of p and their weights, which is done in time O (log ∆) . Putting everything together proves that the running time of Algorithm 2 is 2 O (dim) ε -dim log ∆ , which finishes the proof.

A.3 Deletion

In this section, we explain how to maintain our data structure after the deletion of point p . As described in Algorithm 3, we first produce sets S r and T r for all r ∈ R that are used for updating parents and children as well as neighborhoods. We then iterate over the levels r ∈ R from bottom to top. During the algorithm, we may elevate some points from N r/ 2 \ N r to N r to maintain our data structure. We refer to the set of these points that are elevated to N r as E r . After changing the representative of a point, we need to change the weights of its previous representative in the next level as well as the indirect previous representatives in the upper levels. To make this process of updating weights efficient, we define the set D r and a function δ r : D r → Z for each r ∈ R . The set D r refers to the set of points q ∈ N r whose weight should be updated by the value δ r [ q ] .

After deleting p , we need to find a new representative for any point q ∈ N r/ 2 and also reduce w r/ 2 ( q ) from its previous indirect representatives in the upper levels. To do this, we decrease δ 2 r [ rep 2 r ( p )] by w r/ 2 ( q ) . After deleting p from N r , any point q ∈ N r/ 2 that was represented by p in N r would not have any representative. Besides, we need to find a representative in N r for the points in E r/ 2 . Let q ∈ N r/ 2 be a point such that rep r ( q ) = p or q ∈ E r/ 2 . To find a new representative for q in N r , we consider two cases: either q has a parent in N r \ { p } or p is the only parent of q in N r .

For the first case, we choose a parent x ∈ N r \{ p } of q as its representative in N r . Then, we increase w r ( x ) and δ 2 r [ rep 2 r ( x )] by w r/ 2 ( q ) to update the weight of all points that represent q in higher levels directly or indirectly. For the second case, we have to elevate q to N r . After elevating q to N r , we need to find its parents and children. To find the children, it is enough to explore S r/ 2 . It is because if s ∈ N r/ 2 is a child of q ∈ N r , then d ( q, s ) ≤ r . Adding it to d ( p, q ) ≤ r , we have d ( p, s ) ≤ 2 r = 4( r/ 2) by triangle inequality. Therefore, s ∈ S r/ 2 and it is enough to explore S r/ 2 . With a similar argument, it is enough to explore S 2 r to find the parents of q in N 2 r .

We next call UpdateNeighbourhoodElevate ( q, r, T r ) . In Lemma A.9, we show that this procedure can compute B 1 q,r/ε and B 3 q,r/ε by exploring T r .

At the end of each iteration, we call UPDATENEIGHBOURHOODREMOVE ( p, r ) . This procedure deletes p from all the neighborhoods of level r that contain p . Note that for i ∈ { 1 , 3 } , p ∈ B i x,r and x ∈ B i p,r are equivalent. Hence, it is enough to iterate over all x ∈ B i p,r and delete p from B i x,r for i = { 1 , 3 } .

To show that UpdateNeighbourhoodElevate computes the neighborhoods in Lemma A.9, we first prove Lemma A.8, which is about the distance of the points in E r to p .

Lemma A.8. Let r ∈ R , and let E r be the set of elevated points in Algorithm 3. Then, for any point q ∈ E r we have d ( p, q ) ≤ r .

Proof. Let ˆ r be the smallest level in R such that q is elevated to it. It means that q is a child of p ∈ N ˆ r , and therefore, d ( p, q ) ≤ ˆ r . Besides, we have ˆ r ≤ r , which implies d ( p, q ) ≤ r .

We next call UPDATENEIGHBOURHOODELEVATE to create B 1 q,r and B 3 q,r , as well as to add q to the neighborhoods in level r that must contain q .

Lemma A.9. Let r ′ ∈ R , q ∈ E r ′ and T r ′ as constructed in Line 3 of Algorithm 3. We define r := r ′ /ε . The procedure UpdateNeighbourhoodElevate ( q, r ′ , T r ′ ) computes B 1 q,r and B 3 q,r and updates the neighborhoods B 1 q ′ ,r (and B 3 q ′ ,r ) for all q ′ ∈ B 1 q,r ( q ′ ∈ B 3 q,r ) by adding q to them. Besides, this procedure runs in time O ( ε -dim 2 O (dim) ) .

Proof. Let p be the point to be deleted when calling Algorithm 3. q ∈ E r ′ implies that either p was the representative of q in N r ′ , or q ∈ E r ′ / 2 . If p was the representative of q in N r ′ , we have d ( p, q ) ≤ r ′ . Otherwise, if q ∈ E r ′ / 2 , Lemma A.8 states that d ( p, q ) ≤ r ′ / 2 ≤ r ′ . Therefore, d ( p, q ) ≤ r ′ always holds. By Lemma A.3, T r ′ contains all points x ∈ N r ′ such that d ( p, x ) ≤ (1 + (3 + 8 ε ) /ε ) r ′ = r ′ +(3 + 8 ε ) r , for r = r ′ /ε . Let q ′ ∈ N r ′ be a point such that d ( q, q ′ ) ≤ (3 + 8 ε ) r . We claim that we add q ′ to B 3 q,r . To do this, it is enough to show that q ′ ∈ T r ′ . As we mentioned, d ( p, q ) ≤ r ′ and d ( q, q ′ ) ≤ (3 + 8 ε ) r . Then by the triangle inequality we have d ( p, q ′ ) ≤ d ( p, q ) + d ( q, q ′ ) ≤ r ′ +(3+8 ε ) r , which means that q ′ ∈ T r ′ and it is enough to explore T r ′ for computing B 3 q,r . Note that the same argument also works for B 1 q,r .

Algorithm 3: DELETE ( p )

Further, B 3 q,r (and B 1 q,r ) contains all points whose neighborhoods need to be updated to include q . The procedure iterates through all q ′ ∈ T r ′ , so the running time is O ( | T r ′ | ) = O ( ε -dim 2 O (dim) ) .

Procedure UPDATEWEIGHT( D , δ , q , ω )

Procedure UPDATENEIGHBOURHOODELEVATE( q , r ′ , T r ′ ): a procedure to update neighbourhoods after adding q to N r ′

Procedure UPDATENEIGHBOURHOODREMOVE( p , r ′ ): a procedure to update neighbourhoods after removing p from N r ′

To prove the update time of Algorithm 3, we first prove Lemma A.10 and Lemma A.11.

Lemma A.10. Let r ∈ R . Then, the set E r in Algorithm 3 is of size 2 O (dim) .

Proof. Lemma A.8 states that d ( p, q ) ≤ r holds for any q ∈ E r . Moreover, E r ⊆ N r , which implies that the distance between any two points in E r is more than r by the definition of N r . Therefore, the definition of doubling dimension implies that | E r | ≤ 2 O (dim) .

Lemma A.11. Let r ∈ R . Then the set D r in Algorithm 3 is of size 2 O (dim) .

Proof. To prove the lemma, we first claim that for any r ∈ R , if y ∈ D r , then d ( p, y ) ≤ 2 r . We prove the claim by induction on r . For the base case, we consider r = β . Since D β = ∅ , the claim trivially holds for r = β . Now, we show that if the claim holds for r ∈ R , then it also holds for 2 r . Let v be a point in D 2 r . Then, v is added to D 2 r in one of the Lines 13, 17, or 22 of Algorithm 3. If it is added in Line 13, it means that there is a point q ∈ D r , such that v = rep 2 r ( q ) . By the induction hypothesis, we have d ( p, q ) ≤ 2 r . Besides, we know that

d ( q, v ) = d ( q, rep 2 r ( q )) ≤ 2 r . Hence, d ( p, v ) ≤ 4 r = 2(2 r ) holds by the triangle inequality. If v is added to D 2 r in Line 17, we have v = rep 2 r ( p ) , and we know that d ( p, rep 2 r ( p )) ≤ 2 r . Therefore, d ( p, v ) = d ( p, rep 2 r ( p )) ≤ 2 r ≤ 2(2 r ) . Finally, we consider the case that v is added to D 2 r in Line 22. In this case, v = rep 2 r ( x ) for a point x ∈ N r , and x = rep r ( q ) for a point q ∈ N r/ 2 such that either q was a child of p or q ∈ E r/ 2 . If q was a child of p , then d ( p, q ) ≤ r , and if q ∈ E r/ 2 , then d ( p, q ) ≤ r/ 2 ≤ r by Lemma A.8. Therefore, d ( p, q ) ≤ r always holds. Besides, d ( q, x ) ≤ r , as x is a parent of q . Moreover, we have d ( x, rep 2 r ( x )) ≤ 2 r . Putting everything together we have

Thus, our claim holds.

In addition, D r ⊆ N r , which means that the distance between any two points in D r is more than r . Adding this to the claim, the definition of doubling dimension implies that D r is of size 2 O (dim) .

Now, we can discuss the update time for maintaining our data structure after each deletion.

Lemma A.12. Let n be the size of the point set P t . Then after deletion of any point from P t , we can update our data structure in time 2 O (dim) ε -2 dim log ∆ log n .

Proof. As we discussed in Section A.2, to maintain the heaps, a 2 O (dim) ε -dim log n factor will be multiplied by the running time of Algorithm 3. Hence, it is enough to show that the running time of Algorithm 3 is 2 O (dim) ε -dim log ∆ .

In Algorithm 3, we first call FindNeighbours for γ = 4 and γ = 1 + (3 + 8 ε ) /ε to find sets S r and T r , which take time 2 O (dim) log ∆ and 2 O (dim) ε -dim log ∆ , respectively, according to Lemma A.5.

We next iterate over O (log ∆) levels and in each level, we iterate over some children of p and the elevated points E r/ 2 , and then we call UpdateNeighbourhoodRemove, which takes O ( | B 3 p,r | + | B 1 p,r | ) = O (2 O (dim) ε -dim ) . The number of p 's children and the elevated points are 2 O (dim) by Lemma A.2 and Lemma A.10, respectively. Thus, we iterate over 2 O (dim) points in each level, and in each iteration, all the operations other than UpdateNeighbourhoodElevate can be done in time 2 O (dim) . Besides, the running time of UpdateNeighbourhoodElevate is O ( | T r ′ | ) = O (2 O (dim) ε -dim ) . Hence, the total running time of the iteration over the O (log ∆) levels is O (2 O (dim) ε -dim log ∆) .

Proof of Lemma 2.3 Now, adding Lemma A.7 and Lemma A.12 together, finishes the proof of Lemma 2.3, which is about the update time of our data structure.

Lemma 2.3. Let n be the size of point set P t . Then after insertion/deletion of any point to P t , we can update our data structure in time 2 O (dim) ε -2 dim log ∆ log n .

B Omitted Proofs

Lemma 2.1. Let p ∈ P t and r ∈ R . Then d ( p, rep r ( p )) ≤ 2 r . In particular, d ( p, rep εr ( p )) ≤ 2 εr , where ε = 2 ⌊ log ε ′ ⌋ for the error parameter ε ′ .

Proof. Let r ′ ∈ R . As N 2 r ′ is a 2 r ′ -net of N r ′ , we know that d ( rep r ′ ( p ) , rep 2 r ′ ( rep r ′ ( p ))) ≤ 2 r ′ . Further, by definition, rep 2 r ′ ( p ) = rep 2 r ′ ( rep r ′ ( p )) and hence, d ( rep r ′ ( p ) , rep 2 r ′ ( p )) ≤ 2 r ′ . Thus,

For r ′ = εr , we make a case distinction. If εr ≥ β , then εr ∈ R and hence d ( p, rep εr ( p )) ≤ 2 εr by Equation (1). If εr < β , then d ( p, rep εr ( p )) = 0 ≤ 2 εr because rep εr ( p ) = p by definition.

Lemma 2.2. Let r ∈ R and p ∈ N εr . The sets B 1 p,r and B 3 p,r defined above are of size at most 2 O (dim) ε dim . In particular, the size is O ( ε -dim ) for a constant doubling dimension dim .

Proof. By recursively applying the definition of doubling dimension i times, we can cover a ball of radius (3 + 8 ε ) r with at most 2 i dim balls of radius (3+8 ε ) r 2 i . For i = ⌈ log 3+8 ε ε/ 2 ⌉ it follows that B 3 p,r can be covered by (2 · 3+8 ε ε/ 2 ) dim ∈ 2 O (dim) ε dim balls of radius εr 2 . As B 3 p,r ⊆ N εr , the distance between any pair of points in B 3 p,r is at least εr . Therefore, each of the εr 2 -balls contains at most one point, which finishes the proof.

Lemma 3.1. Let k be an integer, 0 ≤ i ≤ k , and r ∈ R . After the i -th iteration of the loop in Line 3, H r [ y ] is the total weight of unmarked points in B 1 y,r for each y ∈ N εr . More formally, H r [ y ] = w εr ( B 1 y,r ∩ U i ) for any y ∈ N εr after the i -th iteration.

Proof. Let H i r denote the state of the heap and M i the set Marked at the end of iteration i , and H 0 r and M 0 denote the respective sets before entering the for-loop. It can easily be seen that M i = ∪ j ≤ i B 3 c j ,r for every i ≤ k by a simple induction. Initially, M 0 = ∅ = ∪ j ≤ 0 B 3 c j ,r . Now assume M i -1 = ∪ j ≤ i -1 B 3 c j ,r for some i < k . Noting that M i -1 is only updated in line 7 of MAXCOVERAGE ( k, r ) , Lines 6 and 7 imply that all points from B 3 c i ,r that are not in M i -1 yet are added to M i -1 . Therefore, M i = M i -1 ∪ B 3 c i ,r = ∪ j ≤ i B 3 c j ,r . Recall that U i = N εr \ ∪ j ≤ i B 3 c j ,r . This directly implies that U i corresponds to the set of points that are still unmarked at the end of iteration i , that is U i = N εr \ M i . From this, it also immediately follows that U i = U i -1 \ B 3 c i ,r .

Now we can show H i r [ x ] = w εr ( B 1 x,r ∩ U i ) for all i ≤ k . For i = 0 , the heap is not modified and no points are covered yet, i.e. H 0 r [ x ] = w εr ( B 1 x,r ) and U 0 = N εr . Now assume H i -1 r [ x ] = w εr ( B 1 x,r ∩ U i -1 ) for some i < k . Lines 6 to 9 in MAXCOVERAGE ( k, r ) are equivalent to

Neighborhood membership is a symmetric relation in the following sense. If x ∈ N εr is contained within the local neighborhood of y ∈ N εr , then the converse is also true: For every x, y ∈ N εr such that x ∈ B y,r it also holds y ∈ B x,r . Therefore, Equation (2) is equivalent to

which means that during iteration i , the heap value of x ∈ N εr is reduced by w εr ( B 3 c i ,r ∩ B 1 x,r \ M i -1 ) . Because of the equality B 3 c i ,r ∩ B 1 x,r \ M i -1 = B 3 c i ,r ∩ B 1 x,r ∩ U i -1 , we can deduce

where (3) follows from the fact that w εr ( X \ Y ) = w εr ( X ) -w εr ( Y ) for Y ⊆ X ⊆ N εr .

Lemma 3.6. Let OPT > 0 be the optimal radius for the k -center clustering of P t with z outliers, and let r ∗ be the minimum number in R such that r ∗ ≥ OPT . Then FINDCENTERS ( k, z ) returns a (3 + 10 ε ) ρ -approximate solution for k -center clustering problem with z outliers, where ρ = r ∗ OPT .

Proof. Wefirst show that ˆ r ≤ r ∗ . To do this, we consider two cases: ˆ r > 2 or ˆ r ≤ 2 . For the first case, it holds that the outliersWeight returned by MAXCOVERAGE ( k, ˆ r/ 2) is more than z , and then we can conduct that OPT > ˆ r/ 2 . It is because otherwise, MAXCOVERAGE ( k, ˆ r/ 2) . outliersWeight would be less than z by Lemma 3.5, which is a contradiction. It means that r ∗ > ˆ r/ 2 , and then according to the definition of R and r ∗ we have r ∗ ≥ ˆ r . Now we consider the second case that ˆ r ≤ 2 . Since OPT > 0 , we have OPT ≥ d min = 2 . Adding it to OPT ≤ r ∗ , which is an assumption of this lemma, we have ˆ r ≤ 2 ≤ OPT ≤ r ∗ . Thus ˆ r ≤ r ∗ holds in both cases.

Due to Lemma 3.2 and Lemma 3.5, MAXCOVERAGE ( k, ˆ r ) returned by FINDCENTERS ( k, z ) is a set of k centers such that all but at most z points in P t are within distance (3 + 10 ε )ˆ r of these centers. Hence, FINDCENTERS ( k, z ) returns a (3+10 ε )ˆ r OPT -approximation solution. We also showed that ˆ r ≤ r ∗ , therefore, the approximation ratio is at most (3 + 10 ε ) ρ , where ρ = r ∗ OPT .

Lemma 3.7. Let OPT > 0 , and let ε > 0 be fixed. We define m := ⌈ 1 / log 2 (1 + ε ) ⌉ . Suppose we have m parallel instances of our data structure with parameter β = 2 i/m -1 for the i -th instance. Then in at least one of the instances, we find a (3 + O ( ε )) -approximation solution for k -center clustering with z outliers by calling FINDCENTERS ( k, z ) .

Proof. Since we assume OPT > 0 , then we have OPT ≥ d min = 2 . Let j ∗ ∈ [1 , ⌈ log ∆ ⌉ ] be such that 2 j ∗ -1 < OPT ≤ 2 j ∗ , and let i ∗ ∈ [1 , m ] be such that 2 j ∗ -1+( i ∗ -1) /m < OPT ≤ 2 j ∗ -1+ i ∗ /m . For the instance with parameter β = 2 i ∗ /m -1 , we have β · 2 j ∗ = 2 j ∗ -1+ i ∗ /m ∈ R . Therefore by Lemma 3.6, FINDCENTERS ( k, z ) returns a (3 + 10 ε ) ρ ∗ -approximation solution, where ρ ∗ = 2 j ∗ -1+ i ∗ /m /OPT . To finish the proof of Lemma, we show that ρ ∗ ≤ (1 + ε ) , which immediately implies a (3 + O ( ε )) -approximation solution. According to the definition of i ∗ we have ρ ∗ = 2 j ∗ -1+ i ∗ /m /OPT ≤ 2 j ∗ -1+ i ∗ /m / 2 j ∗ -1+( i ∗ -1) /m = 2 1 /m . Besides, m ≥ 1 / log 2 (1 + ε ) holds by the definition for of m , which means 1 /m ≤ log 2 (1 + ε ) . Therefore, 2 1 /m ≤ (1 + ε ) , and then we have ρ ∗ ≤ 2 1 /m ≤ (1 + ε ) , which finishes the proof.

Lemma 3.8. Let u be the number of times that MAXCOVERAGE ( k, r ) updates heap H . Then copying heap H r in Line 2, as well as all these u updates, can be handled in total time O ( u log n ) .

Proof. Procedure MAXCOVERAGE ( k, r ) sets H as a copy of H r , and then it decreases the value of some keys in H during the algorithm. Note that it never inserts or deletes a new key to H , and the only possible update is decreasing the value of a key. We claim that it is not necessary to really copy the heap H r , which takes O ( | H r | ) = O ( n ) time. Instead, we apply all the updates on H r and then undo them at the end of MAXCOVERAGE ( k, r ) . Although the procedure can change H r as we defined, we guarantee that H r is the same at the start and end of the procedure. To do this, we keep a record of all u updates, and at end of MAXCOVERAGE ( k, r ) , we undo all these u updates, which means increasing the value of each updated key with the decreased value. Since the number of updates is u , then we can do all the reverse updates in O ( u log | H r | ) = O ( u log n ) .

Lemma 3.9. Let k and z be two given parameters. Then FINDCENTERS ( k, z ) described in Algorithm 1 has a time complexity of 2 O (dim) ε -2 dim k log n log log ∆ .

Proof. FINDCENTERS ( k, z ) perform a binary-search on R and in each search, it invokes MAXCOVERAGE two times. Therefore, MAXCOVERAGE is called O (log | R | ) times in total, which is O (log log ∆) as | R | = O (log ∆) . Hence, it remains to show that the running time of MAXCOVERAGE ( k, r ) is 2 O (dim) ε -2 dim k log n .

Now, we discuss the running time of MAXCOVERAGE ( k, r ) . This procedure consists of k iterations, in which we iterate on all elements y ∈ B 3 c i ,r . Recall that Lemma 2.2 states B 3 c i ,r is of size at most 2 O (dim) ε dim . Then for any y , we iterate on all elements x ∈ B 1 y,r and update H [ x ] in Line 9. Again by Lemma 2.2, the size of B 1 y,r is at most 2 O (dim) ε dim . Therefore, we update heap H at most ( 2 O (dim) ε dim ) 2 · k times. Then by Lemma 3.8, these heap updates and also copying heap H r in Line 2 are done in total time of 2 O (dim) ε -2 dim k log n .

Proof of Theorem 1.1.

Theorem 1.1. Let ( M,d ) be a metric space of bounded doubling dimension dim , and let ε > 0 be an error parameter. There exists a deterministic dynamic algorithm that allows the insertion or deletion of points from M using worst-case ε -O (dim) log n log ∆ update time. Moreover, at any time t , it can be queried by parameters k and z to compute a (3 + ε ) -approximate solution for the k -center problem with z outliers of P t using worst-case ε -O (dim) k log n log log ∆ query time, where P t is the set of points that are inserted but not deleted up to time t , and n is the size of P t .

Proof. Wemaintain m = ⌈ 1 / log 2 (1+ ε ) ⌉ instances of our data structure with parameter β = 2 i/m -1 for the i -th instance. We first discuss the approximation ratio. If OPT > 0 , then we find a (3 + O ( ε )) -approximation solution by Lemma 3.7. Otherwise if OPT = 0 , then by Lemma 3.5, the outliersWeight returned by MAXCOVERAGE ( k, 0) is at most z . In this case, we return a solution with radius 0 in Line 2, which is an exact solution.

Now we discuss the update time. If we maintain m = O (1 / log(1+ ε )) instances of our data structure in parallel, it incurs an O (1 / log(1 + ε )) = O ( ε -1 ) factor in the time complexity. In each instance, the update time per insert/delete is 2 O (dim) ε -2 dim log ∆ log n by Lemma 2.3, and the k centers can be computed in time O (2 O (dim) ε -2 dim k log n log log ∆) by Lemma 3.9 Therefore, we handle each insert/delete in 2 O (dim) ε -(2 dim +1) log ∆ log n = ε -O (dim) log n log ∆ total time and we can find the centers in O (2 O (dim) ε -(2 dim)+1 k log n log log ∆) = ε -O (dim) k log n log log ∆ total time.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper studies dynamic algorithms for k-center with outliers in a general metric space with bounded doubling dimension, denoted as dim. In the k-center with z outliers problem (which they call (k, z)-center problem), the goal is to find a set of k points C, such that the maximum distance from the data points to the center set is minimized, where the maximization is taken only over the n - z closest data points to C. In terms of the dynamic model, the paper assumes oracle access to the distance function, subject to point insertion and deletions. The query is to return a list of approximate centers, which is of size (at most) k.\n\nThe main result is a dynamic algorithm that can handle each update in time eps^{-dim} log n, which is independent of k, and can report a (3 + eps)-approx solution in eps^{-dim} k log n time. The running time is completely independent of z, and for the query in linear in k which improves the (k + z)^2 query time from previous works significantly.\n\nThe techniques are based on previous navigating net/cover tree structures. However, nontrivial steps are employed to obtain the improved bounds.\n\nSTRENGTHS:\n- The result is strong. In particular, the running times are independent of z, and the query time is only linear in k which improves over (k + z)^2 as in previous works. I find this improvement significant.\n- The comprehensive comparison to various recent works helps a lot in gauging the novelty of this work.\n- Technically, although the approach is not novel in terms of overall framework, to fit ideas from several different works together is a nontrivial task, and I find it interesting.\n\nWEAKNESSES:\n- The setting of doubling metrics is only partially motivated. Indeed, Bateni et al. [1] showed \\Omega(k) is necessary for handling updates in general metrics, but what about the dependence in z? It seems removing the dependence in z in general metrics is still an important goal of study?\n- There is no empirical evaluation of your algorithm, which may be important for some in the NeurIPS community.\n- I don't find a statement of the main theorem. A rigorous statement may be helpful for people who would like to cite/use your paper without going too much into detail. Also, this makes it somewhat difficult to read your proofs, since it's easy to get lost in the series of lemmas and I don't see the big picture.\n- The presentation is not very friendly for non-experts. People without sufficient background in doubling metrics and k-center clustering may find it difficult to understand the paper. I personally only manage to check part of the proofs, although I think it overall makes sense.\n\nQUESTIONS:\n- Table 1, line 2, eps^d -> eps^{-d}. Also line 1 is using 1 / eps, which is inconsistent with eps^{-d} style.\n-  Page 2, line 57: I agree that wlog you can assume d_\\min = 2 if it is the static setting, where P is given. However, in the dynamic setting, the aspect ratio and/or d_min could change very significantly. Do you assume the d_min is always = 2, and that the aspect ratio is always bounded, at any time step?\n- Did you define doubling dimension at all? Also, in line 175, you mentioned it has 2^{O(dim)} children. This is probably standard, but it still requires some explanation, or at least requires a reference.\n- In sec 2 you defined a data structure. It would be helpful to state what updates/queries it supports and what's the guarantee in e.g. a lemma statement.\n- The \"Overview\" of Sec 3 seems too detailed and without a big picture. For example, it starts with a discussion of what we do for the heaps, but did not explain what's the overall purpose of this MaxCoeverage procedure.\n\nLIMITATIONS:\nI don't find a clear discussion these. But I suppose there is no potential negative societal impact.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-02"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe main contribution of this paper is the proposal of a new approximate algorithm for \"fully dynamic k center with outliers\" problem in metric space with low doubling dimension. The approximation ratio is 3+$\\epsilon$. The meaning of \"fully dynamic\" is that the algorithm should be able to efficiently adjust its output to accommodate new data when deletion or insertion operations are performed on the dataset. To achieve this goal, we need to maintain a data structure to handle the addition and deletion of data, and to efficiently provide an approximate solution for the k center with outliers problem at any time. According to this paper,  the time complexity of query (given the data structure has been established, to generate a solution for the k center with outliers problem) is $\\epsilon ^{-O(\\mathtt{dim})}k \\log n \\log \\log \\Delta$, where $\\Delta$ is the ratio between the maximum and minimum distance between two points in  dataset, $\\mathtt{dim}$ is the doubling dimension of the metric space. And the time complexity of insertion/deletion  is $\\epsilon ^{-O(\\mathtt{dim})}\\log n \\log \\Delta$.\n\nSTRENGTHS:\n1. Faster binary search for a specific problem. The \"Query\" algorithm in the paper essentially uses binary search to find the appropriate clustering radius, for example, by searching within the interval $[0, \\Delta]$. This step usually takes $O(\\log \\Delta)$ time, but the technique used in this paper can reduce this complexity to $O(\\log \\log \\Delta)$. This technique appears to be applicable for solving some problems other than the k center with outliers problem.\n2. Lower time complexity in some cases.  The time complexity of addition/deletion operation is independent of the number of cluster centers k and the number of outliers z in the data. And the time complexity of querying is linearly related to the k. This fact gives the algorithm proposed in this paper a significant advantage in terms of running time when k or z is very large.\n\n3. State-of-the-art approximation ratio. The approximation ratio of this algorithm achieves the current state-of-the-art results ($3+\\epsilon$).\n\nWEAKNESSES:\n1. Time complexity. Table 2 in this paper presents a comparison of the time complexity of the proposed algorithm with some existing algorithms for solving the dynamic k center with outliers problem. The table reveals that the previous works (such as [3, 16, 7] in the references) have update and query time complexities that are independent of n, whereas the proposed algorithm has a linear dependence on log n for both update and query. As a result, the proposed algorithm may have slower running times when n is large and k and z are relatively small. \n2. Complex data structures. The algorithm in the text uses relatively complex data structures, which may not be conducive to the implementation of the algorithm and the final actual running time. I am wondering about the space complexity.\n\nQUESTIONS:\n1. Line 148, \"We utilize $\\beta$ to define $R:=\\{0\\}\\cup \\{\\beta \\cdot 2^l | 0 \\le l \\le \\lceil \\log _2 \\Delta \\rceil \\}$ as the set of levels.\".  Does '$l$' have any restrictions here? I guess '$l$' should only take integers? Otherwise, if '$l$' is a real number in this range, the time complexity of Algorithm 1 will be linearly related to $\\log \\Delta$.\n\n2. You mentioned in the paper that the time complexity of Algorithm 1 is linear with respect to $\\log \\log \\Delta$, which is an interesting conclusion because traditional binary search results in time complexity linearly related to log Delta. I noticed that you used some techniques to make this conclusion hold. I wonder if these techniques can be applied to similar binary search scenarios? For example, in [3], the k-center with outliers algorithm based on binary search, can we also obtain a time complexity linearly related to $\\log \\log \\Delta$?\n\nLIMITATIONS:\nThe work is mostly theoretical, and SODA/ICALP/ESA may be better venue for this paper?", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-05"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper presents a new algorithm for fully dynamic $k$-center clustering with outliers in spaces with bounded doubling dimension $dim$ and aspect ratio $\\Delta$, where the number of outliers $z$, can be specified at query time. While the approximation ratio of $3+\\epsilon$ is on par with previous results, it trades a $\\log(n)$ dependencies for a removal of a $k$ factor from update and query time and moving $z$ from the problem parameterization to the query specification. In particular, the update time is $1/\\epsilon^{O(dim)} \\log n \\log \\Delta$, and the query time is $k/\\epsilon^{O(dim)} \\log n \\log \\log \\Delta$. Previous algorithms differ in the query time by at least a factor of $(k+z^2) / log(n)$.\n\nThe algorithm builds on the previous result by Pellizzoni et al. and improves its internal tree-based data structure by augmenting additional information. The tree imposes a hierarchy on the input points and stores, for each representative point of a node, a small and a large neighborhood and a list of child points ordered by the number of their descendants. By maintaining the hierarchy for $\\log \\Delta$ choices of the neighbhorhoods' radius (and the fact that the radius of the neighbhorhood scales linearly with the $k$-center cost), the ordered lists allow to construct a $k$-center solution in-place at node level.\n\nOverall, I think this paper showcases nicely how one self-contained improvement to an existing algorithm can lead to an interesting property like time complexity independet of $z$ and actually moving the specification of $z$ from problem paramters to query arguments. The resulting bounds are nice and are an improvement in the interesting case that $k \\in \\Omega(\\log n)$ or $z$ is a variable.\n\nSTRENGTHS:\n* Update and/or query time improvement over previous results for $k \\in \\Omega(\\log n)$.\n* The algorithm solves the dynamic $k$-center problem with $z$ outliers for all $z$ simulteanously.\n* The time complexities are independent of $z$.\n\nWEAKNESSES:\n* The time complexities are not better for all settings, and the update time on its own is always slightly worse compared to one other existing algorithm.\n\nQUESTIONS:\n-\n\nLIMITATIONS:\n-", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nIn k-center with z outliers problem, the input is a data set X that lies in metric space and the goal is to find a center set C of size k such that the z+1 largest distance from points in X to C is minimized. This paper stuided a dynamic version of this paper where data point can be inserted and deleted but we should output an approximate solution to the problem at any time.\n\nThe main result of this paper is $3+\\epsilon$ approximation dynamic algorithm that supports an $\\epsilon^{-O(\\mathrm{ddim})}\\log n \\log \\Delta$ update time and an $\\epsilon^{-O(\\mathrm{ddim})}k\\log n \\log \\log \\Delta$ where $\\mathrm{ddim}$ is the doubling dimension of metric space, $n=|X|$, and $\\Delta$ is the ratio between the maximum and minimum pariwise distance of $X$.\n\nThis result does not significantly improve previous results. For example, [16] already gave a dynamic algorithm with an $\\epsilon^{-O(\\mathrm{ddim})}\\log \\Delta$ update time, an $\\epsilon^{-O(\\mathrm{ddim})}(k+z)^2\\log \\Delta$ query time, and the same approximation ratio. The new algorithm only trade a $poly(k+z)$ factor with an $\\log n$ in the query time. Authors claimed the work is finished indepdently from [16] while even comparing with a weaker and ealier result [7], the new bounds do not seem to be very strong. \n\nMoreover, I do not see the main technical contributions of this paper after reading the first few pages. Authors introduce a few existing techniques of other papers but skip to technical parts directly. I suggest to add a section named \"Technical Contribution\" to feed the readers with spoons.\n\nSTRENGTHS:\n1. A new algorithm for robust dynamic k-center in doubling metric space.\n\nWEAKNESSES:\n1. The algorithm only achieves similar guarantee, comparing with existing results.\n\nQUESTIONS:\n1. The algorithm seems to build on a few existing techniques and the main technical contributions of this paper are not very clear to me. Can you summary your main technical contributions?\n\nLIMITATIONS:\nI do not see potential negative societal impact.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-07-10"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper consider the $k$-center problem with outliers in the fully dynamic setting (insertions and deletions of points).\n\nThe assumption is that the metric space has bounded doubling dimension (as a side note: some assumption is necessary to get better bounds due to known lower bounds).\n\nThe main result of the paper is to give an algorithm with the following guarantees:\n\n- Worst-case  update time  exp(double-dimension) log n log (Delta)\n- Worst-case query time: exp(double-dimension)  k log n log log Delta\n\nNote that the query time is almost optimal in the sense that $k$ is needed to return $k$ centers.  Independent concurrent work has achieved similar guarantees. In particular, [16] uses similar ideas but pay an k^2 in query time. \nThe idea of this paper and [16] is to use \"Navigating sets\" as previously used. Now an issue is that they don't work off the shelves for the outlier settings. [16] solves this by showing that a certain level forms a coarset and then runs the 3-approximation algorithm Charikar et al. To run this algorithm from scratch incurs a running time overhead. Instead the current paper includes smart information in their datastructrue that avoids running this algorithm from scratch leading to the better running time.\n\nSTRENGTHS:\n- An improvement on a natural problem k-center with outliers in the dynamic setting.\n\n- Close to optimal query time (is the exponential dependency on doubling dimension necessary?)\n\n- Smart algorithmic techniques.\n\nWEAKNESSES:\n- Quite a complex algorithm in the end.\n\n- The improvement is quite specialized: query time for the case of double dimensions. Yes, I know that some restrictions on the input is necessary so cannot complain too much but I do think this decreases the general appeal of the paper.\n\n- Would 2-approximation be possible? This is interesting as the best \"combinatorial\" approximation algorithm for k-center with outliers is 3...\n\nQUESTIONS:\n- What factors in your running times are necessary? Is the exponential dependency on doubling dimension necessary etc?\n\nMinor things: \n\n- line 37 \"which gives\"\n\n- Thm 1.1. shouldn't it be insertions and deletions instead of insertions or deletions?\n\nLIMITATIONS:\n-", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-27"}