# Worst-Case Efficient Dynamic Geometric Independent Set

We consider the problem of maintaining an approximate maximum independent set of geometric objects under insertions and deletions. We present data structures that maintain a constant-factor approximate maximum independent set for broad classes of fat objects in d dimensions, where d is assumed to be a constant, in sublinear worst-case update time. This gives the first results for dynamic independent set in a wide variety of geometric settings, such as disks, fat polygons, and their high-dimensional equivalents. Our result is obtained via a two-level approach. First, we develop a dynamic data structure which stores all objects and provides an approximate independent set when queried, with output-sensitive running time. We show that via standard methods such a structure can be used to obtain a dynamic algorithm with amortized update time bounds. Then, to obtain worst-case update time algorithms, we develop a generic deamortization scheme that with each insertion/deletion keeps (i) the update time bounded and (ii) the number of changes in the independent set constant. We show that such a scheme is applicable to fat objects by showing an appropriate generalization of a separator theorem. Interestingly, we show that our deamortization scheme is also necessary in order to obtain worst-case update bounds: If for a class of objects our scheme is not applicable, then no constant-factor approximation with sublinear worst-case update time is possible. We show that such a lower bound applies even for seemingly simple classes of geometric objects including axis-aligned rectangles in the plane.

## Authors

• 24 publications
• 23 publications
• 8 publications
07/16/2020

### Dynamic Geometric Independent Set

We present fully dynamic approximation algorithms for the Maximum Indepe...
03/14/2021

### More Dynamic Data Structures for Geometric Set Cover with Sublinear Update Time

We study geometric set cover problems in dynamic settings, allowing inse...
10/25/2018

### A Deamortization Approach for Dynamic Spanner and Dynamic Maximal Matching

Many dynamic graph algorithms have an amortized update time, rather than...
03/31/2017

### Optimal Reconstruction with a Small Number of Views

Estimating positions of world points from features observed in images is...
03/19/2019

### Preprocessing Ambiguous Imprecise Points

Let R = {R_1, R_2, ..., R_n} be a set of regions and let X = {x_1, x_2,...
03/05/2020

### Dynamic Approximate Maximum Independent Set of Intervals, Hypercubes and Hyperrectangles

Independent set is a fundamental problem in combinatorial optimization. ...
02/29/2020

### Dynamic geometric set cover and hitting set

We investigate dynamic versions of geometric set cover and hitting set w...
##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Dynamic algorithms for classic NP-hard optimization problems is a quite active research area and major progress has been achieved over the last years (see [34, 1, 10, 12, 11]). For such problems, typically improved performance can be achieved when their geometric versions are considered, i.e., when the input has a certain geometric structure. As a result, a very recent line of research considers dynamic algorithms for well-known algorithmic problems in the geometric setting [3, 37, 13, 26, 21]. In this work, we continue this investigation by considering the geometric version of the Maximum Independent Set problem; some of our results improve upon the previous (very recent) work of Henzinger et al. [37] and Bhore et al. [13] and some others provide the first dynamic data structures for various geometric instances.

#### Static Independent Set.

In the maximum independent set problem, we are given a graph and we aim to produce a subset of maximum cardinality, such that no two vertices in are adjacent. This is one of the most well-studied algorithmic problems. It is well-known to be NP-complete and hard to approximate: no polynomial time algorithm can achieve an approximation factor , for any constant , unless P=NP [49, 36].

#### (Static) Geometric Independent Set.

In the geometric version of the maximum independent set problem, the graph is the intersection graph of a set of geometric objects: each vertex corresponds to an object, and there is an edge between two vertices if and only if the corresponding objects intersect.

Besides the theoretical interest, the study of independent sets of geometric objects such as axis-aligned squares, rectangles or disks has been motivated by applications in various areas such as VLSI design [38], map labeling [4, 48] and data mining [39, 9].

For most classes of geometric objects, the problem remains NP-hard. A notable exception is the case where all objects are intervals on the real line (the well-known interval scheduling problem), where the optimal solution can be computed in polynomial time using a folklore greedy algorithm [32]. However, even the simplest 2d-generalization to axis-aligned unit squares is NP-hard [30]. As a result, most of the related work has focused on developing PTASs for certain versions of geometric independent set. This has been achieved for various types of objects such as squares, hypercubes, fat objects and pseudodisks [38, 29, 19, 20].

A substantially harder setting is the when the geometric objects are arbitrary (axis-aligned) rectangles in the plane: Despite the intense interest (see [2, 25]), no PTAS is known. Until very recently the best known approximation factor was  [17, 18]; in 2021, several -approximation algorithms were claimed [44, 31].

#### Dynamic Geometric Independent Set.

In the dynamic version of geometric independent set, is a class of geometric objects (for instance squares in the plane) and we maintain a set of active objects. Objects of may be inserted in and deleted from over time and the goal is to maintain a maximum independent set111This problem should not be confused by the related, but very different, maximal independent set problem, where the goal is to maintain an inclusionwise maximal independent set subject to updates on the edges (and not the vertices). This problem has been studied in the dynamic setting, with a remarkable recent progress after a sequence of breakthrough results [5, 6, 24, 7]. of , while keeping the time to implement the changes (the update time) sublinear on the size of the input.

#### Previous Work.

Most previous work dates from 2020 onwards. The only exception is the work of Gavruskin et al. [33] who considered the very special case of intervals where no interval is fully contained in any other interval. The study of this area was revitalized by a paper of Henzinger, Neumann and Wiese in SoCG’20 [37]. They presented deterministic dynamic algorithms with approximation ratio for intervals and for -dimensional hypercubes, under the assumption that all objects are contained in and each of their edges has at least unit length. Their update time was polylogarithmic in both and , but could be unbounded in . Furthermore, they showed that no -approximation scheme with sublinear update time is possible, unless the Exponential Time Hypothesis fails (this follows almost directly from a lower bound of Marx [41] for the offline problem).

Subsequently Bhore et al. [13] obtained the first results for dynamic geometric independent set without any assumption on the input. For intervals, they presented a dynamic -approximation with logarithmic update time; this was recently simplified and improved by Compton et al. [26]. For squares, [13] presented a randomized algorithm with expected approximation ratio roughly (generalizing to roughly for -dimensional hypercubes) with amortized update time (generalizing to for hypercubes).

### 1.1 Our results

In this work we obtain the first dynamic algorithms for fat objects (formally defined in Section 5) in fixed dimension with sublinear worst-case update time. The precise bounds on the approximation ratio and the update time depend on the fatness constant and the running time for worst-case range query structures for each family of objects. However, the results follow from a generic approach, applicable to all those classes of objects.

###### Theorem 1.1.

There exists a deterministic data structure for maintaining a -approximate independent set of a collection of fat objects, with sublinear worst-case update time, that reports changes in the independent set per update. In particular, it achieves the following approximation ratios and worst-case update times, for any constant :

• -approximation with update time for axis-aligned squares in the plane.

• -approximation with update time for disks in the plane222Throughout this paper, suppresses polylogarithmic factors..

• -approximation with update time for -dimensional hypercubes.

• -approximation with update time for fat objects which are unions of (hyper)rectangles.

• -approximation with update time for fat simplices in dimensions.

• -approximation with update time for fat objects which are unions of simplices in dimensions.

• -approximation with update time for balls in dimensions.

This result gives the first dynamic algorithms with sublinear update time for all the aforementioned classes of objects, apart from -dimensional hypercubes. Moreover, for hypercubes our result is the first with sublinear worst-case update time bounds without assumptions on the input; it also achieves the same approximation ratio as [37], which is the best known for any dynamic setting.

In fact, it seems hard to significantly improve our result on any aspect: First, for the approximation factor, as mentioned above, Henzinger, Neumann and Wiese [37] proved that (under the Exponential Time Hypothesis) one cannot maintain a -approximate maximum independent set of hypercubes in dimensions with update time for any ; therefore the only potential improvement in the approximation ratio is by small constant factors. Moreover, the update time we obtain is essentially the time required for detecting intersections between objects in a range query data structure333In a previous version of this paper [15, 16], we erroneously claimed a polylogarithmic update time for squares and hypercubes. We withdrew this claim. Reaching polylogarithmic worst-case update time bounds for these objects would require new ideas, distinct from those given in Section 6.. Fatness of the objects is a sensible condition for achieving such results: we prove that for (nonfat) rectangles, ellipses, or arbitrary polygons, no dynamic approximation in sublinear worst-case update time is possible. Finally, we emphasize the remarkable additional property that the number of changes reported per update is always constant.

To obtain the result of Theorem 1.1 we develop a generic method to obtain dynamic independent set algorithms and show how to apply it for fat objects. Our method uses a combination of several components. The first is a data structure which stores all objects, supports insertions and deletions in sublinear time and, when queried, returns a -approximate independent set with output-sensitive running time. The second main component is a generic transformation of such a data structure into a dynamic algorithm with approximation factor and amortized update time . This is done by periodically updating the solution using the data structure. Then, we apply a generic deamortization scheme, involving what we call a MIX function, a generic way to switch “smoothly” from one solution to another. We design such a MIX function for fat objects using geometric separators.

### 1.2 Notation and preliminaries

#### Notation.

In what follows, is a class of geometric objects, such as squares in the plane, and we consider a finite set . A subset of is a maximum independent set (MIS) of if all its objects are pairwise disjoint and it has maximum size over all sets with this property. We use to denote the size of a maximum independent set. We use to denote , unless otherwise specified. We say that is a -approximate MIS if its size is at least , for a constant 444Note that while stating the main result in Theorem 1.1, we used the convention that the approximation ratio is . This is done mainly for aesthetical reasons, making the result easier to parse. From now on, we assume ; it is easy to see that this is equivalent to a data structure achieving a -approximation in the language of Theorem 1.1..

The problem we study is to maintain an approximate MIS set under a sequence of insertions and deletions in , which we call generically an update, starting from an empty set. This can be expressed as implementing a single operation , where is the object to be inserted or deleted, and , the update set, is the set of objects that change in the approximate MIS , presented as the symmetric difference from the previous set. In general we will use subscripts to express variables’ states after the indicated update, and unsubscripted versions for the current state. Using the operator to denote the symmetric difference, we therefore have and . We say that Update is a -approximate MIS algorithm if is always a -approximate MIS of .

#### Comment on the model.

Here, we adopt the convention that the update set is always returned explicitly and thus the running time of an update is at least the size of the returned update set:

###### Fact 1.2.

The running time of performing an update is at least , i.e., the size of the update set.

We proceed with a simple yet crucial observation about MIS.

###### Fact 1.3.

The size of a MIS can change by at most one with every update: .

Note that this fact does not hold for the weighted version of the MIS problem. Also note that this does not say that it is possible to have an update algorithm with an update set with cardinality always at most ; this fact bounds how the size of a MIS can change after an update, and not the content. In fact, it is easy to produce examples where must be 2, even for intervals (e.g. , , ). However, it does leave open the possibility to have an update operation returning constant-size update sets, which is something we will achieve for the classes of geometric objects we consider.

## 2 Overview

Our goal is thus to develop a general method for dynamic approximate MIS that has efficient worst-case running times and small update set sizes for various classes of geometric objects. We identify two ingredients that are needed:

-dynamic independent set query structure (-DISQS):

This an abstract data type for maintaining a set of objects, in which one can insert or delete an object in time , and obtain a -approximate MIS of the current set in output-sensitive time if the set returned has size .

MIX algorithm:

A MIX algorithm receives two independent sets and whose sizes sums to as input, and smoothly transitions from to by adding or removing one element at a time such that at all times the the intermediate sets are an independent sets of size at least . The running time of the MIX algorithm is said to be if the entire computation takes time .

The plan of the paper is as follows.

#### Section 3: Amortized Update Time.

In this section, we prove that the first ingredient, the -DISQS, is sufficient to obtain a -approximate dynamic MIS algorithm with amortized update time for any . This is presented as Theorem 3.2. We note that this is a bit of a “folklore” algorithm that essentially does nothing more than periodically querying the -DISQS.

#### Section 4: Worst-case Update time.

The second ingredient, MIX, is vital to deamortizing: In Section 4, we show that a DISQS and a MIX together are sufficient to produce a data structure which for any constant maintains an approximate MIS of size at least , has a worst-case running time of , and whose Update operation returns a constant-sized update set; this is presented as Theorem 4.3. We also show in that the non-existence of a MIX function implies the impossibility of a approximate MIS data structure with sublinear update set size, hence sublinear worst-case running time, and that this impossibility holds for rectangles and other classes of nonfat objects (Theorem 4.5 and Lemma 4.6).

Given this generic scheme developed, to prove our main result, it remains to show that fat objects have a MIX function and a DISQS, both with sublinear update time. This is the content of Sections 5 and 6.

#### Section 5: Existence of a MIX function for fat objects.

We show in Lemma 5.4 that for fat objects in any constant dimension a MIX algorithm always exists with . This is achieved via geometric separators [47].

#### Section 6: Existence of β-DISQS for fat objects.

Last, we show that obtaining a -DISQS is possible for many types of fat objects using variants of standard range query data structures (kd-trees for orthogonal objects and partition trees for non-orthogonal objects such as disks, triangles or general polyhedra) with the running time matching the query time of such structures. The result is based on a simple greedy algorithm for the MIS problem on fat objects [28, 40], yielding an approximation factor that only depends on the fatness constant.

## 3 Dynamization

In this section we define formally the -dynamic independent set query structure (-DISQS) and show that its existence implies a dynamic independent set algorithm with approximation ratio and sublinear amortized update time.

###### Definition 3.1.

A -dynamic independent set query structure (-DISQS) is a data structure that maintains a set whose size is denoted as and supports the following operations:

• : Insert or remove , so that becomes .

• Query: Returns a -approximate MIS of

We say that the running time of a DISQS is if Update takes time and if Query returns a set of size in time . We require to be sublinear.

#### From β-DISQS to dynamic with amortized update time.

We now show that a -DISQS is sufficient to give a approximate MIS data structure with an amortized running time, with a loss of only in the approximation factor for any . The intuition is simple, pass through the update operations to the DISQS and periodically replace the approximate MIS seen by the user by querying the DISQS. The only subtlety is to immediately remove any items from the approximate MIS that have been deleted in order to keep the approximate MIS valid. This simple transformation is likely folklore, but we work out the details for completeness.

###### Theorem 3.2.

Given a -DISQS with sublinear running time for an independent set problem and , there is a fully dynamic data structure to maintain a -approximate independent set that runs in amortized time per operation.

###### Proof.

We describe the implementation of . Initially set global variables , , and is an empty -DISQS. The sets and are stored in a balanced binary search tree, indexed according to some total order on the objects (for instance lexicographically by the coordinates that define them). The variables here are defined so that after the th Update operation the invariants and hold. Pick such that . It is easy to show that .

We first argue that is an independent set of . This is the case after each rebuild, as the query to the DISQS returns an independent set by definition. Between rebuilds, items are only deleted from , thus will never contain intersecting items. By deleting items from when they are deleted from , this ensures that .

#### Approximation ratio.

We now argue that . To this end we make the following observation.

###### Observation 3.3.

If updates have been performed since the last rebuild, then we have that .

This follows since in each update the size of can shrink by at most 1, which happens only in case is in and must be removed. We have that:

 |I|OPT ≥|Iold|−iOPTold+i Fact 1.3 and Observation 3.3 ≥(1−ϵ′)|Iold|OPTold+ϵ′⋅|Iold| i≤ϵ′⋅|Iold| ≥(1−ϵ′)|Iold|(1+ϵ′)⋅OPTold |Iold|≤OPTold ≥(1−ϵ′)⋅β⋅OPTold(1+ϵ′)⋅OPTold |Iold|≥β⋅OPTold =1−ϵ′1+ϵ′⋅β=(1−ϵ)⋅β. Since 1−ϵ′1+ϵ′=1−ϵ

#### Update time.

Finally, we need to argue that the amortized running time is . If an operation is not a rebuild, the running time is simply for the update in the DISQS and to update the binary search tree containing (and possibly ).

After operations, time is spent with the call to update. Thus the amortized cost per operation for the rebuild is:

 |I|f(n)ϵ′⋅|Iold|≤(|Iold|+i)f(n)ϵ′⋅|Iold|≤(1+ϵ′)|Iold|f(n)ϵ′⋅|I% old|≤(1+ϵ′)ϵ′f(n)

Note that is the current size of the set at the time of the rebuild, but as this can only change by a factor between rebuilds, and is sublinear, this gives an amortized time of for every update . Thus combining the amortized running time for the rebuild with the for the BST operations and for the DISQS update, gives the total amortized running time of . ∎

## 4 Deamortization

In this section we present our deamortization technique. In particular, we describe a procedure, which we call MIX, which if exists, is used to transform a -DISQS into a deterministic dynamic algorithm for with worst-case update time guarantees and update set size bounds. We also show that if a MIX does not exist for an independent set problem, then no sublinear worst-case update time guarantees are possible.

#### MIX function.

We now define our main ingredient for deamortization, which essentially says that we can smoothly switch from one solution to another, by adding or removing one item at a time:

###### Definition 4.1 (MIX function).

Given two solution sets and , let , for be a set where:

• is always a valid solution

• , for some .

• and differ by one item.

Given this purely combinatorial definition, we define a MIX algorithm as follows.

###### Definition 4.2.

A MIX algorithm with running time is a data structure such that

1. It is initialized with , , and it has a single operation Advance which advances and reports the single element in the symmetric difference .

2. The initialization plus calls to Advance run in total time .

#### Organization.

The rest of this section is organized as follows. In 4.1 we show that given a -DISQS and a MIX function for an independent set problem, we can produce a dynamic algorithm with worst-case update time guarantees and approximation ratio arbitrarily close to . In 4.2, we show the necessity of MIX function; in other words, we show that if there does not exist a MIX function for an independent set problem, then no deterministic algorithms with worst-case update time guarantees exist.

### 4.1 Dynamic algorithm with worst-case update time

We now present our main theorem. As we discuss next, the intuition expands upon that for Theorem 3.2, that in addition to periodically using the -DISQS to get a new solution, the MIX slowly transitions between the two previous solutions reported by the -DISQS. Our result is the following.

###### Theorem 4.3.

Given a -DISQS with running time for an independent set problem, a -time MIX algorithm with nondecreasing , and an , there is a fully dynamic data structure to maintain an independent set of size at least . The data structure runs in worst-case time per operation, where is the current number of objects stored, and reports a number of changes in the independent set per update.

#### High-level description.

We saw in the previous section how to obtain an amortized update time algorithm by splitting the update sequence into rounds and query the DISQS at the end of each round to recompute an approximate MIS. Let be the independent set produced by the DISQS at the end of round . At a high-level, the main task is to deamortize the computation of : we can not afford computing it during one step. Instead, we compute gradually during round , making sure that the running time per step is bounded. is eventually computed by the end of round . At this point, we would like to have (discarding elements deleted during round ) as our output independent set; however this can not be done immediately, since might be very different from . For that reason, the switch from to is done gradually using the MIX function during round . After all, our algorithm uses as its independent set at the end of round .

It follows that the independent set reported to the user is a combination of DISQS queries 3 or 2 rounds in the past. We show that by appropriately choosing the lengths of the rounds depending on the sizes of the independent sets, this lag affects the approximation factor by an additive .

###### Proof of Theorem 4.3.

We group the updates into rounds, and use to indicate that is the last update of round . Let be the independent set output by the -DISQS (if queried) at time , i.e., at the end of th round. The length of the th round, is defined to be updates.

For convenience, we define the following functions for any :

 g(ϵ)=1+√1−4ϵ2 h(ϵ)=3−√1−4ϵ2 ϕ(ϵ)=16h2(ϵ)ϵ⋅β⋅g3(ϵ)

Note that and . Note also that and in particular as . Similarly, and as .

#### Our Data Structures and Operations.

Our overall structure contains a -DISQS and a MIX algorithm. We also maintain the current active set of objects and our approximate independent set explicitly in a binary search tree; we refer to simply as and , each stored according to some total order on the objects555Instead of a tree one could use a hash table, which would remove the additive logarithmic term from the update time, at the expense of randomization. However this will not improve our overall result, since functions and are at least logarithmic in our application (see sections 5,6); therefore the logarithm can be absorbed while keeping the result deterministic.. We maintain the invariant that at the beginning of round , the DISQS stores the set of objects . Also, our structure stores and .

To execute update operations in round , the following are performed:

Running MIX slowly:

During round we use MIX to transition from to . This is done by initializing MIX with and and repeatedly running the Advance operation. After each update, we continue running MIX where we left off and continue until either time has passed or if calls to Advance have been performed.

Operation archiving:

All updates are placed into a queue as they arrive. This will ensure that the DISQS will take into account all updates of previous rounds. Moreover, if an update deletes an element of , we wish to report it as being deleted. To do so we set a variable , and otherwise .

Interaction with the DISQS:

During round , we want to use the DISQS in order to compute the set . To do that, we first perform to the DISQS all updates of round one by one and remove them from . This way, DISQS stores the set . Then, we perform a query to the DISQS, to get . In each update of the round time is spent on executing these operations.

Maintaining :

We store in a binary search tree based on some total ordering of the objects. For each update , we search for in and remove it if it is there, and add it if it is not, to maintain .

Output:

After each update, we report the symmetric difference between previous and current independent set to the user. Let be the union of the items returned by the Advance operation of the MIX algorithm during the execution of update . We combine and , and before returning, we remove any items that would result in the insertion into of items that are not in .

We need to argue about (i) correctness, (ii) running time, (iii) approximation ratio and (iv) feasibility of our algorithm, i.e., that during each round the computation of MIX and DISQS have finished before the round ends. Before this, we will first mention some basic properties that will be helpful in the analysis.

#### Basic Properties.

We first mention some basic properties that will be helpful in the analysis. Although the intuition is clear, some of the proofs are long, and we defer them to Appendix A, to keep the proof focused.

Let be the size of the current optimum. First, let us explore the relations between these and in various rounds. We use to denote the current round and to denote an arbitrary round. First, since the DISQS, outputs a -approximate independent set, we have that

 OPTk≥|^Ik|≥βOPTrk. (1)

We proceed with the following claim.

###### Claim 4.4.

For any round , we have that .

Note this implies that , i.e., the optimal cost is changing by a bounded amount between consecutive rounds. Proof is in Appendix A. By the same logic, we get a similar claim on the change of the optimal cost between subsequent rounds. At any time during current round we have that

 gℓ(ϵ)⋅OPTrt−ℓ≤OPT≤hℓ(ϵ)⋅OPTrt−ℓ (2)

As a corollary, we get that at any time during current round ,

 |^It−2|+|^It−3|≤OPTrt−2+OPTrt−3≤OPTg2(ϵ)+OPTg3(ϵ)≤2OPTg3(ϵ). (3)

#### Correctness.

It is easy to see that the algorithm described above always outputs an independent set to the user: During current round , the user always sees for some , with perhaps some items that have been deleted in round or the current round removed. MIX is by definition an independent set at every step as in any subset of it, so the user always sees an independent set.

#### Bound on update set size.

The update set returned is a subset of , as insertions of might be removed if the items are no longer in . The size of is at most by construction; the set contains at most one element. Therefore,

 Δ≤ϕ(ϵ)+1=16h2(ϵ)ϵ⋅β⋅g3(ϵ)+1≤16ϵ⋅β⋅(3/2)2(1/2)3+1=O(1ϵ⋅β)=Oϵ,β(1) (4)

#### Running time.

We now argue about the running time of a single update.

• The running time due to the execution of MIX is

 ϕ(ϵ)⋅γ(|^It−3|+|^It−2|)≤ϕ(ϵ)⋅γ(2OPTg3(ϵ))≤ϕ(ϵ)⋅γ(16⋅n)=Oϵ(γ(n)),

where the first inequality holds due to (3), the second due to and and the equality at the end holds since is sublinear.

• The running time due to the interaction with the DISQS is

 (1+2h(ϵ)β⋅ϵ)f(n)≤4h(ϵ)β⋅ϵ⋅f(n)=Oϵ,β(f(n))
• There are also the operations in the binary search trees holding and , for updating and checking whether objects output by MIX have been deleted. Those operations cost each (as ). The number of such operations is linear in the update set size, which by (4) is . Therefore their total cost is .

Putting everything together: Overall, we get that the total update time is upper bounded by .

#### Approximation ratio.

Now we argue the approximation factor. First, we bound the number of items at any step of MIX during current round :

 |MIX(^It−2,^It−3,j)| ≥min(|^It−2|,|^It−3|)−Γ(|^It−2|+|^It−3|) Defn of MIX ≥min(βOPTi−2,βOPTi−3)−Γ(|^It−2|+|^It−3|) From (1) ≥min(βh2(ϵ)OPT,βh3(ϵ)OPT)−Γ(1g2(ϵ)OPT+1g3(ϵ)OPT) From (2), (3) ≥βh3(ϵ)OPT−Γ(2g3(ϵ)OPT) ≥βh3(ϵ)OPT−o(OPT), Since Γ(n)=o(n)

The items that have been deleted are from the round or the current round, and thus are at most:

 Rt+Rt−1 =max{1,⌊ϵ⋅|^It−2|⌋}+max{1,⌊ϵ⋅|^It−3|⌋}≤ϵ(|^It−2|+|^It−3|)+2 ≤ϵ(1g2(ϵ)OPT+1g3(ϵ)OPT)+2 Due to (3) ≤2ϵg3(ϵ)OPT+2

Combining, the independent set is of size at least

 (βh3(ϵ)−2ϵg3(ϵ))OPT−o(OPT)

For any , by the definition of and , there is an such that . This gives the independent set size as stated in the theorem.

#### Feasibility: MIX and interaction with the DISQS complete.

We now show that our algorithm is feasible, i.e., the required updates of MIX and DISQS can be performed during a round while maintaining the promised update time.

Interaction with DISQS. First we consider the interaction with the DISQS. Overall, during current round , the interaction with DISQS consists of performing the updates of round and querying the DISQS to output an independent set. The total running time is therefore at most

 (|^It−1|+Rt)f(n) ≤(OPTrt−1+Rt)f(n) ≤(h(ϵ)OPTrt−2+Rt)f(n) Claim 4.4 ≤(h(ϵ)β|^It−2|+Rt)f(n) ^It−2 is a β-approx of OPTrt−2 =(h(ϵ)βϵ⋅ϵ|^It−2|+Rt)f(n) ≤(h(ϵ)βϵ⋅2Rt+Rt)f(n) Using ϵ|^It−2|≤2Rt =(1+2h(ϵ)βϵ)f(n)Rt

As we spend time on this per operation, after operations it will complete.

The MIX operation completes: The last part of the proof is to show that indeed during each current round the MIX operation has enough time to complete and calculate .

Our basic logic is as follows: Suppose you have a sequence of operations to execute that has breakpoints. Then the sequence will be completed after execution chunks. Thus, to show that the MIX operation completes during round , we have to count its breakpoints operation and show that they are .

Recall that in each step we run MIX until either time has passed or items are output by MIX. We treat those two cases separately and then put everything together. In the subsequent calculations we use that , since all of the factors evaluate to at least one, for any .

Breakpoints due to the time constraint: The chunks that are interrupted due to the first (time) constraint have size .

Recall that by definition of MIX, initializing MIX with and and performing calls, takes time. Since , using (3) we get that the total time of MIX is at most .

Therefore, the total time of MIX operation is upper bounded by and the size of chunks interrupted due to time constraints is at least . This implies that the number of breakpoints due to time constraints is at most

 τϕ(ϵ)2⋅γ(|^It−3|+|^It−2|)=2OPTg3(ϵ)⋅γ(|^It−3|+|^It−2|)ϕ(ϵ)2⋅γ(|^It−3|+|^It−2|)=4OPTg(ϵ)3⋅ϕ(ϵ) (5)

Breakpoints due to MIX changes: The chunks that are interrupted due to the second (MIX) constraint have size . Note that MIX will output at most items. Therefore, the number of breakpoints due to MIX is at most

 2OPTg(ϵ)3ϕ(ϵ)/2=4OPTg(ϵ)3⋅ϕ(ϵ) (6)

Putting everything together: By  (5) and (6), we get that the total number of breakpoints is at most

 8OPTg(ϵ))3⋅ϕ(ϵ) =8OPTg(ϵ))3⋅16h2(ϵ)ϵ⋅β⋅g3(ϵ)=ϵ⋅β⋅OPT2h2(ϵ) ≤ϵ⋅β⋅OPTt−22 Since OPTh2(ϵ)≤OPTt−2 by  (2) ≤ϵ|^It−2|2 Using ^It−2≥β⋅OPTt−2 ≤Rt Using ϵ⋅|^It−2|≤2⋅Rt

Thus the mix operation will finish during the round.

### 4.2 Necessity of the MIX function

###### Theorem 4.5.

Suppose for any , there are independent sets and of size such there is no MIX function with for all and , where . Then there is no -approximate dynamic MIS algorithm that reports at most changes in the independent set per update, for any .

###### Proof.

Let and suppose there is a -approximate MIS algorithm that reports changes per update in the worst case. Insert in to the data structure. Then insert and delete . This is update operations. At all times the independent set is at least , and there are at most changes per update operation. We could transform this into a MIX function by taking the at most changes from update and report each change one at a time, first deletes and then inserts; thus at each step of the resultant MIX, their independent set is at least which is at least for sufficiently large

We can apply this to the case of rectangles in the plane, where we show that with a non-trivial worst-case performance of changes in the independent set per operation, it is impossible to have an -approximate MIS for any .

###### Lemma 4.6.

There is no MIX function for rectangles with . Thus from Theorem 4.5, for any , there is no -approximate dynamic MIS algorithm that reports at most changes in the independent set per update.

###### Proof.

This is equivalent to saying that there are sets of rectangles and such that for any MIX function, there is an such that . Consider sets of rectangles and , each of size , in the form of a grid such that are horizontally thin and disjoint, are vertically thin and disjoint, and every rectangle of intersects all rectangles of . In a MIX function, starting from , one can not add a single element from until all elements of have been removed. ∎

This construction works for any class of objects for such a generalized ”hashtag” construction is possible, which includes any class of shapes which are connected and where for any rectangle, there is a shape in the class that has that rectangle as its minimum orthogonal bounding rectangle. This includes natural classes of shapes without fatness constraints, such as triangles, ellipses, polygons, etc.

## 5 A MIX algorithm for fat objects

In this section we show that our deamortization scheme applies to fat objects, by showing that fat objects have a MIX algorithm with runtime .

#### Fat objects.

There are many possible definitions of fat objects in Euclidean space, we use the following one from [19]. Define the center and size of an object to be the center and side length of one of its minimal enclosing hypercube.

###### Definition 5.1.

A collection of (connected) objects is -fat, for a constant , if for any size- box , there are points such that every object that intersects and has size at least contains one of the chosen points.

This implies that any box can only intersect disjoint objects of size larger than the box. Throughout the whole section, and the dimension are considered to be constant.

We will develop and use a variant of the rectangle separator theorem of Smith and Wormald [47]. We first state the classic version, and then prove the variant we need. Our proofs are straightforward adaptations of those in [47].

###### Lemma 5.2 (Smith and Wormald [47]).

For any set of disjoint squares objects in the plane, there is a separating rectangle that such if we partition into , and based on whether each object lies entirely inside , entirely outside , or intersects , , and .

What we need differs from this in that we have two sets of fat objects, in each set the objects are disjoint but intersection is allowed between the two sets, and we want to have the separator intersect with an order-square-root number of objects in each set. However we require the separator to be balanced with respect to the first set only; it is not possible to require balance with respect to both sets. We state the separator lemma here; the proof is the subject of Section 5.1.

###### Lemma 5.3.

Let and be two sets of disjoint -fat objects in -dimensions. Let . We can compute a hypercube and sets with the following properties in time :

• The hypercube intersects objects of .

• , , ,

• All objects in and lie entirely inside

• All objects in and lie entirely outside

Given this separator lemma, we can construct a MIX algorithm with running time . The main novelty of lemma 5.3 is that we achieve the separation in linear time; previous works had separator lemmas running in “polynomial time”. It turns out that this fast running time is the key towards achieving a -time MIX algorithm; this will be clear after analyzing our MIX algorithm (see the discussion at the very end of Section 5.2).

Formally, our main result regarding MIX algorithm for fact objects is the following.

###### Lemma 5.4.

Fat objects in constant dimension have a MIX algorithm with running time : Given independent sets of fat objects and , there is a MIX from to whose size is always at least , with . The total running time of initializing the algorithm with and and performing all steps of MIX is .

The proof is the topic of Section 5.2.

### 5.1 Proof of separator lemma

In this subsection we prove lemma 5.3.

We start with a technical lemma. Let be a hypercube centered at and with side length (size) .

###### Lemma 5.5.

Let and be two sets of disjoint -fat objects in -dimensions. Let . Given two concentric hypercubes and , there is a hypercube that intersects at most objects of . Furthermore, can be computed in time .

###### Proof.

Fix for each fat object a minimum enclosing hypercube, arbitrarily chosen if it is not unique. For simplicity of presentation we assume general position: all coordinates and sizes of enclosing hypercubes are unique and no enclosing hypercube has size exactly

; these assumptions can be removed via standard methods. We classify each object in of

and as big or small based on whether its size is larger or smaller than .

The proof is divided into two steps. First, the combinatorial part, the existence of hypercube and second, the algorithmic part: finding in linear time.

#### Combinatorial part: existence of s3.

Consider the hypercubes for . All of these hypercubes are on or in the hyperannulus defined by and . We call them candidate hypercubes. We will show that at least one of these hypercubes meets the requirements to be the separator of the lemma. To this end, we treat small and big objects separately.

Small objects: Each of the candidate hypercubes is at distance from each other, and thus each small object in can only intersect at most one of the candidate hypercubes. Thus there will be at least one candidate hypercube which intersects at most small objects from .

Big objects: Now we bound how many big objects from , and by symmetry , can intersect any candidate hypercube . To do that, we upper bound the number of disjoint hypercubes of size that may intersect a candidate hypercube; call this bound . Since each hypercube of size intersects at most big objects of (due to Definition 5.1), we get that at most big objects of might intersect a candidate hypercube. By symmetry, the same bound holds for , so overall, big objects of may intersect a candidate hypercube.

We now compute the upper bound . Each candidate hypercube