Computational and Communication Complexity of Geometric Problems

Sima Hajiaghaei Shanjani B.Sc. Amirkabir University of Technology, 2011 B.Sc. Amirkabir University of Technology, 2012 M.Sc. Sharif University of Technology, 2015

A Dissertation Submitted in Partial Fulﬁllment of the Requirements for the Degree of

DOCTOR OF PHILOSOPHY

in the Department of Computer Science

c Sima Hajiaghaei Shanjani, 2021 University of Victoria

We acknowledge with respect the Lekwungen peoples on whose traditional territory the university stands and the Songhees, Esquimalt and WSÁNEĆ peoples whose ¯ historical relationships with the land continue to this day. ii

Computational and Communication Complexity of Geometric Problems

Sima Hajiaghaei Shanjani B.Sc. Amirkabir University of Technology, 2011 B.Sc. Amirkabir University of Technology, 2012 M.Sc. Sharif University of Technology, 2015

Supervisory Committee

Dr. Valerie King, Supervisor (Department of Computer Science)

Dr. Venkatesh Srinivasan, Departmental Member (Department of Computer Science)

Dr. William Evans, Outside Member (Department of Computer Science, University of British Columbia ) iii

ABSTRACT

In this dissertation, we investigate a number of geometric problems in diﬀerent settings. We present lower bounds and approximation algorithms for geometric problems in sequential and distributed settings. For the sequential setting, we prove the ﬁrst hardness of approximation results for the following problems:

• Red-Blue Geometric Set Cover is APX-hard when the objects are axis-aligned rectangles.

c • Red-Blue Geometric Set Cover cannot be approximated to within 2log1−1/(log log m) m in polynomial time for any constant c < 1/2, unless P = NP , when the given objects are m triangles or convex objects. This shows that Red-Blue Geometric Set Cover is a harder problem than Geometric Set Cover for some class of objects.

• Boxes Class Cover is APX-hard.

We also deﬁne MaxRM-3SAT, a restricted version of Max3SAT, and we prove that this problem is APX-hard. This problem might be interesting in its own right.

In the distributed setting, we define a new model, the fixed-link model, where each processor has a position on the plane and processors can communicate to each other if and only if there is an edge between them. We motivate the model and study a number of geometric problems in this model. We prove lower bounds on the communication complexity of the problems in the fixed-link model and present approximation algorithms for them. We prove lower bounds on the number of expected bits required for any randomized algorithm in the fixed-link model with n nodes to solve the following problems, when the communication is in the asynchronous KT1 model:

• Ω(n2/ log n) expected bits of communication are required for solving Diameter, Convex Hull, or Closest Pair, even if the graph has only a linear number of edges.

• Ω(min{n2, 1/}) expected bits of communications are required for approximating Diameter within a 1 − factor of optimal, even if the graph is planar. iv

• Ω(n2) bits of communications is required for approximating Closest Pair in a c c nc−1/2 graph on an [n ] × [n ] grid, for any constant c > 1 + 1/(2 lg n), within 4 − factor of optimal, even if the graph is planar.

We also present approximation algorithms in geometric communication networks with n nodes, when the communication is in the asynchronous CONGEST KT1 model:

• An -kernel, and consequently (1 − )–Approximate Diameter and - √n Approximate Hull with O( ) messages plus the costs of constructing a spanning tree.

√nc c c • An k -Approximate Closest Pair on an [n ]×[n ] grid , for a constant c > 1/2, 2 plus the cost of computing a spanning tree, for any k ≤ n − 1.

We also deﬁne a new version of the two-party communication problem, Path Com- putation, where two parties communicate through a path. We prove a lower bound on the communication complexity of this problem. v

Table of Contents

Supervisory Committee ii

Abstract iii

Table of Contents v

List of Tables vii

List of Figures viii

Acknowledgements x

1 Introduction 1 1.1 Organization ...... 2 1.2 Preliminaries ...... 3

2 Red-Blue Geometric Covering 10 2.1 Introduction ...... 10 2.1.1 Preliminaries and Background ...... 12 2.1.2 Motivation and Discussion ...... 18 2.1.3 Sketch of the Techniques ...... 19 2.2 MaxRM-3SAT ...... 21 2.2.1 Hardness of Approximation MaxRM-3SAT ...... 21 2.3 Red-Blue Geometric Set Cover ...... 28 2.3.1 RBGSC[AARectangle] ...... 29 2.3.2 RBGSC[Convex] and RBGSC[Triangle] ...... 40 2.4 Boxes Class Cover ...... 43 2.4.1 Reduction from MaxRM-3SAT to BCC ...... 43 2.5 Conclusion and Open Problems ...... 46 vi

3 Distributed Geometric Networks 48 3.1 Preliminaries and Background ...... 49 3.1.1 Distributed Networks ...... 49 3.1.2 Geometric Networks ...... 54 3.1.3 Two-Party Communication ...... 58 3.1.4 Coreset ...... 60 3.2 Path Computation ...... 63 3.2.1 Path Computation Lower Bounds ...... 66 3.3 Diameter and Convex Hull ...... 70 3.3.1 -Kernel ...... 71 3.3.2 Approximate Diameter ...... 73 3.3.3 Approximate Convex Hull ...... 74 3.3.4 Lower Bound for Diameter ...... 76 3.3.5 Lower Bound for Convex Hull ...... 80 3.4 Closest Pair ...... 83 3.4.1 Approximate Closest Pair ...... 84 3.4.2 Lower Bound ...... 87 3.5 Conclusion and Open Problems ...... 91

Bibliography 94 vii

List of Tables

Table 2.1 Lower bounds shown in Chapter 2. * for any constant c < 1/2. 20

Table 3.1 Results of Chapter 3. Upper bound and lower bound of the number of messages of size O(log n) bits for a geometric communication network with n nodes on an [nc] × [nc] grid in the ﬁxed-link model. *for a constant c > 1/2. ** for a constant c > 1 + 1/(2 lg n). 92 viii

List of Figures

Figure 2.1 Geometric Set Cover. (a) input for an instance of Geometric Set Cover (b) the set of the green objects is a solution for this instance...... 13 Figure 2.2 Boxes Class Cover. (a) input for an instance of Boxes Class Cover, and (b) the set of green rectangles is a solution for this instance...... 14 Figure 2.3 Red-Blue Geometric Set Cover. (a) input for an instance of Red-Blue Geometric Set Cover (b) the set of the green objects is a solution for this instance...... 16 Figure 2.4 Reductions. −→∗ is a modiﬁed version of the reduction that Chan and Grant showed from SPECIAL-3SC to GSC[AARectangle] in [21]. −→∗∗ is the reduction that Bereg et al. showed from Rec- tilinear Polygon Covering to BCC in [11]. All of the reductions are the results of this dissertation...... 19 Figure 2.5 It is not always possible to add a unique red point to each object...... 29 Figure 2.6 Reduction from MaxRM-3SAT to RBGSC[AARectangle]. a) variable points for all the variables and four variable rectangles

for X2 (b) Highlighted green areas are divisions of the plane to Region 1-3. c, d, e, f) clause points and clause rectangles ¯ for diﬀerent types of clauses: c) (Xj ∨ Xl), d) (Xj ∨ Xl), e) ¯ ¯ ¯ ¯ (Xj ∨ Xl), f) (Xj ∨ Xj+1 ∨ Xj+2) ...... 32 Figure 2.7 Points and rectangles for Reduction from SPECIAL-3SC to RBGSC[AARectangle] ...... 40 Figure 2.8 points and convex shapes for the reduction from Set Cover to RBGSC[Convex] ...... 42 ix

Figure 2.9 Reduction from MaxRM-3SAT to BCC. a) The points in the

highlighted gray area are variable points for X2. b)Region 1-3. ¯ c, d, e, f) Added red points and blue points for c = (Xj ∨Xl), d) ¯ ¯ Added red points and blue points for (Xj ∨ Xl), c = (Xj ∨ Xl), ¯ ¯ c = (Xj ∨ Xj+1 ∨ Xj+2)...... 45

Figure 3.1 - kernel proof ...... 73 Figure 3.2 Reduction from Set Disjointness to Diameter. In this example,

a1 = 1, ai = 0, ai+1 = 1, an = 1, b1 = 0, bi = 0, bi+1 = 1, and

bn = 1...... 77

Figure 3.3 The distance between wi and ui+1 is the second largest distance of a pair of points after the diameter...... 80 Figure 3.4 Reduction from Set Disjointness to Convex Hull. In this exam-

ple, a1 = 1, ai = 0, ai+1 = 1, an = 0, b1 = 1, bi = 0, bi+1 = 0, and

bn = 1...... 82 Figure 3.5 Reduction from Set Disjointness to Closest Pair...... 88 Figure 3.6 Reduction from Set Disjointness to Closest Pair. In this ex-

ample, a1 = 1, a2 = 1, an = 0, b1 = 0, b2 = 1, and bn = 0...... 90 x

ACKNOWLEDGEMENTS

Many helped me on this journey, and I want to take a moment to thank them. First and foremost I would like to sincerely thank my supervisor, Dr. Valerie King, who has supported and advised me during my past few years with her knowledge and foresight. Valerie is an inspiring individual and supervisor. She has always motivated me to do my best in my research. I am grateful for all the technical skills and insights that she has shared and the engaging courses I took with her. I would like to thank both Dr. Venkatesh Sirvanasan and Dr. Will Evans, my supervisory committee members, for all the fruitful discussions and useful feedback I have received at every stage of my research. Venkatesh and Will were always very encouraging and helped me during hard times. I would like to thank Dr. Jit Bose, who agreed to be the external examiner and for all the insightful comments and suggestions. My life during the past years would have been difficult if I had not had the help of many people. I want to thank everyone at the university that helped me and taught me different skills. It is hard to name everyone, but I would especially like to express my gratitude to David Palmer-Stone for his support and guidance. I would like to extend my sincere thanks to Dr. Bruce Kapron, Dr. Nishant Mehta, and Dr. Andrea Tagliasacchi for offering interesting courses which helped me to broaden my knowledge in other subjects. I also would like to thank the Center for Academic Communication, especially Nancy Ami and Kaveh Tagharobi for their help, support, and everything they taught me. I would like to acknowledge the assistance the staff of the Department of Computer Science especially Wendy Beggs, Kath Milinazzo, and John Fagan provided during these years in the department. I would like to thank my lab mates at UVic and my friends for all the good conversations, motivation, support, and fun. They were there in all the ups and downs! I also want to especially thank my friend Dr. Keivan Monfared for all the good conversations and feedback on my thesis and work, and for being a great support. In the end, I want to dedicate this thesis to my family, the memory of my mom Nadereh, my father Reza, my sister Mina, and my brother Hamid. They have always supported and motivated me. 1

Chapter 1 Introduction

In this dissertation, we study geometric problems in sequential and distributed settings. We prove hardness of approximation for problems in the sequential setting, and we prove lower bounds and present approximation algorithms in the distributed setting. We show lower bounds on the number of communication bits required to approximate these problems in the distributed setting. In this research, we study problems for which finding an exact solution is hard. That is, finding an exact solution requires a large amount of resources such as time, space, or communication. We design approximation algorithms whose solutions are always guaranteed to be within a multiplicative factor of the optimal. We say that the approximation ratio of an approximation algorithm is ρ if its solution is within a factor ρ of the optimal. One way of improving the results for this type of problem is to find efficient approximation algorithms with better approximation ratios. The second way is 1) to show hardness of approximation by proving a threshold or lower bound on the approximation ratio of the problem given some restriction on the amount of some resources or 2) to show a lower bound on the amount of resource to achieve a specific ratio, as there is always a trade off between the amount of resources and the possible achievable approximation ratio. 2

1.1 Organization

This dissertation is divided into two parts; the first part of this study aims to address red-blue geometric covering questions in the sequential setting, the second part addresses questions on geometric communication networks in the distributed setting. In Chapter 2, we study variants of the problem of Geometric Set Cover. This problem is one of the fundamental geometric problems that has been studied for decades and has a wide range of applications from wireless networks to image processing. In the problem of Red-Blue Geometric Set Cover, a set of red points, a set of blue points, and a set of objects are given and the goal is to find a subset of the objects that cover all the blue points while covering the minimum number of red points. Chan and Hu in 2014 showed that this minimization problem is NP-hard even when the points are in the plane and objects are axis-aligned unit squares. Here we study Red-Blue Ge- ometric Set Cover when the objects are axis-aligned rectangles, convex shapes, and triangles. We also study the problem of Boxes Class Cover in which a red-blue point set is given, and the goal is to find a minimum number of axis-aligned rectangles that cover all the blue points but no red point. This problem was introduced in a paper in 2012 by Bereg et al., who showed this minimization problem is NP-hard. No hardness of approximation was known for these problems prior to this work. The results of this chapter have been published in the proceeding of the 32nd Canadian Conference on Computational Geometry (CCCG 2020) [35]. A shorter version of these results also has been published in the booklet of abstracts of the Computational Geometry: Young Researchers Forum 2020 (CG:YRF 2020) [36].

In Chapter 3, we investigate the amount of communication that is required to find solutions to some geometric problems in the fixed-link model. In the fixed-link model, 3

a communication network is a graph in which each node has only local information about the graph, and nodes communicate by passing messages along its edges. Here, we consider the geometric communication network in which the nodes also occupy points in space. Our goal is to understand the communication cost needed to solve several fundamental geometry problems, including Convex Hull, Diameter, Closest Pair, and approximations of these problems, in an asynchronous communication setting. The model is specifically useful if we have a setting in which our communication network does not change or is relativity stable, but the positions of the nodes are changing, for example, there are mobile agents with a fixed communication network. This extends the 2011 result of Rajsbaum and Urrutia for finding a convex hull of a planar geometric communication network to networks of arbitrary topology. A version of some results of this chapter has been published in the proceeding of the 22nd International Conference on Distributed Computing and Networking (ICDCN 2021) [37].

1.2 Preliminaries

In both chapters of this dissertation we study techniques to approximate or show hardness of approximation results for geometric optimization problems. Here we review some deﬁnitions and concepts in the context of optimization problems and approximation.

Deﬁnition 1.2.1 ([7]). An optimization problem A is characterized by the following quadruple of objects (IA, SOLA, COSTA, GOALA), where:

• IA is the set of instances of A; 4

• SOLA is a function that associates any input instance x ∈ IA the set of feasible solutions of x;

• COSTA is the measure function, deﬁned for pairs (x, y) such that x ∈ IA and

y ∈ SOLA(x). For every such pair (x, y), COSTA provides a positive rational number which is the value of the feasible solution y;

• GOALA ∈ {max,min} speciﬁes whether A is a maximization or minimization problem.

Given an input instance I of optimization problem A, we denote by OPTA(I) the the value of an optimal solution. If there is no confusion we might also use the notation OPT (I).

Any optimization problem A has an associated decision problem AD. If A is a minimization problem, AD asks, given K > 0, whether there exists a feasible solution

y for any instance x such that COSTA ≤ K. Similarly, if A is a maximization

problem, AD asks, given K > 0, whether there exists a feasible solution y for any

instance x such that COSTA ≥ K [7].

An NP-optimization problem is an optimization problem whose decision version is in NP. The class of all NP-optimization problems is called NPO [7].

We say an NP-optimization problem is NP-hard if its decision version is NP-hard. This is a slight abuse of notation, but it has been used widely in the literature [71]

Here we review some deﬁnitions in the context of approximation algorithms.

• Approximation Ratio (Factor): An algorithm for a minimization problem 5

A has the approximation ratio (factor) ρ, for some ρ > 1, if for every input I, the algorithm’s solution is feasible and the value of the solution, shown by

COSTA(I), is at most ρ · OPT (I).

An algorithm for a maximization problem A has the approximation ratio (factor) of ρ, for some ρ < 1, if the value of the algorithm’s solution for every input

I, shown by COSTA(I), is at least ρ · OPT (I).

• ρ-Approximation Algorithm: An approximation algorithm is called a ρ- approximation if it has the approximation factor ρ.

• PTAS: For a minimization problem in NPO, a polynomial time approximation scheme (PTAS) is a (1 + )-approximation algorithm which takes a parameter > 0 as part of the input and runs in time polynomial in the problem size n for every ﬁxed . Similarly, for a maximization problem in NPO, a PTAS is a (1 − )-approximation algorithm which takes a parameter > 0 as part of the input and runs in time polynomial in the problem size n for every ﬁxed .

Here we review some of the approximation complexity classes.

• PTAS: The class of all the NP-optimization problems for which a PTAS exists.

• APX: The class of all the NP-optimization problems that allow constant factor polynomial time approximation algorithms.

• F -APX: The class of all the NP-optimization problems for which f(n)- approximation algorithm exists for some f ∈ F . O(1)-APX is also called APX.

It is known that if P 6= NP , P T AS ( AP X [23]. 6

Hardness of Approximation

An NP-optimization problem A is NP-hard to approximate within ρ factor of the optimum if ﬁnding a polynomial time approximation for the problem with an approximation ratio ρ is impossible if P 6= NP . Such a result for the problem A is called a hardness of approximation result for A. For a minimization problem, this translates into a lower bound on the achievable approximation ratio under the assumption that P 6= NP . One way to show hardness of approximation for an optimization problem is to use reductions from known hard problems. If we reduce from an NP-hard decision problem such as SAT to an instance of a given NP-optimization problem, there should be a gap between the optimum value of the objective function depending on whether the boolean formula is satisﬁable [41]. Such a reduction is called a gap-introducing reduction.

Deﬁnition 1.2.2. [71] For a minimization problem P , a gap-introducing reduction from SAT to P with two parameters α and β is a polynomial algorithm f. Given an instance φ of SAT, f produces an instance x = f(φ) of P , such that

if φ is satisﬁable, OPT (x) ≤ β,

if φ is not satisﬁable, OPT (x) > α · β.

Here α and β are functions of |x|, and α ≥ 1. Similarly if P is a maximization problem,

if φ is satisﬁable, OPT (x) ≥ β,

if φ is not satisﬁable, OPT (x) < α · β. 7

In this case α < 1. The gap, α, is precisely the hardness factor established by the gap-introducing reduction for the NP-hard optimization problem P .

In this way, we can prove hardness of approximation for NP-optimization problems using gap-introducing reductions from NP-hard decision problems. Then we can use these NP-optimization problems with known hardness of approximation to show hardness results for other NP-optimization problems. In the reduction from an NP-optimization inapproximable problem to a given NP-optimization problem, we start with a known inapproximable problem, such as Set Cover, MAX-3SAT, and Label Cover, and reduce it to the given problem via a gap-preserving reduction.

Deﬁnition 1.2.3 ([41]). Let A and A0 be two maximization problems. A gap- preserving reduction from A to A0 with parameters (α, β), (α0, β0) is a polynomial time algorithm f. For each instance x of A, algorithm f produces x0 = f(x) an

0 0 0 instance of A . The optima of x and x , say OPTA(x) and OPTA0 (x ) respectively, satisfy the following property:

0 0 OPTA(x) ≥ β =⇒ OPTA0 (x ) ≥ β ,

0 0 0 OPTA(x) < α · β =⇒ OPTA0 (x ) < α · β

Here α and β are functions of |x|, and α0 and β0 are functions of |x0|. Also, α(x), α0(x0) ≤ 1 .

Having such a gap-preserving reduction from A to A0 implies that if achieving an approximation ratio of α for A is NP-hard, then achieving an approximation ratio of α0 for A0 is NP-hard [41]. 8

Here we assumed both of the problems are maximization problems. The other cases are similar. For example, in the case that A is a minimization problem and A0 is a maximization problem the property changes to the following:

0 0 OPTA(x) ≤ β =⇒ OPTA0 (x ) ≥ β ,

0 0 0 OPTA(x) > α · β =⇒ OPTA0 (x ) < α · β

Here α and β are functions of |x|, and α0 and β0 are functions of |x0|. Also, α(x) ≥ 1 and α0(x0) ≤ 1 [71].

There are diﬀerent types of gap preserving reductions, and some of them pre- serve membership of NP-optimization problems in diﬀerent approximation complexity classes. PTAS-reduction is a commonly used reduction scheme, as it preserves

membership in PTAS [70], i.e. If B ∈ PTAS and A ≤PTAS B, then A ∈ PTAS.

Deﬁnition 1.2.4. [70] There is a PTAS-reduction from NP-optimization problem A

to A0 if there are computable functions f, g, δ : Q+ → Q+ such that for any input instance x of A and for any > 0,

• f produces x0 = f(x, ) of A0 in polynomial time in |x| for any ﬁxed value of ;

0 • for any y ∈ SOLA0 (x ) , g(x, y, ) is a solution for x in A and g is polynomial time computable in |x| and |y| for any ﬁxed value ;

0 0 0 • for any solution y for x in A , if y is within 1+δ() of OPTA0 (x ), then g(x, y, )

is within 1 + of OPTA(x).

A problem is APX-hard if there is a PTAS-reduction from every problem in APX to that problem. (It doesn’t need to be an NP-optimization problem.) By Crescenzi and Panconesi [21], if P 6= NP , then an APX-hard problem cannot 9

be in PTAS. A problem is APX-complete if the problem is APX-hard and also in APX.

Coreset

Data summarization and sampling are the common approaches which are used in sequential, distributed, parallel, and streaming models. There are different types of samples that have been used. A coreset is a subset of the input data with the property that an approximate solution to the whole input data can be obtained given the coreset alone. Finding a small coreset, whose size is a function of only the approximation parameter , is an effective way to approximate problems, as the size of the coreset is independent of the size of the original data set. Depending on the problem we might need to use different types of coresets, such as -nets and -kernels. Given a set system (X,R), where X is a set of elements and R is a family of subsets, an -net is a sample of X which has a representative from any subset with more than |X| elements. We will define -net formally in Chapter 2. Given a set of points, an -kernel is a type of coreset whose width approximates the width of the point set in any direction. In Chapter 3 we will define -kernel formally and propose an algorithm to find it for our problems in a distributed setting. 10

Chapter 2 Red-Blue Geometric Covering

2.1 Introduction

Consider the problem that we want to locate fire stations across a city and there are some candidate places that can be used for this purpose. For each of these candidate places, we compute all the buildings (demand points) that the fire stations in the candidate positions can give service to in less than five minutes. By considering these demand points, we want to locate fire stations in a minimum possible number of places while we want to be able to serve all the demand points in the entire city in less than five minutes. We can see this problem as an instance of Set Cover, but this is a special case of Set Cover, in which the elements of the universe set are points and the subsets are geometric objects or areas. This version of Set Cover that the universe X is a set of points and the family of T is a set of geometric objects, is called Geometric Set Cover. In this problem the goal is to find a minimum sized subset T 0 ⊆ T such that each point in X is contained in one of the objects in T 0. The dual equivalent instance of Set Cover is the problem of Hitting Set. Assume that we want to form a committee in a society where there are some special interest groups of people, for example people from specific ethnicities, age groups, and gender 11

identities. We want to choose the smallest possible subset of people to be in the committee such that we have at least one representative for each group. In order to formulate this instance of Hitting Set, we can represent the entire population as a universe set X and represent the groups as a family T of subsets of X. The goal is to find a minimum sized subset X0 ⊆ X such that each group in T has at least one representative in X0. Although these problems are easy to define, they are not easy problems to solve optimally. In fact, these problems are NP -hard, which means that no polynomial time algorithm exists to solve these problems optimally unless P = NP . Geometric Set Cover, the geometric version of Set Cover, is a fundamental theoretical problem that has been studied for over 30 years. Applications of this problem include wireless network design, image compression, and circuit-printing [21]. This problem is NP-hard even for simple geometric objects such as unit squares, unit disks, and axis-aligned rectangles [42]. Much effort has been made to develop approximation algorithms or prove lower bounds for the best possible approximation ratio for this problem; However, still there is a big gap between the best upper bound and lower bound. While Geometric Set Cover has been studied widely for several geometric objects, the problem of Red-Blue Geometric Set Cover has been studied only for axis-aligned unit squares [22]. In this research, we study Red-Blue Geometric Set Cover for some classes of objects, and we prove new results on the hardness of approximation for this and Boxes Class Cover. Then we compare our result with the approximability of Geometric Set Cover for the same class of objects, and we conclude that Red-Blue Geometric Set Cover is a harder problem than Geometric Set Cover for some class of objects. 12

2.1.1 Preliminaries and Background

In this section, we deﬁne and describe problems and terms we use in this research.

Set Cover: In the problem of Set Cover, a set X of n elements and a family T of m subsets of X are given, and the goal is to ﬁnd a minimum sized subset T 0 ⊆ T such that each element in X is contained in at least one member of T 0. This fundamental problem has been known to be NP-hard and NP-hard to approximate within a factor of (1−α) ln n of the optimum for every α > 0 [26], where n and m are polynomially related. It has also been shown that this problem cannot be approximated to within 2log1−δc(m) m in polynomial time for any constant c < 1/2

1−δ (m) O(2log c m) c unless SAT can be decided in time 2 , where δc(m) = 1/(log log m) [59]. Note that this result is only depends on m, the number of subsets.

VC-dimension: For a given set X of n elements and a family T of subsets of X, a subset S ⊆ X is shattered by T if for any S0 ⊆ S, there is some t ∈ T such that S0 = S ∩ t. The VC-dimension of set system (X,T ) is the maximum size of any set S shattered by T . The VC-dimension of a set system is a measure of complexity of the set system.

-net: In the context of approximation, one of the ideas is to use only a small sample of the input set which is a representative of the input. For given universe set X and a family T of subsets of X, E ⊆ X is called an -net, for some 0 < < 1, if E ∩ t 6= ∅ for all t ∈ T whenever |t| ≥ |X|.

Geometric Set Cover (GSC): In this version of Set Cover, we are given a set of points X and the given family T is a set of geometric objects, and the goal is to ﬁnd 13

(a) (b)

Figure 2.1: Geometric Set Cover. (a) input for an instance of Geometric Set Cover (b) the set of the green objects is a solution for this instance.

a minimum sized subset T 0 ⊆ T such that each element in X is contained in at least one of the objects of T 0. Figure 2.1 shows an instance of Geometric Set Cover. We denote the problem of Geometric Set Cover when the objects are from the class of objects OBJ with GSC[OBJ], where OBJ is the name of the class of objects, for example GSC[AARectangle] means Geometric Set Cover when the objects are from the class of axis-aligned rectangles. Approximating this problem has been studied in two directions. First, PTASes have been developed for some simple objects, such as unit-squares [42] and disks in

R2 [57]. For some other objects with low VC-dimension, -net based algorithms with constant or almost-constant approximation factors have been presented [17, 27]. However, ﬁnding a small, O(1/)-size -net is not always possible. For example, [60] shows that there exists a dual range space induced by a family of ﬁnite families

1 1 of axis-aligned rectangles in which the size of the smallest -net is Ω(( ) log ). In this case the approximation factor of the -net based algorithms is O(log OPT ), where OPT is the size of the optimal solution. Second, it has been shown that Geometric Set Cover is APX-hard for a large class of geometric objects including axis-aligned rectangles, axis-aligned slabs, and triangles assuming P 6= NP .[21][38]. Additionally it has been shown that the problem is APX-hard for pseudo-disks 14

(a) (b)

Figure 2.2: Boxes Class Cover. (a) input for an instance of Boxes Class Cover, and (b) the set of green rectangles is a solution for this instance.

in the plane, assuming NP ( DTIME(2polylog(n)) [56], where pseudo-disks refers to a set of objects such that the boundary of every pair of them intersects at most twice

Class Cover: In Class Cover problems, points are given in two sets R and B, red points and blue points respectively, and the goal is to ﬁnd a minimum sized family T of a speciﬁc type of object (e.g. balls) that cover all the points in B but no point in R. This problem has been studied also in the context of data mining when the objects are balls with the constraint that balls are centered at blue points [18, 25, 52]. The constrained and unconstrained versions of this problem are NP-hard when the objects are balls [18, 10].

Boxes Class Cover(BCC): In this version of Class Cover problem, the objects are axis-aligned rectangles. Figure 2.2 shows an instance of BCC. Note that in Set Cover problems, the family of subsets is given as the input, and we select a subfamily of them. But, in Class Cover, the goal is to compute such a family and the candidate subsets are all the subsets of that type of object. For example, in GSC[AARectangle] we are given a set of points X and a family T of 15

some axis-aligned rectangles, and the goal is to ﬁnd a minimum sized subset of these rectangles to cover all the points. However, in BCC a family of rectangles is not given, and we want to compute a minimum sized family of axis-aligned rectangles that cover all the blue points but no red point. In any solution for BCC we can expand the rectangles so that the sides of the rectangles reach the red points or inﬁnity (the bounding box of the the points). We can see BCC as a special case of GSC[AARectangle], as we can consider the family of all the maximal rectangles to be the family of given objects for GSC[AARectangle] and the blue points as the set of points. The size of the family of all the maximal rectangles is O(|R|2), where |R| is the number of red points, and this family of rectangles can be computed in polynomial time [58]. Bereg et al. use a reduction from a rectilinear polygon covering problem [24, 53] to show that the BCC is NP-hard and admits O(log OPT )-approximation, where OPT is the size of optimal covering [11]. The same paper also shows NP-hardness and the existence of an O(1)-approximation algorithm for BCC when the objects are axis-aligned squares. They also show that BCC is NP-hard even if the objects are axis-aligned half-slabs, but BCC can be exactly solved in polynomial time when the objects are axis-aligned slabs. It has also been shows that BCC is NP-hard by a reduction from NAS-SAT, a version of Max3SAT, to this problem [5, 6]. However, no hardness of approximation has been shown for BCC yet.

Red-Blue Set Cover: This problem is a more general version of Set Cover. The elements are given in two sets R and B, red elements and blue elements respectively, and the goal is to select a subfamily T 0 of a given family T of m subsets of R ∪ B such that T 0 covers all the elements in B but includes only a minimum number of elements in R. 16

(a) (b)

Figure 2.3: Red-Blue Geometric Set Cover. (a) input for an instance of Red-Blue Geometric Set Cover (b) the set of the green objects is a solution for this instance.

Carr et al. showed that the problem is NP-hard and NP-hard to approximate within 2(log m)(1−δ) factor of the optimal for δ = 1/(log log m)c and any constant c < 1/2 even in the restricted case that each set in T contains only one blue √ and two red elements [19]. They also present a 2 m-approximation algorithm for the case that each set in T contains only one blue element. Peleg presented a q 2 m log |B|-approximation algorithm for the problem [62].

Red-Blue Geometric Set Cover (RBGSC): In the geometric version of Red- Blue Set Cover, the given sets R and B are red points and blue points respectively and the given family T are geometric objects, and the goal is to select a subfamily T 0 of a given family T of geometric objects such that T 0 covers all the points in B but covers only a minimum number of points in R. Figure 2.3 show an instance of Red-Blue Geometric Set Cover. We denote the problem of Red-Blue Geometric Set Cover when the objects are from the class of objects OBJ with RBGSC[OBJ]. e.g. RBGSC[AARectangle]. Note that Red-Blue Set cover is a general version of Set Cover. However, the same idea of reduction (adding exactly one distinct red element to each subset) does not work for the geometric version. So, Red-Blue Geometric Set Cover is not yet shown 17

to be a more general version of Geometric Set Cover, and we do not know a way to relate lower bounds on these two geometric problems. Chan and Hu showed that the problem is NP-hard even when the objects are unit-squares and present a PTAS for this version of the problem [22]. To the best of our knowledge, no hardness of approximation result has been shown for Red-Blue Geometric Set Cover.

We will show the APX-hardness of for RBGSC[AARectangle] and BCC in Section 2.3.1. First we show our results via reductions from a newly deﬁned version of Max3SAT to these two problems. Then, we describe how we can modify reductions in [22] and [11] to prove the APX-hardness of these two problems. Here we describe results known for problems related to this.

Max3SAT: This is the version of MaxSAT where a CNF formula is given and each clause has at most 3 distinct literals, and the goal is to determine the maximum number of clauses that can be satisﬁed by any truth assignment. A truth assignment for a formula is a mapping from each variable to 0 or 1. We call a truth assignment a satisfying truth assignment if the formula evaluates to 1. Håstad showed that MaxE3SAT, the version of Max3SAT in which each clause has size exactly three, is NP-hard to approximate within a factor greater than 7/8 of the optimum even in the case of satisﬁable instances of the problem [39]. Here we use MAX-EkSAT-b, a version of MaxSAT in which every clause has length k and each variable occurs exactly b times (other notations have been used for this problem e.g. (k, b)-SAT , EbOCC-EkSAT, and MAX EkSAT(b) [13]). Feige showed that MaxE3SAT-5 is APX-hard with an explicit bound on the approximability constant [28]. MaxE3SAT-4 is also known to be APX-hard [13, 14]. 18

2.1.2 Motivation and Discussion

Geometric Set Cover vs Red-Blue Geometric Set Cover

Red-Blue Geometric Set Cover is not yet shown to be a more general version of Ge- ometric Set Cover. This research investigates the complexity of Red-Blue Geometric Set Cover as compared to other well known problems such as Geometric Set Cover and attempts to determine if any of them is harder.

Red-Blue Geometric Set Cover

Geometric Set Cover has been studied widely for several geometric objects. However, the problem of Red-Blue Geometric Set Cover has been studied only for axis-aligned unit squares [22]. In this research we want to investigate the complexity of Red-Blue Geometric Set Cover for diﬀerent geometric objects such as rectangles and triangles.

Boxes Class Cover

It is interesting to see that Geometric Set Cover is strictly harder than Class Cover for some classes of objects. This comes from the fact that Geometric Set Cover is APX-hard [21] when the objects are axis-aligned slabs, but Class Cover can be solved in polynomial time when the objects are axis-aligned slabs (unbounded axis-aligned rectangles) [11]. On the other hand, BCC is a special case of GSC[AARectangle]. In BCC a family of rectangles is not given, but we can consider the family of all the possible eligible rectangles as the family of given objects for the Geometric Set Cover. The number of possible rectangles can be restricted to only a polynomial number of rectangle in the 19

Figure 2.4: Reductions. −→∗ is a modiﬁed version of the reduction that Chan and Grant showed from SPECIAL-3SC to GSC[AARectangle] in [21]. −→∗∗ is the reduction that Bereg et al. showed from Rectilinear Polygon Covering to BCC in [11]. All of the reductions are the results of this dissertation.

size of the input. Therefore, BCC can be approximated within a O(log OPT ) [17, 27] in polynomial time, but no hardness of approximation has been shown for BCC yet. In this research we want to know what is the complexity of approximating BCC.

2.1.3 Sketch of the Techniques

Unless otherwise speciﬁed, the rest of this chapter includes new ideas and proofs which are the result of our research. Table 2.1 shows the results of this chapter. We show our hardness results by a series of reductions. Figure 2.4 shows these reductions. In Section 2.2 we deﬁne a new version of Max3SAT, MAX Restricted Mixed 3SAT (MaxRM-3SAT), and we show that the problem is APX-hard. In Section 2.3.1 we prove the APX-hardness of RBGSC[AARectangle] in two ways: First, we show a reduction from MaxRM-3SAT to RBGSC[AARectangle]. Second, we show how to modify the presented reductions in [21] to show that RBGSC[AARectangle] is APX-hard. 20

Known Before Our Result

MaxRM-3SAT - APX-hard

BCC NP-hard APX-hard

RBGSC[AARectangle] NP-hard APX-hard

c RBGSC[Convex] NP-hard inapproximable within 2log1−1/(log log m) m *

c RBGSC[Triangles] NP-hard inapproximable within 2log1−1/(log log m) m *

Table 2.1: Lower bounds shown in Chapter 2. * for any constant c < 1/2.

In Section 2.3.2 we prove hardness results for RBGSC[Convex] and RBGSC[Triangle] by reductions from Set Cover and Red-Blue Set Cover. We provide the proof of APX-hardness of BCC in Section 2.4. The reduction from MaxRM-3SAT to BCC is similar to the reduction in Section 2.3.1. In this section, we also mention how we can use the reduction presented in [11] to show the APX-hardness of BCC.

The ﬁrst method of showing the APX-hardness of both RBGSC[AARectangle] and BCC are attained by showing reductions from the same problem, MaxRM-3SAT. We believe this can be utilized to elucidate the relation and similarities of these two problems. Besides, we are hopeful that MaxRM-3SAT can potentially be used to show hardness of approximation results for other geometric problems. However, the second methods for both of the problems are interesting on their own right, as they build on previous works by other scholars, and following these reduction can be more strait forward. 21

2.2 MaxRM-3SAT

Max3SAT is a version of MaxSAT where all clauses have at most 3 literals and the goal is to determine the maximum number of clauses that can be satisﬁed by any truth assignment. Here, we deﬁne MaxRM-3SAT, and we prove this problem is APX-hard by a PTAS-reduction from MaxE3SAT-5.

Deﬁnition 2.2.1 (MaxRM-3SAT). This problem is a variant of Max3SAT where all the clauses are of size 2 or 3 and have the following properties:

1. All the clauses of size 3 have a literal in negated form and a literal in non-negated form.

2. Every variable appears in exactly one clause of size 3 either in negated form or non-negated form.

3. Every variable appears in exactly one of the clauses of size 2 in negated form, and exactly one of the clauses of size 2 in non-negated form.

We can observe that by properties 2 and 3 of the deﬁnition if m is the number of clauses of size 3 in an instance of MaxRM-3SAT, then there are exactly 3m variables and 4m clauses in total in the formula. We prove a hardness result for MaxRM-3SAT by a reduction from MaxE3SAT-5, the version of the Max3SAT in which each clause is of length exactly 3 and each variable appears in exactly 5 clauses [28].

2.2.1 Hardness of Approximation MaxRM-3SAT

We use a reduction from MaxE3SAT-5 to show the inapproximability of MaxRM- 3SAT. 22

Suppose that an instance φ of MaxE3SAT-5 is given with n variables and m = 5n/3 clauses. The following transformation F transforms φ to Φ, an instance of MaxRM-3SAT with M clauses and N variables. F adds all the clauses of φ to Φ, then changes the name of variables and adds some clauses as described below.

First, F arbitrarily orders φ’s variables and clauses. For each variable x, let cx,i be the ith clause that x appears in φ.

0 For each variable x and clause c = cx,i, F replaces x with xi or x¯i in c , the corresponding clause in Φ, as described in the following steps. In addition, let f be a

mapping that shows if x replaced by xi or x¯i; f(x, i) = xi or x¯i respectively.

1. F process the variables and clauses regarding the order picked before, and uses

the changed clauses for the next variable. For each variable x and clause c = cx,i,

0 • If c = cx,i = (x ∨ y ∨ z), F replaces x with x¯i such that c = (x ¯i ∨ y ∨ z)

and f(x, i) =x ¯i.

• If c = cx,i = (x ∨ t2 ∨ t3) or c = cx,i = (¯x ∨ t2 ∨ t3), where either or both

0 t2 =y ¯ and t3 =z ¯, F replaces x or x¯ with xi such that c = (xi ∨ t2 ∨ t3)

and f(x, i) = xi or f(x, i) =x ¯i respectively.

After Step 1 is completed, F adds the clauses in Step 2 to Φ to have equality of xi’s instances with original x. For each variable x in φ,

2. F adds the following clauses to Φ for each 1 ≤ i ≤ 5:

(f(x, i) ∨ f(x, t)), where t = i + 1 if 1 ≤ i ≤ 4; t = 1 if i = 5.

Example 2.2.2 illustrates the steps of F on the smallest meaningful instance of MaxE3SAT-5. 23

Now Φ is an instance of MaxRM-3SAT. This is because it is a CNF formula, each clause of size 3 has one negated and one non-negated literal, each variable appears in one of the clauses of size 3, and each variable appears in exactly one of the clauses of size 2 in negated form, and exactly one of the clauses of size 2 in non-negated form. The number of variables in Φ is 3m, and the number of clauses is M = 4m, where m is the number of clauses in φ. This is because the number of clauses of size 3 in φ is m, and these are the only clauses of size 3 added to Φ by F . Besides, the number of clauses of size 2 associated with each variable x is at most the number of times it appears in φ, which is 5, so the total number of clauses of size 2 for all the variables is 5n = 3m, as m = 5n/3. Thus, M = m + 3m = 4m.

Example 2.2.2. Let u, v, w, x, y, z be the variables in φ an instance of MaxE3SAT-5 with 10 clauses, and

φ =(x ∨ y ∨ z) ∧ (¯x ∨ y ∨ w) ∧ (y ∨ z¯ ∨ u¯) ∧ (y ∨ v¯ ∨ w) ∧ (¯x ∨ z ∨ v) ∧ (¯y ∨ w¯ ∨ u)

∧ (z ∨ v ∨ u) ∧ (¯z ∨ w¯ ∨ u) ∧ (¯x ∨ v¯ ∨ w¯) ∧ (x ∨ v ∨ u¯).

Assume that the order that F picks to process the variables is x, y, z, v, w, z, and clauses by the order appeared in φ here. First F adds all the clause of φ to Φ, then

replaces variable x by ﬁve literals xi or x¯i for 1 ≤ i ≤ 5, and the followings are the clauses in Φ.

Φ =(x ¯1 ∨ y ∨ z) ∧ (x ¯2 ∨ y ∨ w) ∧ (y ∨ z¯ ∨ u¯) ∧ (y ∨ v¯ ∨ w) ∧ (x ¯3 ∨ z ∨ v) ∧ (¯y ∨ w¯ ∨ u)

∧ (z ∨ v ∨ u) ∧ (¯z ∨ w¯ ∨ u) ∧ (x4 ∨ v¯ ∨ w¯) ∧ (x5 ∨ v ∨ u¯)

The value of f for these replacements of x are as follows: f(x, 1) =x ¯1, f(x, 2) =

x2, f(x, 3) = x3, f(x, 4) =x ¯4, f(x, 5) = x5. 24

Next, F replaces variable y with ﬁve literals yi or y¯i for 1 ≤ i ≤ 5, and the followings are the updated clauses in Φ.

Φ =(x ¯1 ∨ y1 ∨ z) ∧ (x ¯2 ∨ y2 ∨ w) ∧ (y3 ∨ z¯ ∨ u¯) ∧ (y4 ∨ v¯ ∨ w) ∧ (x ¯3 ∨ z ∨ v) ∧ (y ¯5 ∨ w¯ ∨ u)

∧ (z ∨ v ∨ u) ∧ (¯z ∨ w¯ ∨ u) ∧ (x4 ∨ v¯ ∨ w¯) ∧ (x5 ∨ v ∨ u¯)

For any 1 ≤ i ≤ 5, f(y, i) = yi. The following is the formula Φ when F ﬁnishes Step 1 for all the variables.

Φ =(x ¯1 ∨ y1 ∨ z1) ∧ (x ¯2 ∨ y2 ∨ w1) ∧ (y3 ∨ z¯2 ∨ u¯1) ∧ (y4 ∨ v¯1 ∨ w2) ∧ (x ¯3 ∨ z3 ∨ v2)∧

(y ¯5 ∨ w¯3 ∨ u2) ∧ (z ¯4 ∨ v3 ∨ u3) ∧ (z ¯5 ∨ w¯4 ∨ u4) ∧ (x4 ∨ v¯4 ∨ w¯5) ∧ (x5 ∨ v5 ∨ u¯5)

The value of f for variable z is as follows: f(z, i) = zi for i = 1, 2, 3, 5 and f(z, 4) =z ¯4.

For any 1 ≤ i ≤ 5, f(u, i) = ui, f(v, i) = vi, f(w, i) = wi.

Then in Step 2, for variable x, F adds the following clauses of size 2: (x ¯1 ∨ x¯2), (x2 ∨ x¯3), (x3 ∨ x4), (x ¯4 ∨ x¯5), (x5 ∨ x1). Similarly, F adds clauses of size 2 to have the equality of instances of y, z, v, w, and u. The following is the formula Φ when F ﬁnishes Step 2, which is an instance of MaxRM-3SAT with 40 clauses.

Φ =(x ¯1 ∨ y1 ∨ z1) ∧ (x ¯2 ∨ y2 ∨ w1) ∧ (y3 ∨ z¯2 ∨ u¯1) ∧ (y4 ∨ v¯1 ∨ w2) ∧ (x ¯3 ∨ z3 ∨ v2)∧

(y ¯5 ∨ w¯3 ∨ u2) ∧ (z ¯4 ∨ v3 ∨ u3) ∧ (z ¯5 ∨ w¯4 ∨ u4) ∧ (x4 ∨ v¯4 ∨ w¯5) ∧ (x5 ∨ v5 ∨ u¯5)

∧ (x ¯1 ∨ x¯2) ∧ (x2 ∨ x¯3) ∧ (x3 ∨ x4) ∧ (x ¯4 ∨ x¯5) ∧ (x5 ∨ x1) ∧ (y1 ∨ y¯2) ∧ (y2 ∨ y¯3)

∧ (y3 ∨ y¯4) ∧ (y4 ∨ y¯5) ∧ (y5 ∨ y¯1) ∧ (z1 ∨ z¯2) ∧ (z2 ∨ z¯3) ∧ (z3 ∨ z4) ∧ (z ¯4 ∨ z¯5)

∧ (z5 ∨ z¯1) ∧ (v1 ∨ v¯2) ∧ (v2 ∨ v¯3) ∧ (v3 ∨ v¯4) ∧ (v4 ∨ v¯5) ∧ (v5 ∨ v¯1) ∧ (w1 ∨ w¯2)

∧ (w2 ∨ w¯3) ∧ (w3 ∨ w¯4) ∧ (w4 ∨ w¯5) ∧ (w5 ∨ w¯1) ∧ (u1 ∨ u¯2) ∧ (u2 ∨ u¯3)∧

(u3 ∨ u¯4) ∧ (u4 ∨ u¯5) ∧ (u5 ∨ u¯1) 25

Lemma 2.2.3. If there is a truth assignment for φ that satisfies m − k clauses, then there is a truth assignment for Φ that satisfies at least M − k clauses and we can find such a truth assignment for Φ, in polynomial time, by having the truth assignment for φ.

Proof. Consider the truth assignment for φ that satisﬁes at least m − k clauses. Set

the value of all the xi’s in Φ to the equivalent value of x in this truth assignment for

φ by using f, i.e. xi = x if f(x, i) = xi, and xi =x ¯ if f(x, i) =x ¯i. Therefore, the only unsatisfied clauses of size 3 in Φ are the ones whose corresponding clauses in φ are not satisfied. Besides, all the clauses of size 2 are satisfied in Φ. This is because all the values of xi’s are equivalent for any variable x, i.e. the value of f(x, i) is equal the value of f(x, j) for any 1 ≤ i, j ≤ 5. This implies either all the f(xi)’s are true or all the f(x, i) are true, so in clauses of size 2 for each variable (which are in the form of (f(x, i) ∨ f(x, t)), where t = i + 1 if 1 ≤ i ≤ 4; t = 1 if i = 5) exactly one of the literals is true. Thus, at most, k clauses are unsatisfied by this truth assignment for Φ.

Lemma 2.2.4. If there is a truth assignment for Φ that leaves no more than k clauses unsatisfied, there is a truth assignment for φ that leaves no more than k clauses unsatisfied and we can find such a truth assignment for φ, in polynomial time, by having the truth assignment for Φ.

Proof. First, we explain how we can change any truth assignment for Φ with no more than k unsatisﬁed clauses to another truth assignment, in which for each variable x all the xi’s have equivalent value and there are no more than k unsatisﬁed clauses.

Then, in the truth assignment for φ, we set the value of x to the value that all xi’s agreed on, and we show that this truth assignment does not leave more than k clauses unsatisﬁed. 26

For each x, we change the value of xi’s to the majority value of them. Now, we describe why this truth assignment for Φ has no more than k unsatisfied clauses. The number of unsatisfied clauses in Φ with this new truth assignment is, at most, the number of unsatisfied clauses of size 3 with the original truth assignment added to the number of satisfied clauses of size 3 in Φ that are no longer satisfied due to the change in xi’s values. For each x with equivalent values of xi’s in the original truth assignment, there is no change in the value of them in the new truth assignment and consequently no change by these variables in the number of satisfied clauses of size 3.

For each x with non-equivalent values of xi’s in the original truth assignment, at most, two clauses of size 3 can be unsatisfied after changing their values to their equivalent majority value, as i ≤ 5. On the other hand, if all the values of xi’s are equivalent, then the clauses of size 2 for each variable x are all true. But, if the values of xi’s are not equivalent, then, at least two of their clauses of size 2 are unsatisfied. So, changing the value of xi’s to their majority satisfies at least two more clauses of size 2 for these variables. This means that changing the value of xi’s to their majority does not increase the number of unsatisfied clauses. Therefore, we have a truth assignment for Φ with no more than k unsatisfied clause and for each x all the xi’s are equivalent. Finally, for the truth assignment for φ, each variable x gets the majority equivalent value of xi’s in Φ, and there are no more than k unsatisfied clauses in this truth assignment for φ.

Observation 2.2.5. For any instance of MaxE3SAT-5 there is a truth assignment that satisﬁes at least half of the clauses.

If there is a truth assignment that satisfies less than half of the clauses of any instance of MaxE3SAT-5, then we create a new truth assignment by flipping the value of each variable. This new truth assignment satisfies at least half of the clauses, as any unsatisfied clause in the original truth assignment is satisfied here. This shows 27

the correctness of Observation 2.2.5.

Theorem 2.2.6. MaxRM-3SAT is APX-hard.

Proof. Consider the two CNF formulas φ and Φ, an instance of MaxE3SAT-5 with m clauses and an instance of MaxRM-3SAT with M clauses, respectively. Assume the optimal solution for φ has (m − k) true clauses. Lemma 2.2.3 implies that there is a truth assignment for Φ with at least (M − k) true clauses. Assume that there

is a polynomial time algorithm that approximates MaxRM-3SAT with factor CRM ,

where CRM < 1. Then, the algorithm provides a truth assignment that has at least

CRM (M−k) true clauses and at most M−CRM (M−k) false clauses in Φ in polynomial time. By Lemma 2.2.4, we can ﬁnd a truth assignment for φ with at most M −

CRM (M −k) false clauses and at least m−M +CRM (M −k) true clauses in polynomial time. The approximation ratio of this truth assignment in φ is at least ρ = (m − M +

CRM (M − k))/(m − k).

m − M + C (M − k) m − M(1 − C ) − kC ρ = RM ≥ RM RM m − k m − k

Since M ≤ 4m,

m − 4m(1 − C ) − kC m(1 − 4 + 4C ) − kC m(−3 + 4C ) − kC ρ ≥ RM RM ≥ RM RM ≥ RM RM m − k m − k m − k (m − k)(−3 + 4C ) + k(−3 + 4C ) − kC 3k(1 − C ) ≥ RM RM RM ≥ 4C − 3 − RM m − k RM m − k

By Observation 2.2.5, 0 ≤ k ≤ m/2,

m 3 2 (1 − CRM ) ρ ≥ 4CRM − 3 − m ≥ 7CRM − 6 m − 2

This shows that if there is a polynomial time CRM -approximation algorithm for

MaxRM-3SAT, then there is a polynomial time (7CRM − 6)-approximation algorithm 28

for MaxE3SAT-5.

Assume CRM = 1 − δ(), and consider δ() = /7, for any > 0. 7CRM − 6 = 7(1−/7)−6 = 1+. Thus, this is a PTAS-reduction from MaxE3SAT-5 to MaxRM- 3SAT. Since MaxE3SAT-5 is APX-hard [28], MaxRM-3SAT is APX-hard.

2.3 Red-Blue Geometric Set Cover

Red-Blue Set cover is a general version of Set Cover: any instance of Set Cover can be transformed to an instance of Red-Blue Set Cover by considering all the elements of X as the blue elements and adding exactly one distinct red element to each subset in T . This reduction does not work for the geometric version, as it is not always possible to add exactly one distinct red point to each member of T . Figure 2.5 shows the situation that the general idea of adding a red point to each subset does not work in the geometric setting. In this ﬁgure, the three green rectangles are fully covered with the two gray rectangles, so it is not possible to add a unique red point to any of the green rectangles. However this does not prove that these two problems cannot be reduced to or related to each other with other ideas. No general relation has been shown yet between Red-Blue Geometric Set Cover and Geometric Set Cover, and we do not know a general way to relate lower bounds on these two geometric problems. We independently show a hardness of approximation for the Red-Blue Geometric Set Cover. We show APX-hardness of RBGSC[AARectangle] and Boxes Class Cover via reductions from MaxRM-3SAT. We also show how we can modify reductions in [22] and [11] to prove the APX-hardness of these two problems. We prove hardness results for RBGSC[Convex] and RBGSC[Triangle] by reductions from Set Cover and Red-Blue 29

Figure 2.5: It is not always possible to add a unique red point to each object.

Set Cover.

2.3.1 RBGSC[AARectangle]

RBGSC[AARectangle] is a version of Red-Blue Geometric Set Cover, where the objects are axis-aligned rectangles. In this section we prove the hardness of approximation for RBGSC[AARectangle] in two ways. First, we show a PTAS-reduction from MaxRM-3SAT, which we showed is an APX-hard problem in Section 2.2, to RBGSC[AARectangle]. Second, we show how to modify the presented reductions in [21] to show that RBGSC[AARectangle] is APX-hard. The hardness result that we prove for RBGSC[AARectangle] in this section shows that Red-Blue Geometric Set Cover is APX-hard, just like Geometric Set Cover, when the objects are axis-aligned rectangles.

Reduction from MaxRM-3SAT to RBGSC[AARectangle]

In this section, for an instance of MaxRM-3SAT we construct a set of red points, a set of blue points, and a set of rectangles in polynomial time. Then, we show a relation between the number of satisﬁed clauses in an optimal solution of MaxRM-3SAT and the 30

size of the optimum solution in the corresponding instance of RBGSC[AARectangle]. The idea of this structure was inspired by the structure used in [5].

Deﬁnition 2.3.1 (Vertical and Horizontal Rectangles). We call an axis-aligned rectangle that covers two points with the same x (resp., y)-coordinate a vertical rectangle (resp., horizontal rectangle).

We represent a rectangle by the coordinate of its four vertices: [x1, x2, y1, y2].

In the following three steps γ transforms formula Φ to (B,R,T ), which is an instance of RBGSC[AARectangle], in polynomial time. For clarity in the next steps we provide the position of the points in a Cartesian Coordinate System. γ adds red points in R, blue points in B, and axis-aligned rectangles to T as follows:

Step 1: For Φ, an instance of MaxRM-3SAT with 3m variables and 4m clauses, γ changes the order of the clauses to have all the clauses of size 3 ﬁrst and then clauses of size 2. γ renames the jth variable of the kth clause of this order to X3(k−1)+j.

Step 2: For each variable Xi, 1 ≤ i ≤ 3m, γ adds four blue points on coordinates (±7i, ±7i) to set B, four red points on coordinates (±7i, 7(3m + 1)) and (−7(3m + 1), ±7i), and two vertical and two horizontal rectangles to the object set T as shown in Figure 2.6(a). The coordinates of these rectangles are: [±7i − 1, ±7i + 1, −7(3m + 2), 7(3m + 2)] and [−7(3m + 2), 7(3m + 2), ±7i − 1, ±7i + 1]. Note that the four rectangles for each variable Xi together cover the points added for Xi in this step. In the ﬁgures of this section, circles and stars indicate blue and red points respectively. We call the blue points that we added in this step to B variable points, and the rectangles variable rectangles. On this arrangement of points RBGSC[AARectangle] has to have an optimal 31

(a) X3m X3 X2 X1 X2 (b)

Region 2

··· ··· ··· ··· X2

ein3 Region

· · · · · · X2 · · · · · ·

Region 1

··· ···

(e) In Region 1

···

Xl 32

(f) In region 2 Xj Xj

Xj+2

Xj+1

Figure 2.6: Reduction from MaxRM-3SAT to RBGSC[AARectangle]. a) variable points for all the variables and four variable rectangles for X2 (b) Highlighted green areas are divisions of the plane to Region 1-3. c, d, e, f) clause points and clause ¯ ¯ ¯ rectangles for diﬀerent types of clauses: c) (Xj ∨ Xl), d) (Xj ∨ Xl), e) (Xj ∨ Xl), f) ¯ ¯ (Xj ∨ Xj+1 ∨ Xj+2) solution that covers each variable’s blue points by exactly two rectangles, either both vertical or both horizontal. The main idea of the reduction from MaxRM-3SAT to RBGSC[AARectangle] is that the choice of vertical vs horizontal corresponds to a true vs a false assignment to the variables. In the next step, for each clause, we add some blue points to B to force the choice of the covering rectangle to be horizontal or vertical in the optimal solution for RBGSC[AARectangle] based on the structure of the clauses of Φ. The locations of these points are diﬀerent in each type of clauses depending on the size of the clause and the number of negated literals in the clause. Finally, we add one distinct red point to each rectangle.

Step 3: For each clause, add new blue points to B, new red points to R, and new rectangles to T as shown in Figure 2.6 (c), (d), (e), and (f), where the newly added blue points are shown in blue and the variable points are shown in gray. This figure shows these new points and rectangles in different regions, where regions are defined 33

¯ in Figure 2.6 (b). For each clause c = (Xj ∨ Xj+1 ∨ Xj+2), added points are similar to part (e) but rotated by −π/2 in Region 3. We call these added blue points clause points and the rectangles clause rectangles. The coordinate of the points and rectangles for diﬀerent types of clauses:

¯ • For each c = (Xj ∨ Xl), two blue points on coordinates (−7j, −7l) and (−7l + 3, −7l − 2), two red points (−7l + 2, −7l − 3) and (−7j − 2, −7l − 2), and two rectangles [−7l+1, −7l+3, −7l−4, −7l−1] and −7j−3, −7j+2, −7l−3, −7l+2 are added , as shown in Figure 2.6 (c).

• For each clause c = (Xj ∨ Xl), three blue points are added on coordinates (−7j, −7j + 2), (−7j + 2, −7j + 4), and (−7l, −7j + 4). The two red points are added on coordinates (−7j + 2, −7j + 2) and (−7j + 4, −7j + 4), and the two added rectangles are [−7j − 1, −7j + 3, −7j + 1, −7j + 5] and [−7j, −7l + 1, −7j + 3, −7j + 5], as shown in Figure 2.6 (d).

¯ ¯ • For each clause c = (Xj ∨ Xl), three blue points are added on (−7l − 3, −7l), (−7l − 4, −7l + 2), and (−7l − 4, −7j). The two red points are added on (−7l − 4, −7l + 4) and (−7l − 2, −7l + 2), and the added rectangles are [−7l − 3, −7l − 1, −7l − 1, −7l + 3] and [−7l − 5, −7l − 3, −7l + 1, −7j + 1], as shown in Figure 2.6 (e).

¯ ¯ • For each clause c = (Xj ∨Xj+1∨Xj+2), three blue points are added on (−7j, 7(j+ 1)), (7j, 7(j + 2)) and (−7j + 2, 7(j + 2) − 2). The coordinate of the red points are (−7j + 2, 7(j + 1) + 2) and (−7j + 4, 7(j + 2) − 2). The added rectangles are [−7j − 1, −7j + 3, −7(j + 1) − 1, −7(j + 2)] and [−7j + 1, 7j + 1, 7(j + 2) − 3, 7(j + 2) + 1], as shown in Figure 2.6 (f).

We observe that γ transforms formula Φ with 3m variables and 4m clauses to (B,R,T ) with 20m rectangles and |B ∪ R| = O(m) in polynomial time. This is 34

because 12m rectangles are added for all the variables, as for each variable four rectangles are added in Step 1, and there are 3m variables. Besides, 8m rectangles are added for all the clauses, as for each clause two rectangles are added, and there are 4m clauses.

Lemma 2.3.2. If there is a truth assignment for Φ with 4m − k satisﬁed clauses, then there is a solution for the corresponding instance of RBGSC[AARectangle] with at most 10m + k rectangles, and such a solution is polynomial time computable given the truth assignment for Φ.

Proof. The following mapping G maps a truth assignment α for Φ to a solution T 0 for

RBGSC[AARectangle]: For any variable Xi, if α(Xi) is true, then add two horizontal

0 variable rectangles associated with Xi to T . For any variable Xi, if α(Xi) is false, then

0 add two vertical variable rectangles associated with Xi to T . For each satisfied clause c, add one of the clause rectangles associated with c to T 0, such that the rectangle includes an uncovered clause point of this clause. For each unsatisfied clause c, add both of the clause rectangles associated with c to T 0. The rectangles in T 0 cover all the blue points. This is because all the variable points are covered with the two horizontal variable rectangles or the two vertical variable rectangles. Selecting variable rectangles regarding the mapping G leaves only one clause point uncovered for any satisfied clause, and one extra rectangle is enough to cover that. If a clause is not satisfied, none of its clause points is covered by the ¯ ¯ variable rectangles. For example, for clause c = (Xj ∨ Xl), if c is satisfied, at least one of Xj or Xl is assigned to 0 by α. Thus, at least for one of these two variables the vertical rectangles are selected, which means at least one of the clause points of c is covered and the uncovered clause point(s) can be covered with one extra clause rectangle. If c is not satisfied, this means that both of Xj and Xl are assigned to 1 by 35

α. Then, for both of these two variables the horizontal rectangles are selected, which means none of the clause points of c is covered by the variable rectangles and the two extra clause rectangles are needed to cover the clause points of c. See Figure 2.6 part (d). The size of T 0 is 10m + k, as two rectangles are selected for each variable, one rectangle for each satisﬁed clause, and two rectangles for each unsatisﬁed clause. |T 0| = 2 · 3m + 4m − k + 2k = 10m + k

Lemma 2.3.3. If there is a solution with 10m+k rectangles for (B,R,T ), an instance of RBGSC[AARectangle], then there is a truth assignment for Φ with at least 4m − k satisﬁed clauses, and such a truth assignment is polynomial time computable given the solution for (B,R,T ).

Proof. We show how to deﬁne a mapping G−1 that maps a solution T for (B,R,T ) an instance of RBGSC[AARectangle] to a truth assignment α for Φ. First, we show there is the solution T 0, in which all the four variable points of any variable is covered with exactly two vertical or exactly two horizontal rectangles and |T | ≥ |T 0|. Observe that for any variable, each variable point can be covered only by

0 its variable rectangles. Set T = ∅. For any variable Xi, 1 ≤ i ≤ 3m,

• if T covers the variable points of Xi with exactly two rectangles, this means either both of them are vertical or both of them are horizontal. In this case, we add both of these rectangles to T 0.

• if T covers the variable points of Xi with three or four rectangles, check if the two vertical or the two horizontal rectangles cover the most number of uncovered

clause points of the clauses that Xi appears in. Add these two variable rectangles to T 0. If a clause point remains uncovered, add one clause rectangle to T 0 to cover that. Note that no more than one clause point might remain uncovered as 36

by the deﬁnition of MaxRM-3SAT each variable only appears in three clauses, two clauses of size 2 and one clause of size 3, so either the two vertical or the two horizontal rectangles cover clause points from at least two of these clauses. Therefore, for this case, we added three or fewer rectangles to T 0.

Finally, if there are blue clause points that are not covered by the rectangles in T 0 , we add all the clause rectangles in T that they cover these blue point to T 0. We claim that |T | ≥ |T 0|, as in the ﬁrst case we kept the same rectangles, and in the second case we added fewer rectangles to T 0. G−1 is deﬁned as below for any solution T 0 in which all the four variable points of any variable is covered with exactly two vertical or two horizontal rectangles. G−1:

0 α(Xi) = 1; if the variable points of Xi are covered with vertical rectangles in T .

0 α(Xi) = 0; if the variable points of Xi are covered with horizontal rectangles in T .

Now, we show that the number of unsatisfied clauses in Φ by assignment α is no more than k. In this structure the variable rectangles of each variable only cover the blue points associated with their variable. If only one extra rectangle in addition to the variable rectangles is in T 0 to cover clause points of c, then c is satisfied by α; and if two extra rectangles are in T 0 to cover the clause points of c, then c is unsatisfied by α. See Figure 2.6. Thus, the number of unsatisfied clauses in Φ is equal to the number of clause rectangles in T 0 subtracted by the number of clauses in Φ, which is at most 4m + k − 4m = k. Since 6m of rectangles in T 0 are variable rectangles and there are at most 4m + k clause rectangles in T 0, as |T 0| ≤ |T | = 10m + k. Therefore, the number of rectangles exceeding 10m in T is the maximum number of unsatisfied clauses in Φ.

For example, if c = (Xj ∨ Xl) is not satisﬁed, this means both Xj and Xl are 37

assigned to 0. This means that variable points of both Xj and Xl are covered with

horizontal rectangles, thus none of the clause points of c = (Xj ∨ Xl) are covered by any of its variables’ variable rectangles. This means T 0 has to include both of the clause rectangles of c to cover all the three clause points of this clause. See Figure

2.6 (d). If c = (Xj ∨ Xl) is satisﬁed, this means at least one of Xj or Xl are assigned

0 to 1 by α. Thus, T includes the horizontal variable rectangles of Xj or Xl, which means at least one of the clause points of c is covered with these rectangles and only one clause rectangle is included in T 0 for covering the clause points of c. The proof of the other cases are similar.

Theorem 2.3.4. RBGSC[AARectangles] is APX-hard.

Proof. Consider the CNF formulas Φ, an instance of MaxRM-3SAT with 4m clauses and (B,R,T ) an instance of RBGSC[AARectangle] with 20m rectangles. Assume the optimal solution for Φ has (4m − k) true clauses. Lemma 2.3.2 implies that there is a solution for (B,R,T ) with at most 10m + k red points. In this instance of RBGSC[AARectangles], each object covers a distinct red point, so minimizing the number of covered red points also minimizes the number of objects. This means, there is a solution for (B,R,T ) with at most 10m + k rectangles. Assume that there is a polynomial time algorithm that approximates the mini-

mization problem RBGSC[AARectangle] with factor CAAR, where CAAR > 1. Thus,

the algorithm provides a truth assignment that has at most CAAR(10m + k) rectangles in polynomial time. By Lemma 2.3.3, we can ﬁnd in polynomial time a truth assignment for Φ with at most CAAR(10m + k) − 10m false clauses and at least

4m − CAAR(10m + k) + 10m true clauses. The approximation ratio of this truth assignment in Φ is ρ ≥ (14m − CAAR(10m + k))/(4m − k). 38

Consider CAAR = 1 + δ(), where δ() > for any > 0,

14m − (1 + δ())(10m + k) ρ ≥ 4m − k 14m − (10m + k + δ()(10m + k)) ≥ 4m − k 4m − k − δ()(10m + k) ≥ 4m − k δ()(10m + k) ≥ 1 − 4m − k

By Observation 2.2.5, 0 ≤ k ≤ 2m,

δ()(10m + 2m) ρ ≥ 1 − ≥ 1 − 6δ() 4m − 2m

This shows that if there is a polynomial time (1 + δ())-approximation algorithm for RBGSC[AARectangle], then there is a polynomial time (1−6δ())-approximation algorithm for MaxRM-3SAT. This is a PTAS-reduction from MaxRM-3SAT to RBGSC[AARectangle], where δ() = /6, for any > 0. Since MaxRM-3SAT is APX-hard by Theorem 2.2.6, RBGSC[AARectangle] is APX-hard.

Reduction from SPECIAL-3SC to RBGSC[AARectangle]

In this section, we show how we can modify the presented reduction in [21] from SPECIAL-3CS, a restricted version of Set Cover, to GSC[AARectangle] to show that RBGSC[AARectangle] is APX-hard.

SPECIAL-3SC [21]: we are given universe set U = A ∪ W ∪ X ∪ Y ∪ Z comprising disjoint sets A = {a1, ..., an}, W = {w1, ..., wm}, X = {x1, ..., xm}, Y = {y1, ..., ym}, and Z = {z1, ..., zm} where 2n = 3m. We are also given a family S of 5m subsets of 39

U satisfying the following two conditions: 1) for each a ≤ t ≤ m, there are integers

1 ≤ i < j < k ≤ n such that S contains the sets {ai, wt}, {wt, xt}, {aj, xt, yt},

{yt, zt}, and {ak, zt} (summing over all t given the 5m sets contained in S.) 2) for all 1 ≤ t ≤ n, the element at is in exactly two sets in S. SPECIAL-3SC denotes the Set Cover on universe set U and subset set S.

Chan and Grant showed SPECIAL-3SC is APX-hard by a reduction from minimum vertex cover on 3-regular graphs [21]. Then, they showed a reduction from SPECIAL-3SC to GSC[Fat Axis-Aligned Rectangles]: place the elements of A, in order, on the line segment {(x, x − 2) : x ∈ [1, 1 + ]} and place the elements of A0 = W ∪ X ∪ Y ∪ Z, in order, on the line segment {(x, x + 2) : x ∈ [−1, −1 + ]}, for a suﬃciently small > 0. Then, add 5m axis-aligned rectangles covering {ai, wt},

{wt, xt}, {aj, xt, yt}, {yt, zt}, and {ak, zt} for any 1 ≤ t ≤ m. Figure 1.(C1) of [21] shows these points and rectangles. The following is the modiﬁed reduction for RBGSC[AARectangle].

Reduction from SPECIAL-3SC to RBGSC[AARectangle]: Add m blue points on the line y = x − 2 for the elements in A, and add 5m blue points on

0 the line y = x + 2 for the elements in A = W ∪ X ∪ Y ∪ Z. For each set si ∈ S add the axis-aligned rectangles shown in Figure 2.7. Note that here the rectangles are slightly diﬀerent than the rectangles in [21]. This is to make sure that there is an area in each rectangle which is not covered by any other rectangle. Therefore, we can add a distinct red point to each rectangle. Thus, an optimal solution for RBGSC[AARectangle] that minimizes the number of covered red points also minimizes the number of rectangles and so an optimal solution for SPECIAL-3SC. 40

Figure 2.7: Points and rectangles for Reduction from SPECIAL-3SC to RBGSC[AARectangle]

2.3.2 RBGSC[Convex] and RBGSC[Triangle]

In this section we prove hardness results for RBGSC[Convex] and RBGSC[Triangle] by reductions from Set Cover and Red-Blue Set Cover.

Theorem 2.3.5. For every α > 0 it is NP-hard to approximate RBGSC[Convex] within (1 − α) ln b of the optimum, where b is the number of blue points.

Proof. Suppose that we have an instance of Set Cover, in which X is the set of n elements and T is a family of m subsets of X. The following transformation ψ, transforms this instance of Set Cover to an instance of RBGSC[Convex], where R is the set of red points, B is the set of blue points, and O is the set of convex objects.

ψ takes an arbitrary circle on the plane, and for each element xi ∈ X, ψ adds the blue point bi on the circle. For each subset si ∈ T , ψ adds the red point ri on the circle as shown in Figure 2.8. For set of objects O, for each subset si ∈ T , ψ adds the 41

convex shape oi, which is deﬁned by connecting the red point ri and the blue points

corresponded to si’s members, i.e. oi = ConvexHull({ri} ∪ {bj|xj ∈ si}). In this instance of RGBSC[Convex], each object covers exactly one distinct red point. So, any solution for set cover with size k gives a solution for this instance of RBGSC[Convex] in which k red points are covered. Besides, for any solution of RBGSC[Convex] with k covered red points, there is a solution for set cover with size k. Therefore, approximation Red-Blue Geometric Set Cover with r red points and b blue points, is as hard as approximating Set Cover with b elements and r subsets.

c Theorem 2.3.6. RBGSC[Convex] cannot be approximated to within 2log1−1/(log log m) m in polynomial time for any constant c < 1/2, unless P = NP , where m is the number of given convex objects.

Proof. The proof of this theorem is similar to Theorem 2.3.5. If XB, XR, and T are the

inputs of an instance of Red-Blue Set Cover, for each blue element xbi ∈ XB, add the

blue point bi, on the circle, to B similar to Figure 2.8. For each red element xri ∈ XR,

add the red point ri, on the circle, to R similar to Figure 2.8. For each subset

si ∈ T , add convex shape oi, which is deﬁned by connecting red points and blue points

corresponded to si’s members, i.e. oi = ConvexHull({bj|xbj ∈ si} ∪ {rl|xrl ∈ si}). This implies that RBGSC[Convex] is as hard as Red-Blue Set Cover, which has been shown to be NP-hard to approximate within 2(log m)(1−δ) factor of the optimal for δ = 1/(log log m)c and any constant c < 1/2 [19].

Carr et al. showed that their hardness result holds even in the restricted case that each set in T contains only one blue and two red elements [19]. Here we reduce this version of the Red-Blue Set Cover to RBGSC[Triangle].

c Theorem 2.3.7. RBGSC[Triangle] cannot be approximated to within 2log1−1/(log log m) m in polynomial time for any constant c < 1/2, unless P = NP , where m is the number 42

Figure 2.8: points and convex shapes for the reduction from Set Cover to RBGSC[Convex]

of given triangles.

Proof. This proof is also similar to the proof of Theorem 2.3.5. Assume XB, XR, and T are the inputs of an instance of Red-Blue Set Cover, where each subset si ∈ T

contains only one blue element and two red elements. For each blue element xbi ∈ XB,

add the blue point bi, on the circle, to B similar to Figure 2.8. For each red element

xri ∈ XR, add the red point ri, on the circle, to R similar to Figure 2.8. For each

subset si ∈ T , add the triangle ti, which is deﬁned by connecting the two red points

and the one blue point corresponded to si’s members, i.e. ti = Triangle({bi|xbi ∈

si} ∪ {rl|xrl ∈ si}). This implies that RBGSC[Triangle] is as hard as the restricted version of Red-Blue Set Cover, which has been shown to be NP-hard to approximate within 2(log m)(1−δ) factor of the optimal for δ = 1/(log logc m) and any constant c < 1/2 [19].

The hardness result in Theorem 2.3.7 shows that Red-Blue Geometric Set Cover 43

is strictly harder than Geometric Set Cover, when the objects are triangles. This is because the VC-dimension of triangles in the plane is 7, so the approximation factor of -net based algorithms on GSC[Triangle] is O(log OPT ), which is smaller than the lower bound we showed for RBGSC[Triangle] in Theorem 2.3.7.

2.4 Boxes Class Cover

Here we show that BCC is APX-hard in two ways. First, we demonstrate that the same presented reduction in [11] from Rectilinear Polygon Cover to BCC for showing the NP-hardness of this problem also shows that BCC is APX-hard. Second, we modify the reduction described in Section 2.3.1 to show a reduction from MaxRM-3SAT to BCC.

Rectilinear Polygon Cover(RPC): Given a rectilinear polygon P , ﬁnd a minimum size set of axis-aligned rectangles whose union is exactly P. The idea of the reduction in [11] is to add blue points on the boundary and inside the polygon and add red points outside of the polygon in a way that the only possible non-empty rectangles are the ones that are inside P . Thus, any solution for BCC on these points gives a solution with the same size for RPC. Given that RPC is APX-hard [12], BCC is APX-hard.

2.4.1 Reduction from MaxRM-3SAT to BCC

The idea of the reduction from MaxRM-3SAT to BCC is very similar to the idea of the reduction from MaxRM-3SAT to RBGSC[AARectangle]. f transforms formula Φ, an instance of MaxRM-3SAT, to (R,B), an instance of BCC, in polynomial time. f adds the same blue points that γ adds in Section 2.3.1 for 44

(a) (b)

Region 3 ··· ···

X3m ··· ··· X3 X2 2 Region

· · · · · · · · · · · ·

Region 1

Xj Xj

Xl Xl

(e) In Region 1

Xl 45

(f) In Region 2

Xj+2

Xj+1

Figure 2.9: Reduction from MaxRM-3SAT to BCC. a) The points in the highlighted gray area are variable points for X2. b)Region 1-3. c, d, e, f) Added red points and ¯ blue points for c = (Xj ∨ Xl), d) Added red points and blue points for (Xj ∨ Xl), ¯ ¯ ¯ ¯ c = (Xj ∨ Xl), c = (Xj ∨ Xj+1 ∨ Xj+2). the variables and clauses in Φ. For the set of red points, f adds red points around each blue point in a way that the set of all possible axis-aligned rectangles is limited to the variable rectangles and clause rectangles and the rectangles in the optimal solution of BCC for this instance of the problem are the same as the rectangles in the optimal solution of RBGSC[AARectangle]. Figure 2.9 shows the location of these red points ¯ ¯ ¯ for diﬀerent types of clauses: c) c = (Xj ∨ Xl), d) c = (Xj ∨ Xl), e) c = (Xj ∨ Xl), ¯ ¯ ¯ f)c = (Xj ∨ Xj+1 ∨ Xj+2). For c = (Xj ∨ Xj+1 ∨ Xj+2), added points are similar to part (f) but rotated by −π/2 in Region 3. We can observe that the number of added red points is O(m), and such an instance of BCC is polynomial computable. A rectangle t is a blue-rectangle if t contains only blue points but no red point. We can observe that blue-rectangles in any solution for BCC can be expanded to reach a red point without any change in the size of the solution. We call the set of all expanded possible axis-aligned rectangles maximal rectangles. 46

Theorem 2.4.1. BCC is APX-hard.

Proof. The proof of this theorem is similar to the proof of Theorem 2.3.4. In the instance of BCC created by f, the set of maximal blue-rectangles is the same as the set of rectangles of RBGSC[AARectangle] in Section 2.3.1 produced by γ. In BCC, the goal is to minimize the number of rectangles to cover all the blue points, which is the same as minimizing the number of covered red points in RBGSC[AARectangle] when each rectangle covers only one distinct red point. Therefore, any solution for this instance of BCC is a solution for the instance of RBGSC[AARectangle] produced by γ. Thus, both Lemmas 2.3.2 and 2.3.3 are true for BCC as well. This means exactly similar to the proof of Theorem 2.3.4 we can show that there is a PTAS-reduction form MaxRM-3SAT to BCC.

2.5 Conclusion and Open Problems

We present proofs of hardness of approximation for some geometric problems listed below:

• RBGSC[Axis-Aligned Rectangles] is APX-hard.

• RBGSC[Triangle] and RBGSC[Convex] cannot be approximated to within

c 2log1−1/(log log m) m in polynomial time for any constant c < 1/2, unless P = NP , where m is the number of given triangles or convex objects.

• Boxes Class Cover for axis-aligned rectangles is APX-hard.

These results show that there is a class of objects, triangles, for which approximating Red-Blue Geometric Set Cover is strictly harder than approximating Geometric Set Cover. 47

We also deﬁne a new version of Max3SAT, MaxRM-3SAT, in Deﬁnition 2.2.1, and then prove that this problem is also APX-hard.

Open problems that are raised by these results are: (1) In this research we showed that there is a class of objects, for which approximating Red-Blue Geometric Set Cover is strictly harder than approximating Geometric Set Cover. Is it possible show a relation between the complexity of Geometric Set Cover and Red-Blue Geometric Set Cover for all classes of objects? (2) Is it possible to design an algorithm with better approximation ratio for Red- Blue Geometric Set Cover when the objects are axis-aligned rectangles, triangles, or other simple geometric objects? The only known algorithm for these problems is the one that is designed for the non-geometric version. (3) The best approximation ratio for both BCC and Geometric Set Cover for axis- aligned rectangles is O(log OPT ), which is based on the fact that both has constant VC-dimension. Is it possible to develop an algorithm to solve BCC with a better approximation ratio? (4) Geometric Set Cover for axis-aligned rectangles is a closely related problem. There is a big gap between the ratio of the best approximation algorithm and the proven hardness of approximation for this fundamental and important problem. This problem has been shown to be APX-hard, but the best approximation ratio is O(log OPT ) for the case that the objects are axis-aligned rectangles. However Hitting Set there is an -net based O(log log OPT )-approximation algorithm for axis- aligned rectangles. Is it possible to improve the approximation ratio or the hardness of approximation of this problem and reduce this gap? 48

Chapter 3 Distributed Geometric Networks

In this chapter we study the communication cost needed to solve several fundamental geometry problems, including Convex Hull, Diameter, and Closest Pair. We find approximation algorithms which use o(m) communication, for m sufficiently large, in the asynchronous CONGEST KT1 model in fixed-link model, where m is the number of edges of the communication graph. Our lower bounds hold for the randomized asynchronous KT1 model and therefore in the KT0 model as well. In Section 3.1 we describe preliminaries including definitions, background and related works. We formally define and discuss our model, which is called fixed-link model, in Section 3.1.2. In Section 3.2 we define the Path Computation problem. We prove lower-bounds for Path Computation, which will be used as a building block for our other lower bounds. In Section 3.3 we define and discuss Diameter, Convex Hull, and the -kernel problems. We propose algorithms and prove lower bounds for these problems. In Section 3.4 we define the Closest Pair problem, and present algorithms as well as lower bounds for this. Finally, in Section 3.5 we conclude this research and discuss possible future work. 49

3.1 Preliminaries and Background

In this section we describe preliminaries and background to Distributed Networks, Geometric Networks, Two-Party Communication, and Coresets. We also discuss how each topic relates to our research and will be used. We deﬁne and discuss our model, ﬁxed-link model in the section dedicated to Geometric Networks, Section 3.1.2, and Compare our model to other Geometric Networks.

3.1.1 Distributed Networks

A distributed system has a set of processors that each have a local memory and its own input, and they work together toward a common goal. Here, we consider peer-to- peer message passing models. In this model the only way to communicate is to pass messages, and the processors can send messages to others with no need to send the messages to a server. A distributed protocol or a distributed algorithm is the way or strategy that the processors use to compute the common goal, and all the processors run the same algorithm. The communications network is a formal way to model communication in distributed systems. A communication network is a graph in which each node has only local information about the graph and the nodes communicate by passing messages along its edges. More formally, the communication network is a connected graph G = (V,E), where |V | = n, D denotes the diameter of the graph, and each node in V represents a processor. Each edge in E represents a two-way communication link. Two nodes can communicate directly to each other if only there is an edge between them. For example, the communication network is a complete graph in Congested Clique model, or the communication network is an intersection graph in some ad-hoc networks. 50

To deﬁne a distributed system we need to determine some factors that are deﬁned below.

• Message Passing Model: The message passing model depends on multiple factors: synchrony, size of messages, and the order of messages.

In the synchronous message passing there is a global clock, and messages are sent in rounds. In each round of a synchronous distributed algorithm, ﬁrst, the messages are sent, then all the messages are delivered and nodes do their local computation. In this model, on one edge messages are received in the same order that they were sent.

In the asynchronous message passing there is no global clock, and nodes work at their own pace. Messages are event-driven and might be sent in diﬀerent times, and they might delay and take diﬀerent amount of time to be received, though all messages sent eventually arrive. Messages are not necessarily received in the same order that they were sent on one edge. We assume all nodes wake up at the start of the algorithm. Aside from an initial wake-up, actions are event-driven.

The size of the messages in both synchronous and asynchronous may vary depend on the model. In the LOCAL model there is no limit on the amount of information that one node can send in one message. In the CONGEST model a single node can send a messages that contain only O(log n) bits to all of its neighbors in each round. In both of these models a single node can send diﬀerent messages to all of its neighbours in each round.

• ID of Processors: In a distributed system the processors can be anonymous or they can have identiﬁers. In the anonymous system, nodes do not have unique 51

names or identifiers, but each neighbour of a node has a local particular port number for that node. In a model with identifiers, each node has a unique global identifier which is called ID. IDs can be from any size, but usually they have O(log n) bits.

• Input: The input of each node can be diﬀerent from other nodes’ input. The input of each node gives local or global knowledge to the node depending on the model as described below:

Local Knowledge: In the KT0 model, each node initially only knows ports it has but does not know the ID of its neighbours. In KT1 model, each node initially knows the ID of its neighbours. So, the input of each node in this model is the set of IDs of the node’s neighbour.

Global Knowledge: In a distributed system nodes do not know the global topology of the communication network, and they only have local knowledge about the network. However, processors might know the number of the nodes in the network or an estimation of it.

• Failure: There are distributed systems that can model some types of failure, such as node failure, Byzantine fault, and message failure. In this dissertation we assume there is no failure in the system.

Performance Measures

The performance of a distributed algorithm (also referred to as a protocol) for a given network is measured by diﬀerent factors such as message complexity and time complexity based on the communication between processors. In this dissertation we do not consider the local computation time and memory as the cost of the algorithm, but we avoid abusing this assumption by only computing polynomial time tasks in 52

any processor. The communication complexity of an algorithm on a network with n nodes and m edges is a function f(m, n) that measures the expected number of bits or messages used over the worst case input and scheduling delays. The complexity of a problem is the minimum complexity over all algorithms which correctly solve the problem. Time complexity of an algorithm in the asynchronous model on a network with n nodes and m edges is a function f(m, n) that measures the length of the longest chain of events (receipt of a message) in which each event is waiting for the previous event to occur over the worst case input and scheduling delays. Time complexity of an algorithm in the synchronous model on a network with n nodes and m edges is a function f(m, n) that measures the number of rounds or time units that the algorithm runs over the worst case input.

Spanning Tree, Broadcasting, and Leader Election

In a distributed system, the goal of Spanning Tree problem is to work together and ﬁnd a spanning tree for the communication graph. More speciﬁcally, each node knows if each of its edges is selected to be in the spanning tree or not at the end of the algorithm. We use the following results extensively. Note that both the following algorithms are randomized Monte Carlo and succeed with high probability. A Monte Carlo algorithm is a randomized algorithm whose output may be incorrect with a certain probability, and we say the algorithm succeeds with high probability if the probability

1 of success is more than 1 − nc for any constant c > 0, where n is the size of the input. 53

• Theorem 3.1.1 ([54]). Given any network of n nodes where all nodes awake at the start, a spanning tree and a minimum spanning tree can be built with O˜(min{n3/2, m}) messages of size O(log n) with high probability of success.

O˜ notation means ignoring the logarithmic factors, i.e. O˜(h(n)) = O(h(n) logk n) for some constant k.

• In CONGEST KT1, there is a synchronous algorithm which runs in time and communication O˜(n) [46].

• In CONGEST KT0, Ω(m) messages are required to construct a spanning tree in the synchronous (and asynchronous) model [48, 49].

In the problem of Broadcasting the goal is to spread information throughout a network from a speciﬁed processor to all the other processors. In Leader Election the goal is to work together and select one of the processors as the leader. More speciﬁcally, the goal is that each node knows if it has been selected to be the leader or not at the end of the algorithm; or each processor should know the ID of the leader at the end of the algorithm.

Background for Distributed Networks

Variants of communication networks have been studied which are distinguished by the types of messages, the existence of a global clock (synchronous vs. asynchronous), and the amount of local knowledge known to the nodes [8, 61]. The spanning tree and broadcasting were long believed to need Ω(m) bits of communication in a distributed message passing model. This was ﬁrst proved in the CONGEST KT1 model where each message could contain information about only a constant number of node IDs (atomic model) or the node ID space is exceedingly 54

large, beyond polynomial in size, in 1990 [8]. It was also shown in the CONGEST KT0 model, when each node does not know the ID’s of its neighbors [48, 49]. In 2015, the first algorithm to find a minimum spanning tree (and spanning tree) with O˜(n) messages in the CONGEST KT1 model was designed for the synchronous model [46], √ followed by an O˜(n3/2) message-algorithm with the optimal time steps Θ(D + n) in 2018 [32, 33] and an O˜(n3/2) message algorithm for the asynchronous CONGEST KT1 model was designed in 2018 [54, 55]. [33] also explores other tradeoffs between time and messages for this problem in the synchronous model. A natural question to ask is what other interesting graph problems can be solved in o(m) communication and polynomial time in a message passing network. Recently, Robinson proved time-communication tradeoffs in the synchronous CONGEST KT1 model for the problem of constructing a graph spanner [66]. They show a lower bound on the communication complexity of computing a (2t − 1)-spanner that

1 1 log n 1+ t + 1 consists of at most O(n ) edges, where = θ( t2 ) and 2 ≤ t ≤ O(( log log n ) /3). 1 1 ˜ 1+ 2t Any O(poly(n))-time algorithm requires at least Ω( t2 n ) bits of communication in CONGEST KT1 model. Prior to this work only a trivial lower bound of Ω(˜ n) bits was known. Comparing this result with the result of [46] shows that computing a minimum spanning tree can be done faster than ﬁnding a spanner.

3.1.2 Geometric Networks

In geometric networks, each node of the communication network occupies a point on the plane, and the distance between points is the Euclidean distance. There are two types of geometric networks regarding the positions of the nodes, static and dynamic, which we will describe below.

• In static networks, such as ﬁxed-position model, the positions of the nodes do 55

not change, and the topology of the communication graph is also ﬁxed. This model has been used in [64], where the communication graph is a planar graph that the edges are straight lines segments where no two of them intersect, and the ID of each node is equal to the coordinates of the point on the plane.

• In dynamic networks, such as wireless ad-hoc, in which the nodes are moving and their positions are changing, nodes can communicate if and only if they are within a short distance of each other. For example in the Unit Disk Graph model, two nodes are connected if their distance is at most one unit. Thus in this model, the communication network is also changing, since the nodes are moving.

Hybrid ad hoc networks model the communication in two layers: one for local communication, similar to ad-hoc networks, and one for sending a direct message to any node but with more cost. For example, a set of mobile nodes that each have a cell phone and a wireless device. Nodes can send message via wireless communication if a node is within a range, otherwise they can call the other node. Jung et al. in [45] model a cell phone network as a hybrid directed graph, in which each node can move and has a unique phone number (ID) and there is a Unit Disk Graph to model local communication using their Wifi interface. A node u can send a message to node v if u is within a distance one from v, or if u learns the phone number(ID) of v. The fixed-link model, considered here, can be used as a dynamic model in which the communication graph has a static arbitrary topology. The nodes are moving, but the communication graph is not changing. Here we will define our model, then we compare it with other known geometric models and describe what related problems have been investigated in those. 56

Fixed-Link Models

In our model the communication graph is a connected graph G = (V,E), where each node in V is located at a distinct point specified by (px, py) where px, py are integers between 1 and nc, and c > 0 is a constant. Each node has a unique ID of O(log n) length. Each node knows its own ID and position. Unless otherwise specified, we assume the CONGEST KT1 asynchronous model. That is, each node knows the ID’s of its neighbours but not their positions. We write CONGEST-1 when we assume the message size is one bit. Nodes in the fixed-link model have private randomness, that is, the outcome of their coin flips, which may determine their actions, are not known to other nodes. The network is specified before those random bits are generated. The delay in transmitting a message may depend on the contents of all messages sent so far, including that message, but is independent of the outcomes of coin flips which have not yet been executed. We call this a fixed-link model.

The goal of our research is to study the communication complexity of fundamental computational geometry problems (Convex Hull, Diameter, and Closest Pair) in this setting. This new model can be motivated, for instance, in the situation that the communication network is ﬁxed or changes occasionally, but the positions of the processors are changing. For example, we may represent a network of mobile devices in this model, where the positions of the nodes are changing but the topology of the underlying communication network is unchanging. In our model the communication graph is a graph with arbitrary topology unlike the Unit Disk Graphs that depends on node positions.

There is a simple algorithm to solve any problem on the network where each node needs to learn only O(log n) bits of information. Once a spanning tree is constructed, 57

it suﬃces to send the location of all points to a central location which then computes the answer and sends each node the information required. In the asynchronous CONGEST KT0 model a spanning tree and a leader can be computed in O(m) communication and O(n) time. Furthermore, every node can send the coordinates of their location to the leader using the spanning tree, and this takes no more than n messages of size O(log n) for any node. The leader computes the solution of the problem, then uses the spanning tree to send the solution to every node with no more than n messages for any node. Hence any problem where each node needs to learn an O(log n) bit solution can be solved in O(n2) messages in the weakest model, asynchronous CONGEST KT0. We prove these bounds on communication are optimal within a log n factor for the problems we consider.

Related Work to Geometric Networks

Our work extends the work of Rajsbaum and Urrutia [64], the only paper known to the authors which addresses the communication complexity of a geometric communication network in the fixed-position model. That paper considers the problems of finding a convex hull and external face in an asynchronous planar network. In their model edges are straight lines segments connecting pairs of vertices, such that no two of them intersect. Their model is a fixed-position model, where the ID of each node is equal to the coordinates of the point on the plane. The model used in [64] does not require that each node knows the IDs of its neighbors (KT0), since there are only O(n) edges in a planar graph and each node can afford to learn its neighbor’s IDs by communicating with them. To achieve its lower bounds, it requires the additional assumption that each message may contain information about only a constant number of node IDs (atomic model). They obtain an O(n log2 n) message complexity algorithm to find the convex hull, and an O(n log n) message complexity algorithm to identify the external 58

face of a geometric planar network with n processors. They present a matching lower bound for the external face problem. They also prove that the message complexity of leader election in a geometric ring is Ω(n log n). There are many distributed models for dynamic networks. For example, in mobile ad-hoc Networks and Wireless Networks the communication graph is often a Unit Disk Graph. Many distributed and geometric problems have been studied in these models, such as routing, broadcasting, minimum spanning tree, and spanners [16, 51, 50, 31, 72], where they mainly address the time complexity of these problems.

3.1.3 Two-Party Communication

The Set Disjointness problem is a well-studied problem in the literature on two-party communication. We reduce it to our problems to prove our lower bounds. Here we review two-party communication and Set Disjointness. In the basic two-party communication model, Alice knows x, Bob knows y and the goal is to evaluate a function f(x, y). The players communicate to each other via a two-way channel, and we assume messages arrive as soon as they are sent. The algorithm is described by a protocol tree where each internal node is labeled by a player who sends a message, each leaf is labeled with an outcome for f(x, y), and the tree branches depending on the value of the message string. The cost of the protocol is the length of the longest path from the root to the leaf. A protocol with private randomness also contains nodes where the player ﬂips a coin. With public randomness, the randomness is revealed to both of the players at the start of the protocol, and there is a distribution of deterministic tree protocols. Alice and Bob choose a random string independent of (x, y) at the start of the protocol. If we allow randomness (either private or public) then for any given input 59

(x, y), there are two arbitrary length random strings rA and rB. Each internal node in the decision tree outputs 1 or 0 according to a function that depends on the node’s position in the tree and (x, rA) or (y, rB). Then, there is a probability of reaching a particular leaf, and the expected cost of the protocol on an input (x, y) is the expected number of bits needed to be communicated over all choices of the random strings to reach a leaf. We consider the worst case expected cost of the randomized algorithm to be the worst case cost over all inputs. The communication complexity of a problem is the maximum over all inputs of a ﬁxed size of the expected cost. When we allow randomization, protocols might have errors. Let P be a randomized protocol. P computes a function f with -error if for every (x, y), P r[P (x, y) = f(x, y)] ≥ 1 − over the random choices of the random strings [47].

The following well-studied problem will be used as a basis for proving lower bounds in this research:

• Set Disjointness: Alice has set A and Bob has set B, A and B ⊂ {1, 2, ..., n}. Give a two party communication protocol to answer if A ∩ B = ∅.

No algorithm can do better asymptotically than the one where Alice sends the n bit characteristic vector of A to Bob, and Bob returns the one bit solution to Alice.

Theorem 3.1.2. [69, 65, 34] Alice has set A and Bob has set B, A and B ⊂ {1, 2, ..., n}. Any randomized two party communication protocol to answer if A∩B = ∅ requires Ω(n) bits of communication to achieve a constant error probability c, for any c < 1/2, even if there is public randomness.

Related Work to Two-Party Communication

A reduction of two-party Set Disjointness has been used to prove lower bounds on time in the CONGEST model in CONGEST KT1, for example, on veriﬁcation problems 60

on graphs, by Das Sarma et al. in 2011 [67, 68]. A synchronous model for two-party communication with a global clock was introduced by Impagliazzo and Williams [43], and time-communication tradeoﬀs are given. The basic two-party model assumes messages arrive as soon as they are sent but there is no notion of a global clock, so that information is not gained if Alice waits or sends an empty message. In a 2010 paper, Impagliazzo and Williams introduced the synchronous bit two-party communication model in which there is a global clock. In this model, the levels of the protocol tree represent time steps, and at each time step, a party may send a 0,1, or ∗ , where ∗ means no message is sent. Cost is measured by the number of 0’s and 1’s sent. It is easy to see that Alice can communicate the contents of an n bit string by sending a 1 at time equal to the value of the string and no other messages. There are clearly communication, time tradeoﬀs. For example, Alice can send an n bit string by sending one bit in exponential time equal to the value of the string. Or, in general with time polynomial in n, Alice can send an n bit string using a cost of n/ log n in this model. See [43, 66]. Hence it does not make sense to talk about a lower bound on communication costs here without an upper bound on the time. In this dissertation, we prove lower bounds on communication cost in models with no global clock.

3.1.4 Coreset

Our approximation algorithms for Diameter and Convex Hull ﬁnd an -kernel of the points and use this to solve the problem. An -kernel is a type of coreset, which we will review here. An -kernel of a set of points P is a subset of P whose convex hull approximates the convex hull of P with respect to directional width, i.e. an -kernel approximates 61

the convex hull of the point set in any direction [1]. -hull is also an approximation for Convex Hull but with a diﬀerent measure. An -hull of a set of points P is a subset of the points such that every point in P is within distance from the convex hull of the subset. Having an -kernel provides an f()-coreset for many extent related problems, such as minimum enclosing ball, minimum enclosing box, diameter, and width.

Background for Coreset

The idea of finding a coreset has been used in parallel and distribute settings. A coreset is specifically useful in distributed setting as coresets can be computed in parallel. Feldman and Sugaya designed an effective coreset algorithm by merging coresets in Sensor Networks for a version of the k-line center problem in the parallel setting, where they ignore the communication cost [30]. Balcan et al. proposed distributed algorithms for the k-means and k-median problems, where each node constructs a portion of the coreset [9]. In this paper, the data is distributed across nodes whose communication is restricted to the edges of an arbitrary graph. The input of each node is a set of points, and the goal is to find k-means and k-median of the union of the input points of all the nodes. The authors propose algorithms for finding small coresets with the focus to reduce the communication cost. Much effort has been done to find a fast algorithm that computes a small -kernel in the sequential model. There is also extensive work for approximating Convex Hull in the streaming model [40, 1, 20, 15, 4]. The first one-pass streaming algorithm for computing - hull of a point set on the plane was proposed by Hershberger and √ Suri, and this algorithm uses O(1/ ) space [40]. The algorithm proposed by Arya

(d−1/2) 1 and Chan uses O(1/ log ) space for computing -kernel of a point set in d dimension [4]. 62

A composable coreset has the property that for a collection of sets, the approximate solution to the union of the sets in the collection can be obtained given the union of the composable coreset. Composable coresets can be used to obtain eﬃcient solutions in streaming and distributed models [1, 44]:

• Streaming: If we have a composable coreset of size k, then we divide the data q √ stream of n elements to n/k blocks each of size nk. The algorithm ﬁnds the coreset of each block and stores the coresets separately until the end of the algorithm and solves the problem for the union of the coresets, or the algorithm might do a compression, in which the coresets get combined during the algorithm to reduce the amount of space but this might increase the approximation factor.

• Distributed: Each processor ﬁnds a coreset of its own part of the data and sends it to a server, and server solves the problem for the union of the coresets. Alternatively, the algorithm can have a compression in which processors can send their data or coreset to a local server, and the local server combines the coresets.

Similar ideas have been used to show lower bounds in these two models, as it is common in both of these models to use reductions from communication complexity problems. However, to the best of our knowledge no general relation has been shown between these two models and we cannot necessarily interpret a lower bound in one model in another one. In this research we show lower-bounds for the problems that have have known lower bounds in the streaming model. [29] shows that the diameter and closest pair problems need Ω(n) bits space in the streaming model even if we are allowed to have multiple passes through the input, where n is the number of the input data and each input can be described in O(log n) bits. They also show 63

that a version of the convex hull problem in which the input point set is guaranteed to admit a convex hull with at most k sides, k-promised convex hull, requires Ω(n) space in the one-pass streaming model. They show these results by reductions from communication complexity problems, Set Disjointness and Index.

3.2 Path Computation

In this section, we formulate and analyze the path computation problem. Then, we use two-party communication lower bounds to prove a lower bound on Path Compu- tation. For any two-party function f, we can deﬁne a problem in a communication network consisting of a path.

• Path Computation of f We are given a function f(x, y) and a communication network which consists of

a path P = (v0, v1, v2, ..., vm), where v0 = Alice, vm = Bob. Alice knows x, Bob knows y, and all the nodes know m and n, where n is the size of the input, i.e. n = |x| + |y|. Assume Alice and Bob awake at the start. Nodes pass messages until every node in P learns f(x, y).

One of the naive solutions for Path Computation is that Alice sends x to Bob by passing exactly x itself through the whole path, and Bob passing y or f(x, y) to Alice similarly. Thus, if x and y are n-bit strings and the path has m + 1 nodes including Alice and Bob, this approach uses at least ln bits of communication to send only x to Bob. Here we explain one way that we save some communication in Path Computation problem compared to the naive strategy. 64

√ The idea of the algorithm is to assign m distinct bit-strings to each node node in the path, and every node knows the assigned strings for themselves and their neighbours’, and the order of them. If node i wants to send an n-bit message x to the node i + 1, checks if the last log n bit of the message (suﬃx(x, log n)), is included in the the assigned strings for i + 1, if yes, replaces the suﬃx(x, log n) with the index of the string, and sends it. Otherwise, sends the message x with no change. The receiver can distinguish whether the message has changed (compress) by checking the size of the message, if the size is less than n, then the messages has changed (compressed) and needs to be decompressed. Assume x and y are n-bit strings, and Alice wants to send x to Bob. In the following algorithm we assume that the nodes are labeled 0 to m, and n ≤ m. Given

{p0, p1, ..., pm}, the goal is to send n-bits of information from p0 to pm. Every node runs this protocol independently upon wake up. All the nodes know n, m, and the √ function F : N → Si, where N = [0, m] and Si is an ordered set of m distinct bit- S √ string each of length log n bits, such that the multiset 1≤i≤m Si has at last m copies of all the members of {0, 1}log n. In other words, any possible string of length log n is √ repeated m times in the multiset union of the function’s image. In this algorithm the ith node in the path that receives a message, first decompresses the message by using the decompress function, defined as below. Then the node compresses the result by computing the compress function, as defined below, and sends the result to the next node. These two functions are defined below.

decompressi(x) =   x if |x| = n

 preﬁx(x, n − log n).Si[suﬃx(x, log n/2)] otherwise

When the node i sends message x to node i + 1,

compressi(x) = 65

  prefix(x, n − log n).index(Si+1, suffix(x, log n)) if suffix(x, log n) ∈ Si+1

 x otherwise

where suffix(x, k) is the last k bits of x, prefix(x, k) is the first k bits of x, Si[k] is

the kth array in Si, index(S, x) is the index of the string x in S, and “.” denotes concatenation.

Algorithm 1 Path Computation 1: procedure path(i)

2: p0 computes compress0(x) and sends it to p1.

3: When pm receives the message x, computes decompressm(x).

4: When pi receives the message x from pi−1, computes compressi(x) and sends

it to pi+1.

5: end procedure

√ Analysis of Algorithm 1: For any given x, suﬃx(x, log n) appears at least m S times in multiset union of 1≤i≤m Si. Thus, the compress function is called at least √ m times during the algorithm. A compressed message has log n/2 bits less than √ other messages, and this means the algorithm saves log n/2 bits at least m times √ for each compressed messages. Thus, the algorithm uses at most mn − m log n/2 bits of communication.

Theorem 3.2.1. There exists a protocol which computes Path Computation of √ f(x, y) = x for a path of m + 1 nodes with mn − m log n/2 bits of communication, where |x|, |y| = n.

As we can see the complexity of Path Computation Problem is not obvious. In the next section we prove a lower bound for Path Computation problem. 66

3.2.1 Path Computation Lower Bounds

Theorem 3.2.2. Let C2(f) be the randomized complexity of f in the basic two-party communication model with private randomness. Then the randomized complexity of the Path Computation of f in the CONGEST-b KT1 model where each message has

m b bits is at least Ω( b (C2(f) − lg m)), where m is the length of the path.

We first prove this for b = 1 and for a model with a restricted adversary which we call the restricted model or r-asynchronous CONGEST-1 KT1. The restricted model takes away adversary control over the order in which messages are received, while there is still no global clock, as in the basic two-party communication model. Hence the adversary only controls the inputs. E.g, messages are received in the order they are sent; where there is choice as to which of two messages is received from two different neighbors, the message from the lower numbered node is received first; and if these rules leave a choice as to which of two messages to be sent first in opposite directions over the same link, the message from the lower numbered node is sent first. The nodes in the path have ID’s (0, 1, ..., m). In the proofs below, the term “path protocol" refers to an algorithm to solve Path Computation of f, in the r-asynchronous CONGEST-b KT1 model. Now we show:

Lemma 3.2.3. For every path protocol in the asynchronous model which sends an expected k bits across any edge {i, i + 1} there is a two-party communications protocol with private randomness and expected cost no greater than k.

Proof. We show how to construct decision trees for a randomized two-party protocols (with private randomness) from the asynchronous protocol with a suitably deﬁned schedule for delivery of messages. Let path A = [0, 1, ..., i] and path B = [i + 1, ..., n]. The schedule consists of iterations with two parts. In part (a) messages from i to 67

i + 1 and in path B are kept waiting; in part (b), messages from i + 1 to i and in path A are kept waiting.

(a) For a given rA and x, Alice simulates the nodes and their coinﬂips on the path from 0 to i, assuming the any message delivery schedule which completes all

deliveries between nodes on path A, and uses rA to determine the random coinﬂips in the distributed protocol as needed, until all messages which would be sent from i to i + 1 in the asynchronous model (without receiving more messages from i + 1 ) are sent by A in the order in which they would be sent by i. These are received by i + 1.

(b) The messages from part (a) are received by i + 1. For a given rB and y, Bob similarly simulates the actions of the nodes in path B, and determines and sends all the messages i+1 would send to i in the order these would be sent (without receiving more messages from i). The messages sent from i + 1 are received by i. We observe the followings:

• For a given (rA, x), (rB, y) each iteration extends a path in a two-party protocol’s

decision tree whose nodes are labeled ﬁrst by (rA, x) and then by (rB, y).

• The expected number of bits exchanged between i and i + 1 is the expected number of bits exchanged by i and i+1 in the asynchronous distributed network with the particular schedule of message delivery as described.

This completes the proof.

Lemma 3.2.4. For every path protocol in the r-asynchronous CONGEST-1 KT1 model, for every edge, there is at least one input which requires an expected C2(f) bits to be communicated over that edge.

Proof. Assume by contradiction that e = {i, i + 1} is the edge closest to 0 which carries an expected l < C2(f) bits of communication for all input. By Lemma 3.2.3, 68

there is a two-party protocol P which uses no more than an expected l bits of com-

munication for all input, contradicting the lower bound of C2(f).

Lemma 3.2.5. Suppose there is a path protocol P such that in the r-asynchronous CONGEST-1 KT1 model for f on input I the expected communication cost is no

greater than CP (I) for a path of length m. Then there is a randomized path protocol P0 such that the expected number of bits communicated across any edge is no greater than CP (I)/m + dlg me.

Proof. We will deﬁne a protocol P0 which simulates P. We assume the ﬁrst and last nodes wake up.

1. Node 0 randomly picks a number a ∈ {0, 1, ..., m−1} and communicates a down the path to node m using dlg me bits per edge.

2. Node 0 simulates the nodes in [0, a] and forwards whatever message M that a would have sent to a + 1 down the path to m.

3. After node m receives the value a, it simulates the nodes in [a + 1, m]. When a+1 would send a message M 0 to a in the simulation, node m sends this message down the path to node 0.

4. All nodes a0 ∈ {1, ..., m − 1} upon receiving a message from a0 − 1 passes it to node a0 + 1 and upon receiving a message from a0 + 1 passes it to a0 − 1.

Let CP (I) denote the expected communication cost for input I under protocol P.

Pm−1 We can write CP (I) = i=0 cP (i, i + 1,I) + cP (i + 1, i, I), where cP (d, e, I) denotes the expected number of bits sent from node d to node e under protocol P on input I. We observe that when P0 passes b bits from node 0 to node m or from node m to node 0, the bits arrive at m and the communication cost over all the edges is mb. 69

Then, by this observation, for any input I, for a given choice of a, and for any edge in the path, under P0, the communication per edge (in both directions) is no greater than dlg me plus the communication cost cP (a, a + 1,I) + cP (a + 1, a, I). Taking the expectation over all choices of a chosen uniformly at random, we have that the expected number of bits sent over any one edge {i, i + 1} in both directions by P0 on

input I, cP0 (i, i + 1,I) + cP0 (i, i − 1,I) is:

m−1 X ≤ dlg me + P r(a = i)[cP (i, i + 1,I) + cP (i + 1, i, I)] i=0 m−1 X = dlg me + 1/m[ cP (i, i + 1,I) + cP (i + 1, i, I)] i=0

= dlg me + (1/m)CP (I)

This completes the proof of the lemma. The proof of Theorem 3.2.2 follows: By Lemma 3.2.4, we know that for any protocol P0 and any edge {i, i + 1}, there is some I such that the expected number of

bits passed in both directions over that edge cP0 (i, i + 1,I) + cP0 (i + 1, i, I) ≥ C2(f).

Hence by Lemma 3.2.5, (1/m)CP (I) + dlg me ≥ C2(f) which implies that CP (I) ≥ m(C2(f)−dlg me). Let P be the optimal algorithm for the path computation of f and I be its worst case input, then the communication complexity for the r-asynchronous

CONGEST KT1 model Cm,r(f) ≥ CP (f, I) ≥ m(C2(f) − dlg me). We observe that the lower bound for the asynchronous CONGEST-1 KT1 model

Cm(f) ≥ Cm,r(f) since the restricted model can be simulated by an adversary strategy in the non-restricted model. If we consider the CONGEST-b KT1 model, then as b bits are communicated with each message, we can conclude that the complexity of

m computing f in this model is at least Cm(f)/b or b (C2(f) − dlg me).

Corollary 3.2.6. The communication cost of computing Set Disjointness of size n over a path of length O(n) is Ω(n2/ lg n) messages of size size O(log n). 70

3.3 Diameter and Convex Hull

We consider the following problems deﬁned in the ﬁxed-link model. In Convex Hull, we require that each node learns whether it is on the convex hull or not, and if so, the IDs of both its neighbours in the convex hull. For the Diameter problems, we require that every node learns the solution.

• Convex Hull: Compute the convex hull of the geometric communication network, which is the smallest convex shape that contains all the points.

• Diameter: Determine the diameter of the geometric communication network, which is the furthest distance between any pair of points.

We find approximation algorithms which use o(m) communication when m is sufficiently large, in the asynchronous CONGEST KT1 model, which enables us to initially randomly construct a spanning tree in o(m) communication for dense networks, see Theorem 3.1.1. The other parts of the algorithms are deterministic and can be done in the KT0 model. We state the communication cost of each of our algorithms as a function of the communication needed to build the spanning tree on n nodes, plus the communication needed for the other part of the algorithm. The algorithms for Approximate Diameter and Convex Hull first find a small set of representative points which is an -kernel of the points, and use this to solve the problem. We show lower bounds of Ω(n2) bits on the expected communication needed for exact solutions for Diameter and Convex Hull. Our lower bounds hold for the randomized asynchronous KT1 model (and therefore in the KT0 model). We prove nearly matching lower bounds for the exact problems, as well as the lower bounds for the approximation results, by showing that each of our problems embeds a Path 71

Communication problem as described in the previous section.

3.3.1 -Kernel

Let Sd−1 denote the unit sphere centered at the origin in Rd. For any set P of points in Rd, a point u ∈ Sd−1 is called a direction. Given a set of points P ∈ Rd, the directional width of P in direction u, denoted w(u, P ) = maxp∈P < u, p > −minp∈P < u, p >, where < ., . > is the standard inner product. An -kernel of P is a subset of P which approximates P with respect to directional width. More formally: A subset Q ⊂ P is called an -kernel of P if for each u ∈ Sd−1, (1 − )w(u, P ) ≤ w(u, Q) [1, 2]. In this research, d = 2. Algorithm 2 computes an -kernel of the set of points in R2 by using the idea of rounding directions, which was introduced in [3]. √ Let loc(p) denote the position of node p. Let 0 < < 1 and δ = 2. In Algorithm 2, A is the set of lines passing through (0, 0) which, with the x-axis, make √ angles δ ∗ i for i = 1, ..., dπ/δe, and |A| = Θ(1/ ). Given a set of points P and a line a through the origin, the extreme points for the line is the pair of points r and s in P whose projections onto the line are furthest apart on the line: r is a point such that

< r, u >= maxp∈P < u, p > and s is a point such that < s, u >= minp∈P < u, p >, where < ., . > is the standard inner product. A spanning tree ST is ﬁrst constructed by Theorem 3.1.1. Starting with the leaves of ST , each node compares its own location with the location of the extreme points received from its children (if it is not a leaf) to ﬁnd the best two candidates for the extreme points for each direction, and sends them to its parent, until eventually the root receives all the extreme points. The set SL of these extreme points is an -kernel for this set of points.

Theorem 3.3.1. SL is an -kernel for the point set P . 72

Algorithm 2 Asynchronous -Kernel 1: procedure -Kernel(P is a set of n nodes) 2: Find a spanning tree ST with leader L. 3: L broadcasts < start > when ST is complete. 4: When a leaf p receives < start >, it sends Sp = {loc(p)} to its parent. 5: When a non-leaf node p 6= L receives Sq from all of its children q, p computes S the set Sp of extreme points for all lines in A among the point set q Sq ∪{loc(p)} and passes Sp to its parent. 6: When p = L receives Sq from all of its children q, L computes the set SL of S extreme points for all lines in A among the point set q Sq ∪ {loc(L)}. 7: end procedure

Proof. Given any pair of points p, q, let d(p, q) denote the distance between points p

and q, and let pa denote the projection of point p onto line a. Let S denote the unit sphere centered at the origin in R2, we need to show that for any direction a∗ ∈ S, there is a direction a ∈ A such that for any p, q ∈ P ,

(1 − )d(pa∗, qa∗) ≤ d(pa, qa)

So it is suﬃcient to show (1 − )d(p, q) ≤ d(pa, qa), as d(pa∗, qa∗) ≤ d(p, q). Let −→pq denote the line passing through p and q, and let θ(p, q, a) be the acute angle formed by −→pq and a. Then it is not hard to observe (see ﬁgure 3.1):

d(pa, qa) ≤ d(p, q) = d(pa, qa)/cos(θ(p, q, a))

As there is a line forming an angle with the x-coordinate at every δ angle interval, there must be some line a ∈ A forming an angle ≤ δ with −→pq. Finally, we observe that the Taylor series implies cos(δ) ≥ 1−δ2/2 . In particular, √ for δ = 2, then cos(δ) ≥ 1 − .

Analysis of communication and time complexity of Algorithm 2: Each node passes up √ √ no more than 2|A| = O(1/ ) locations using O(diam(ST )/ ) time for a total of 73

Figure 3.1: - kernel proof

√ O(n/ ) words of size O(log n) where diam(ST ) is the diameter of ST . In addition, there is the initial communication cost of computing the spanning tree.

Theorem 3.3.2. There exists an asynchronous algorithm in CONGEST KT1 which

√n computes an -kernel with high probability in a graph of n nodes with O( ) messages

diam√(ST ) in time O( ) plus the costs of constructing ST . √ Proof. In Algorithm 2 each node passes up no more than 2|A| = O(1/ ) locations √ √ using O(diam(ST )/ ) time for a total of O(n/ ) words of size O(lg n) where diam(ST ) is the diameter of ST . In addition, there is the initial communication cost

of computing the spanning tree. By Theorem 3.3.1, at the end of this algorithm SL is an -kernel for the point set P .

3.3.2 Approximate Diameter

Having an -kernel provides approximation algorithms for many extent related problems, such as minimum enclosing ball, minimum enclosing box, diameter, and 74

width. Here we propose an -kernel base approximation algorithm for Diameter.

Algorithm 3 Asynchronous -Diameter 1: procedure -Diameter(P is a set of n nodes) 2: Find -kernel S and spanning tree ST with leader L. 3: L computes the two farthest points r and s in S and broadcasts r and s through ST . 4: end procedure

Theorem 3.3.3. There exists an asynchronous algorithm in CONGEST KT1 which

√n computes a (1−)–Approximate Diameter in a graph of n nodes with O( ) messages

diam√(ST ) in time O( ) plus the costs of computing ST .

Proof. In Algorithm 3, once the -kernel S is received by the leader, the leader ﬁnds the two points furthest from each other in S and broadcasts them. The diameter of S is a (1 − )-approximation for the diameter of P by the deﬁnition of -kernel. More formally, let p1 and p2 be the points in P furthest from each other. Assume p1 and

d−1 p2 are extreme points of P for some direction a∗ ∈ S . As S is an -kernel of P , then for each u ∈ Sd−1 including a∗, (1 − )w(u, P ) ≤ w(u, S), where w(u, p) is the directional width of P in direction u: w(u, P ) = maxp∈P < u, p > −minp∈P < u, p >. The number of messages in this algorithm is the number of messages we need to compute -kernel plus O(n) messages to broadcast the two farthest points.

3.3.3 Approximate Convex Hull

There are diﬀerent notions of approximate convex hull. An -hull is one of the commonly used notions and it is closely related to -kernel. Let P be a set of n point in Rd. Let C(P ) denotes the convex hull of P . An -hull S of P is such that all the points in P are either in C(S) or within distance from C(S). 75

If we have an approximation of a diameter, then we can set in a way that -kernel will give us a desired ∗ Diam(P )-hull [2]. That is, if S is an 0-kernel of P then the convex hull of S is an (0Diam(P ))-hull where Diam(P ) is the diameter of P . If we obtain an -approximation to Diam(P ), call it D0, then the 0-kernel of P for 0 = (1 − )/D0 is an -hull of P .

Algorithm 4 Asynchronous -Approximate Convex Hull 1: procedure -Convex Hull(P is a set of n nodes) 2: Find -kernel S and spanning tree ST with leader L. 3: L broadcasts the vertices of convex hull of S through ST . 4: end procedure

Theorem 3.3.4. There exists an asynchronous algorithm in CONGEST KT1 which computes an - Approximate Convex Hull and f() − hull with high probability in a

√n diam√(ST ) graph of n nodes with O( ) messages in time O( ) plus the costs of computing ST , where f() = ∗ Diam(P ).

Proof. In Algorithm 4, once the -kernel S is received by the leader, the leader ﬁnds the convex hull of S and broadcasts its vertices, so that every node knows whether it is on the convex hull and knows its neighbors in both the clockwise and the counter- clockwise directions. The -kernel is a multiplicative error version of -hull [2]. By deﬁnition, -kernel S approximates the convex hull of P within a 1 − factor in any direction. The convex hull of S is an ∗Diam(P )-hull, as all the points in P are either in the convex hull of S or within Diam(P ) from the convex hull of S, where Diam(P ) is the diameter of P . This is because if d(x, S) is the distance of any point x ∈ P \ S from convex hull S, then d(x, S) ≤ w(u, p)−w(u, S) ≤ w(u, p) for any direction u ∈ Sd−1, where w(u, p) is the directional width of P in direction u. Thus d(x, S) ≤ ∗Diam(P ), and the -kernel is an ∗ Diam(P )-hull. 76

3.3.4 Lower Bound for Diameter

We reduce the problem of Path Set Disjointness to Diameter. Similar ideas have been used to show lower bounds in a streaming model [29]. Given a path of m = n edges with endpoints Alice and Bob, where Alice and Bob each know subsets A and B resp., of {1, ..., n}, the communication network must compute the Set Disjointness

problem on (a, b), where a = (a1, ..., an) and b = (b1, ..., bn) are the characteristic

vectors of A and B. Consider the following graph GA,B(V,E) where |V | = 3n. Let

V = W ∪ U ∪ H, W = {w1, w2, ..., wn}, U = {u1, u2, ..., un}, H = {h1, h2, ..., hn}, and the position of these nodes are described later.

c c We draw evenly spaced lines L1, ..., Ln through the center of the [n ] × [n ] grid, for a constant c ≥ 2 + 2/ lg n. Each line L is composed of a low ray l(L) which goes from the center to below the center and the upper ray u(L) which goes from the center to above the center. The lines are drawn so that the upper rays are at equally spaced angles from each other and between 0 and π with the x axis. The points of the Diameter problem are determined as follows (Figure 3.2), where r = n and R = 2n2.

• For each 1 ≤ i ≤ n, if ai = 0, wi is on u(Li) at distance r from the center and otherwise at distance R.

• For each 1 ≤ i ≤ n, if bi = 0, ui is on l(Li) at distance r from the center and otherwise at distance R.

• The hi’s, where 1 ≤ i ≤ n, are located on the grid points inside the circle centered at the origin with radius r.

In the above description of the location of the points, in the case that any coordinate is not an integer coordinate, we round the point as follows: For each 1 ≤ i ≤ n, if the angle of u(Li) with the x axis is less than or equal π/2, then we round wi to 77

Figure 3.2: Reduction from Set Disjointness to Diameter. In this example, a1 = 1, ai = 0, ai+1 = 1, an = 1, b1 = 0, bi = 0, bi+1 = 1, and bn = 1.

the top right corner of the cell that contains wi, and if the angle is more than π/2 we round wi to the top left corner of the cell that contains wi. For each 1 ≤ i ≤ n, if the angle of l(Li) with the x axis is less than or equal 3π/2, then we round wi to the

bottom left corner of the cell that contains ui, and if the angle is more than 3π/2 we

round ui to the bottom right corner of the cell that contains ui. Note that a circle centered at the origin with radius r contains at least πr2 lattice points [63]. So choosing r = n guarantees that there are more than n grid points inside the circle to locate points of H. As R = 2n2, no two points of W and U are in the same grid cell and they would not round to the same grid point. We next describe the edges.

• For each 1 ≤ i ≤ n, E contains {wi, wi+1} and {ui, ui+1}.

• For each 1 ≤ i ≤ n, E contains {hi, hi+1}.

• E contains {wn, h1} and {hn, u1}. 78

Claim 3.3.5. The diameter of GA,B is 2R if and only if A ∩ B 6= ∅.

c c Proof. Let CR,Cr be the circles centered at the center of the [n ]×[n ] grid at distance R = 2n2 and r = n, respectively, for a constant c ≥ 2 + 2/ lg n. For any pair of points in U ∪ W , the distance is less than 2R if and only if one of the following is true: (1) the two points are on two diﬀerent lines; (2) the two points are on the same line, one at distance r and the other distance R. Note that even if the points are rounded, this still holds. This is because, the length of the longest √ chord after diameter is not more than cos α + 2 2, where α = π/2n, as shown in √ Figure 3.3. We assumed R = 2n2, so cos α + 2 2 < 2R by the Taylor series. If there

is an Li such that both wi and ui are distance R from the center, then their distance

is at least 2R. This occurs only when for some i, ai = bi = 1, so A ∩ B 6= ∅.

Theorem 3.3.6. Any randomized asynchronous distributed algorithm in the CON- GEST model for solving Diameter in a graph of n nodes requires Ω(n2) expected bits of communication.

Proof. Suppose Alice and Bob are two endpoints of a path with N = n/3 edges numbered 0, 1, ..., N. Alice and Bob each know subsets A and B resp., of {1, ..., N}, and they want to solve the Path Computation for the Set Disjointness problem on (a, b) over a path of size N, where a = (a1, ..., aN ) and b = (b1, ..., bN ) are the characteristic vectors of A and B. Alice can construct the subgraph of G induced by H ∪ W and given B, Bob can construct the subgraph induced by H ∪ U. They both know H, the path of size N. They can then each carry out a simulation of the protocol which determines the diameter of G and output 1 or 0 depending on whether the diameter is at least 2R or not. Thus the communication cost is no less than the cost of computing Set Disjointness over a path of length N where n = 3N is the total number of nodes in G. By Corollary 3.2.6, Ω(n2/ lg n) messages are required. 79

Theorem 3.3.7. Any randomized asynchronous distributed algorithm for approximating Diameter in a graph of n nodes within a 1 − factor of optimal requires Ω(min{n2, 1/}) expected bits of communications.

Proof. Consider the reduction from Set Disjointness to Diameter described before

with vertices V = W ∪U ∪H as shown in Figure 3.2. Let CR,Cr be the circles centered at the center of the [nc] × [nc] grid at distance R = 2n2 and r = n, respectively, for a constant c ≥ 2 + 2/ lg n. The maximum distance between any pair of points is the diameter of the largest circle, which is at least 2R. The next greatest distance in this structure is d ≈ 2R cos α, as this is the longest chord after diameter on the largest circle and it is greater than the diameter of the smaller circle, which is r = n, see Figure 3.3. The reason that we say d ≈ 2R cos α is because we are rounding the points to grid points. As no more than one point is in one cell and the points are rounded to the outside of the circle, the rounding can only increase the distance of the points from the center of the circle. This means the ratio of d/2R after the rounding is not √ √ 2R cos α+2 2 2 2 2 more than 2R = cos α + 2R . As we assumed R = 2n , the ratio of d/2R after √ the rounding is not more than cos π/2n + 2/n2. Therefore, if there is a (1−)-approximation algorithm for the Diameter problem, √ where 1 − > cos π/2n + 2/n2, then the algorithm also ﬁnds the exact solution of Diameter and solves the problem of Set Disjointness of size n/3. So, if < 1 − √ cos π/2n − 2/2n, then by Theorem 3.3.6 any randomized asynchronous distributed algorithm for approximating Diameter of n points within 1 − factor of optimal requires Ω(n2) bits of communications. √ √ If ≥ 1−cos(π/2n)− 2/n2, we build the same structure but with θ(1/ ) points, √ where R = 2n2, and reduce a Set Disjointness problem with size n0 = 1/2 to this problem. By using Taylor series we know that 1−cos(x) ≥ x2/2!−x4/4! ≥ 11x2/24, if √ √ we pick n0 = 1/2 , then 1− > cos π/2n0+ 2/n2 as 1−cos π/2n0 ≥ 11(π/2n0)2/24 ≥ 80

Figure 3.3: The distance between wi and ui+1 is the second largest distance of a pair of points after the diameter.

√ √ 4 and − 2/n2 > 0. Thus, if > 1 − cos π/2n − 2/n2, then by Theorem 3.3.6 any randomized asynchronous distributed algorithm for approximating Diameter of n points within 1 − factor of optimal requires Ω(1/) bits of communications.

Corollary 3.3.8. Any randomized asynchronous distributed algorithm for computing -kernel, for any > 0 requires Ω(min{n2, 1/}) expected bits of communications.

Note that we cannot reach a better lower bound for this problem by only scaling the same structure of the points and having more space between them. This is because even if we consider a bigger circle, still the ratio of the diameter of the circle to the second longest cord of the circle is the same, and this ratio only depends on the number of the points on the circle.

3.3.5 Lower Bound for Convex Hull

We reduce the problem of Path Set Disjointness to Convex Hull. We show that if Convex Hull can be solved in o(n2) communication in an asynchronous network with 81

n nodes, then this implies an algorithm for Path Set Disjointness on a path of length n/3 with fewer than Ω(n2) expected bits of communication, giving a contradiction. Given a path of m = n edges with endpoints Alice and Bob, where Alice and Bob each know subsets A and B resp., of {1, ..., n}, the communication network must compute the Set Disjointness problem on (a, b), where a = (a1, ..., an) and b = (b1, ..., bn) are the characteristic vectors of A and B. Consider the following graph GA,B(V,E) where |V | = 3n. Let V = W ∪ U ∪ H, W = {w1, w2, ..., wn},

U = {u1, u2, ..., un}, H = {h1, h2, ..., hn}. We consider 4n positions equally distanced on a circle centered at the center of

c c i the [n ]×[n ] grid, for a constant c > 1+1/(2 lg n), with radius R = 2n: P = {Pj |1 ≤ i ≤ n, 1 ≤ j ≤ 4, as shown in Figure 3.4. In the case that any coordinate is not an integer coordinate, we round the point to one of grid points of the cell that contains this point as mentioned before in Section 3.3.4. The points of vertices V for the the Convex Hull problem are determined as follows (Figure 3.4):

i • For each 1 ≤ i ≤ n, if ai = 0, wi is on the location P0; otherwise on the location

i P1;

i • For each 1 ≤ i ≤ n, if bi = 0, ui is on the location P2; otherwise on the location

i P3;

• The hi’s, where 1 ≤ i ≤ n, are located on the grid points inside the circle centered at the center of the grid with radius r = n.

Note that a circle centered at the origin with radius r contains at least πr2 lattice points [63]. So choosing R > n guarantees that there are more than n grid points inside the circle to locate points of H. We choose R = 2n to make sure no two points of W and U are in the same grid cell and would not round to the same grid point. We next describe the edges. 82

Figure 3.4: Reduction from Set Disjointness to Convex Hull. In this example, a1 = 1, ai = 0, ai+1 = 1, an = 0, b1 = 1, bi = 0, bi+1 = 0, and bn = 1.

• For each 1 ≤ i ≤ n, E contains {wi, wi+1} and {ui, ui+1}.

• For each 1 ≤ i ≤ n, E contains {hi, hi+1}.

• E contains {w1, h1} and {hn, un}.

i Claim 3.3.9. A ∩ B 6= ∅ if and only if there is some i for which wi is on P1 and the

i location of its neighbor on the convex hull of GA,B is on position P3 in the counter- clockwise direction. Equivalently,A ∩ B 6= ∅ if and only if there is some i for which

i ui is on P3 and the location of its neighbor on the convex hull of GA,B is on position

i P1 in the clockwise direction.

Proof. In the solution of Convex Hull for these points, all the ui’s and wi’s are on the convex hull and no hi is on the convex hull. For any 1 ≤ i ≤ n, ui is the neighbor of wi on the convex hull of GA,B in the counter-clockwise direction. So, in the solution

i of Convex Hull problem, if there is some i for which wi is on P1 and the location

i of its neighbor on the convex hull of GA,B is on position P3 in the counter-clockwise

i direction, this means ui is on P3. So, both ai = 1 and bi = 1. Equivalently, A∩B 6= ∅

i if and only if there is some i for which ui is on P3 and the location of its neighbor on

i the convex hull of GA,B is on position P1 in the clockwise direction. 83

Theorem 3.3.10. Any randomized asynchronous distributed algorithm for solving the Convex Hull in a graph of n nodes requires Ω(n2) expected bits of communication.

Proof. Suppose Alice and Bob are two endpoints of a path with N = n/3 edges. Alice and Bob each know subsets A and B resp., of {1, ..., N}, and they want to solve the Path Computation of the Set Disjointness problem on (a, b) over a path of size

N, where a = (a1, ..., aN ) and b = (b1, ..., bN ) are the characteristic vectors of A and B. Alice can construct the subgraph of G induced by H ∪ W and given B, Bob can construct the subgraph induced by H∪U, and they both know the candidate positions P and the path H. They can then each carry out a simulation of the protocol which computes the convex hull of vertices of G and output 1 or 0 depending on the answer of Convex Hull of GA,B by using Claim 3.3.9. Since Alice knows the states of all wi and each wi knows the location of its neighbors on the convex hull, Alice outputs 1 if

i and only if there is some i for which for wi is on P1 and the location of its neighbor on

i the convex hull of GA,B is on position P3 in the counter-clockwise direction. Similarly

i Bob outputs 1 if and only if there is some i for which ui is on P3 and the location of

i its neighbor on the convex hull of GA,B is on position P1 in the clockwise direction. Thus the communication cost is no less than the cost of computing Disjointness over a path of length N where n = 3N is the total number of nodes in G. By Corollary 3.2.6, Ω(n2/ lg n) messages are required.

3.4 Closest Pair

We consider the following problem deﬁned in the ﬁxed-link model.

• Closest Pair: The goal is to determine a pair of closest points, and we require that every node learns the solution at the end of the algorithm. 84

We present an approximation algorithm, which uses o(m) communication, in the asynchronous CONGEST KT1 model. The algorithm gives us a tradeoﬀ between the approximation ratio and the amount of communication. The approximate Closest Pair algorithm initially randomly construct a spanning tree in o(m) communication for dense networks, see Theorem 3.1.1. Then uses a binary search over the possible locations to locate two points close together. With the exception of the subroutine to build the spanning tree, our algorithms are deterministic and designed to work in the weakest model described in this work, the asynchronous CONGEST KT0 model. We reduce Path Set Disjointness to Closest Pair to show a nearly matching lower bound. Our lower bound holds for the randomized asynchronous KT1 model (and therefore in the KT0 model.)

3.4.1 Approximate Closest Pair

√nc Algorithm 5 computes an n−1 - Approximation Closest Pair with high probability in 2 a graph of n nodes on an [nc] × [nc] grid , for a constant c > 1/2, in the asynchronous CONGEST KT1 model. √ √ The main idea of this algorithms is to divide the [nc]×[nc] grid to a n by n − 1 √ 2 √ grid, for a total of n − n grid cells: C = c1, c2, ..., c n2−n. There are n nodes and fewer than n cells, so there is a cell with more than one node. The algorithm finds such a cell and broadcasts the nodes in it. A spanning tree is first constructed by Theorem 3.1.1. Then, we use binary search √ √ 2 on c1, c2, ..., c n2−n to find a cell with more than two points in lg( n − n) rounds. Let loc(p) denote the position of node p and index(p) denote the index of the cell in

s+e C that contains loc(p). Let mid(s, e) = b 2 c for any s and e.

The leader broadcasts < start >< si, ei > in round i for an interval Ii = [si, ei] of the indices, and the goal is to ﬁnd the number of nodes which are in cells 85

whose indices are in the ﬁrst half of the range Ii. Starting with the leaves of ST ,

each node p computes xp, the number of nodes in the subtree rooted at p which

are in cells whose indices are in Ii,[si, mid(si, ei)], and sends < si, ei, xp > to its parent. When the leader receives messages for a speciﬁc Ii from all of its children, it computes xL and picks Ii+1 to be the half of the interval that has more nodes than the number of cells, and broadcasts Ii+1. When the leader receives information about the last two cells, it picks the cell ce that contains at least two points and broadcasts < cell >< index(ce) > to ﬁnd two points in ce. When a node p receives < cell >< index(ce) > and p ∈ ce, it sends < decision >< loc(p) > to inform the leader about its location.

Theorem 3.4.1. There exists an asynchronous algorithm in CONGEST KT1 which √nc computes an n−1 - Approximation Closest Pair with high probability in a graph of 2 n nodes on an [nc] × [nc] grid , for a constant c > 1/2, with O(n lg n) messages and time O(diam(ST ) lg n) where diam(ST ) is the diameter of the spanning tree, plus the costs for building the ST . √ Proof. We observe that in Algorithm 5 each node sends O(lg n2 − n) messages of √ size O(lg n) , so the total number of messages is n lg n2 − n or O(n lg n) plus the cost of ST . √nc The approximation ratio of the algorithm is n−1 . This is because there is always 2 c c √n √n a cell with more than one point, and the cells are n by n−1 . Thus, there is a pair √ c √ 2n of points with distance of at most the diameter of the cell, n−1 , but the distance of the actual closest pair could be as small as 1, as the points are on the grid and this is the smallest possible distance between any two points.

Corollary 3.4.2. There exists an asynchronous algorithm in CONGEST KT1 which √nc computes an k -Approximate Closest Pair with high probability in a graph of n 2 86

√nc Algorithm 5 n−1 -approximation Closest Pair,c>1/2 2 1: procedure Closest Pair(P is a set of n nodes) 2: Find spanning tree ST with√ leader L. 3: L broadcasts < start >< 1, n2 − n > when ST is complete. 4: When a leaf p receives < start >< s, e >, if index(p) ∈ [s, mid(s, e)] then p sends < s, e, 1 > to its parent; otherwise sends < s, e, 0 >. 5: For speciﬁc s and e, when a non-leaf node p, including the leader, receives P < s, e, xq > from all of its children q, p sends < s, e, q xq + (1 − xp) to its parent, where xp = 0 if index(p) ∈ [s, mid(s, e)] and xp = 1 otherwise. 6: For speciﬁc s and e, when L receives < e, s, xq > from all of its children q and computes xL, If e − s = 1, L broadcasts < cell >< index(ce) > to its children, where ce is one of ce or cs that contains at least two points. Else If xL > mid(s, e) − s + 1, L broadcasts < start >< s, mid(s, e) >. Else L broadcasts < start >< mid(s, e) + 1, e >. 7: When a node p 6= L receives < cell >< ce >, if index(p) = index(ce) and p has not sent more than one < decision > message to its parent before, then p sends< decision >< loc(p) > to its parent. 8: When a non-leaf node p receives < decision >< loc(q) >, from one of its children q if p has not send more than one < decision > message to its parent before, then p sends< decision >< loc(q) > to its parent. 9: When a L receives < decision >< loc(q) >, from one of its children q if p has already received another < decision > message or index(L) = index(ce), then L broadcasts the location of these two points in ce through ST . 10: end procedure

nodes on an [nc] × [nc] grid , for a constant c > 1/2, in O(n lg k) messages in time O(diam(ST ) lg k), where diam(ST ) is the diameter of the spanning tree, plus the cost of computing ST , for any k ≤ n − 1. √ √ Proof. If in Algorithm 5 we divide the grid to k by k cells evenly, each size

c c of √n , the diameter of each cell is √n , and so is the approximation ratio of the k k 2 algorithm. Each node p sends O(k) messages of size lg k, and the algorithm uses O(nk) messages. 87

3.4.2 Lower Bound

We show a reduction from Path Set Disjointness to Closest Pair. Similar ideas were used in the streaming model [29]. Given an instance of the Path Set Disjointness problem, in which there are two players

Alice and Bob where Alice has subset A with characteristic vector a = (a1, ..., an) and

Bob has subset B with characteristic vector b = (b1, ..., bn), we consider the following graph GA,B(V,E) where |V | = 3n. Let V = W ∪ U ∪ H, W = {w1, w2, ..., wn},

U = {u1, u2, ..., un}, H = {h1, h2, ..., hn}. The locations of the vertices of GA,B are as follows:

• For each 1 ≤ i ≤ n, if ai = 0, wi is on coordinate (2i, 0); otherwise on coordinate (2i, 1).

• For each 1 ≤ i ≤ n, if bi = 0, ui is on coordinate (2i, 3); otherwise on coordinate (2i, 2).

• For each 1 ≤ i ≤ n/2, hi is located on coordinate (2(i + n), 0), and for each

n/2 + 1 ≤ i ≤ n, hi is on coordinate (2(i + n), 3) .

We next describe the edges.

• For each 1 ≤ i ≤ n, E contains {wi, wi+1} and {ui, ui+1}.

• For each 1 ≤ i ≤ n, E contains {hi, hi+1}.

• E contains {wn, h1} and {hn, u1}.

Claim 3.4.3. The distance of the two closest vertices in the problem of Closest Pair on GA,B is 1 if and only if A ∩ B 6= ∅.

Proof. It is clear that the distance between any two points in W or any two points in U is at least 2. The distance between any pair of points in H ∪ W and any pair 88

Figure 3.5: Reduction from Set Disjointness to Closest Pair. In this example a1 = 1, a2 = 1, an = 0, b1 = 0, b2 = 1, and bn = 1. of points in H ∪ U is also at least 2. The distance between the points of W and the

points of U is 1 if and only if there is an i such that wi is on (2i, 1) and ui is on (2i, 2).

This occurs only when ai = 1 and bi = 1, so A ∩ B 6= ∅.

Theorem 3.4.4. Any randomized asynchronous distributed algorithm for solving Closest Pair in a graph with n nodes on an [nc] × [nc] grid, for a constant c > 1 + 1/(2 lg n), requires an expected Ω(n2) bits of communication.

Proof. Suppose Alice and Bob are two endpoints of a path with N = n/3 edges numbered 0, 1, ..., N. Alice and Bob each know subsets A and B resp., of {1, ..., n}, and they want to solve the Path Computation of the Set Disjointness problem on (a, b)

over a path of size N, where a = (a1, ..., aN ) and b = (b1, ..., bN ) are the characteristic vectors of A and B. Alice can construct the subgraph of G induced by H ∪ W and given B, Bob can construct the subgraph induced by H ∪ U. They both know H, the path of size N. They can then each carry out a simulation of the protocol which determines the closest pair of G and output 0 iﬀ the closest pair is distance 1 away from each other. Thus the communication cost is no less than the cost of computing Disjointness over a path of length N where n = 3N is the total number of nodes in G. By Corollary 3.2.6, Ω(n2/ lg n) messages are required.

Theorem 3.4.5. Any randomized asynchronous distributed algorithm for approximating Closest in a graph with n nodes on an [nc] × [nc] grid, for a constant c > 89

nc−1 2 1 + 1/(2 lg n), within 2 − factor of optimal requires an expected Ω(n ) bits of communications.

Proof. Consider the reduction shown in the previous section from Set Disjointness to Closest Pair with a slightly diﬀerent location for the points such that the minimum

nc possible distance for a pair of points is 1 or 2n of each other in the same structure nc−1 shown in Figure 3.5: if k = 2

• For each 1 ≤ i ≤ n, if Ai = 0, vi is on coordinate (ki, 0); otherwise on coordinate (ki, k).

• For each 1 ≤ i ≤ n, if Bi = 0, ui is on coordinate (ki, 2k + 1); otherwise on coordinate (ki, k + 1).

• hi is located on coordinate (k(i + n), 0) for 1 ≤ i ≤ n/2 and on coordinate (k(i + n), 2k + 1) for n/2 + 1 ≤ i ≤ n.

If there as an approximation algorithm for Closest Pair with approximation ratio

nc 2 no more than 2n − and uses o(n ) bits of communication, this means that the nc algorithm can distinguish between distance 2n − and distance 1 and answer Path Set Disjointness with using o(n2) bits of communication, which is a contradiction.

The following theorem shows a better lower bound for Closest Pair with the idea of spreading the points even more on the plane. The result of Theorem 3.4.6 subsumes the result of the two previous theorems (Theorem 3.4.4 and Theorem 3.4.5), but these two theorems help to elucidate the structure of the graph in Theorem 3.4.6.

Theorem 3.4.6. Any randomized asynchronous distributed algorithm for approximating Closest Pair in a graph with n nodes on an [nc] × [nc] grid, for a constant 90

Figure 3.6: Reduction from Set Disjointness to Closest Pair. In this example, a1 = 1, a2 = 1, an = 0, b1 = 0, b2 = 1, and bn = 0.

nc−1/2 2 c > 1 + 1/(2 lg n), within 2 − factor of optimal requires an expected Ω(n ) bits of communications.

Proof. When reducing Set Disjointness to Closest Pair, instead of locating all the 3n

nc−1 points on four horizontal lines, y = 0, k, k + 1, 2k + 1 , where k = 2 , as showed √ in Figure 3.5, here we locate the points diﬀerently: on O( n) groups of each group √ containing O( n) points as shown in Figure 3.6 and described below.

0 nc−1/2 if k = 2 ,

3 √ 2 √ 0 0 • For each 0 ≤ i ≤ 2 n and 0 ≤ j ≤ 3 n, < ik + j ≤ n , if Ajk +i = 0, vi is on coordinate (k0i, 3jk0 + j); otherwise on coordinate (k0i, (3j + 1)k0 + j).

3 √ 2 √ 0 0 • For each 0 ≤ i ≤ 2 n and 0 ≤ j ≤ 3 n, < ik + j ≤ n , if Bjk +i = 0, ui is on coordinate (k0i, (3j+1)k0 +j+1); otherwise on coordinate (k0i, (3j+2)k0 +j+1). 91

√ √ 0 • For each 0 ≤ i ≤ n/2 and 0 ≤ j ≤ 2 n, < ik +j ≤ n , hjk0+i is on coordinate

0 3 c 0 (k i + 4 n , jk ).

In this way the minimum possible distance between a pair of point is 1 or k0. If there as an approximation algorithm for Closest Pair with approximation ratio

nc−1/2 2 no more than 2 − and uses o(n ) bits of communication, this means that the nc−1/2 algorithm can distinguish between distance 2 − and distance 1 and answer Path Set Disjointness with using o(n2) bits of communication, which is a contradiction.

3.5 Conclusion and Open Problems

In this chapter we prove lower bounds on the number of expected bits required for any randomized algorithm in geometric communication networks of arbitrary topology with n nodes to solve the following problems in the ﬁxed-link model, when the communication is in asynchronous KT1. We show that Convex Hull , Closest Pair and Diameter problems require Ω(n2) bits of communication. In Closest Pair and Diameter our result holds even if the network is planar. Table 3.1 shows the results of this chapter.

We present approximation algorithms for geometric communication networks in the ﬁxed-link model, when the communication is in asynchronous CONGEST KT1 model. Our algorithms uses o(m) words of communication, where m is the number of edges in the network, to approximate each of these problems. We also deﬁne a new version of two-party communication problem, Path Com- putation, where two parties are communicating through a path. We prove a lower bound on the communication complexity of this problem. 92

Upper Bound Lower Bound Path Computation of Disjointness of size n over a path of O(n) nodes O(n2) Ω(n2/ log n) √ -kernel O(n/ ) + ST Ω(min{n2, 1/})

Diameter O(n2) Ω(n2/ log n) √ (1 − )-approx. Diameter O(n/ ) + ST Ω(min{n2, 1/})

Convex Hull O(n2) Ω(n2/ log n) √ -approx. Convex Hull O(n/ ) + ST -

Closest Pair O(n2) Ω(n2/ log n)

c √ n -approx. Closest Pair O(n log n) + ST *- (n−1)/2 nc−1/2 2 ( 2 - )-approx. Closest Pair - Ω(n / log n)**

Table 3.1: Results of Chapter 3. Upper bound and lower bound of the number of messages of size O(log n) bits for a geometric communication network with n nodes on an [nc] × [nc] grid in the ﬁxed-link model. *for a constant c > 1/2. ** for a constant c > 1 + 1/(2 lg n).

Open problems raised by this research are: (1) We motivated our model for the situation that the topology of the communication graph is not changing very often, but the positions of the nodes are changing. In the case that the communication graph is also constantly changing, we would need to compute the spanning tree every time. In that situation a bottleneck in our upper bounds is the computation of the spanning tree, which in the asynchronous model appears to require signiﬁcantly more communication (O˜(n3/2)) than what is needed for the synchronous model ( O˜(n) ). Is this gap necessary? (2) Euclidean minimum spanning tree (EMST) on a geometric communication network in the ﬁxed-point KT1 model is the minimum spanning tree of the graph, where the weight of an edge between each pair of nodes is the Euclidean distance 93

between the location of two nodes. EMST can be found by the algorithm in [46], since in fixed point model each node knows the weights of its incident edges. But if a node’s ID is not related to its position, merely knowing the neighbors’ IDs may be insufficient to solve this problem in o(m) communication. How can we find EMST efficiently in the fixed-link model? (3) We showed that Convex Hull , Closest Pair and Diameter problems require Ω(n2) bits of communication. What geometric problems in fixed-link asynchronous KT1 model can be solved in o(m) communication in the fixed-link model? 94

Bibliography

[1] Pankaj K. Agarwal, Sariel Har-Peled, and Kasturi R. Varadarajan. Approximat- ing extent measures of points. Journal of ACM, 51(4):606–635, 2004.

[2] Pankaj K. Agarwal, Sariel Har-Peled, and Kasturi R. Varadarajan. Geometric approximation via coresets. In COMBINATORIAL AND COMPUTATIONAL GEOMETRY, MSRI, pages 1–30. University Press, 2005.

[3] Pankaj K. Agarwal, Jirí Matousek, and Subhash Suri. Farthest neighbors, maximum spanning trees and related problems in higher dimensions. Computational Geometry, 1:189–201, 1991.

[4] Sunil Arya and Timothy M. Chan. Better -dependencies for oﬄine approximate nearest neighbor search, euclidean minimum spanning trees, and -kernels. In 30th Annual Symposium on Computational Geometry (SOCG’14), page 416. ACM, 2014.

[5] Navid Assadian. Separating colored points. M.Sc. Thesis, Sharif University of Technology, Tehran, 2014.

[6] Navid Assadian, Sima Hajiaghaei Shanjani, and Alireza Zarei. Separating colored points with minimum number of rectangles. Technical Report 2107.09821, arXiv, 2021. 95

[7] Giorgio Ausiello, Alberto Marchetti-Spaccamela, Pierluigi Crescenzi, Giorgio Gambosi, Marco Protasi, and Viggo Kann. Complexity and approximation: combinatorial optimization problems and their approximability properties. Springer, 1999.

[8] Baruch Awerbuch, Oded Goldreich, David Peleg, and Ronen Vainish. A trade- oﬀ between information and communication in broadcast protocols. Journal of ACM, 37(2):238–256, 1990.

[9] Maria Fiorina Balcan, Steven Ehrlich, and Yingyu Liang. Distributed k-means and k-median clustering on general topologies. NIPS’13, pages 1995–2003. Cur- ran Associates Inc., 2013.

[10] C. Bautista-Santiago, D. Lara J.M. Díaz-Báñez, C. Peláez, and J. Urrutia. On covering a class with arbitrary disk. Technical report, 2008.

[11] Sergey Bereg, Sergio Cabello, José Miguel Díaz-Báñez, Pablo Pérez-Lantero, Carlos Seara, and Inmaculada Ventura. The class cover problem with boxes. Computational Geometry, 45(7):294–304, 2012.

[12] Piotr Berman and Bhaskar DasGupta. Complexities of eﬃcient solutions of rectilinear polygon cover problems. Algorithmica, 17(4):331–356, 1997.

[13] Piotr Berman, Marek Karpinski, and Alex D. Scott. Approximation hardness and satisﬁability of bounded occurrence instances of SAT. Electronic Colloquium on Computational Complexity (ECCC), 10(022), 2003.

[14] Piotr Berman, Marek Karpinski, and Alex D. Scott. Approximation hardness of short symmetric instances of MAX-3SAT. Electronic Colloquium on Computa- tional Complexity (ECCC), (049), 2003. 96

[15] Avrim Blum, Vladimir Braverman, Ananya Kumar, Harry Lang, and Lin F. Yang. Approximate Convex Hull of Data Streams. In 45th International Collo- quium on Automata, Languages, and Programming (ICALP 2018), volume 107 of LIPIcs, pages 21:1–21:13, Dagstuhl, Germany, 2018. Schloss Dagstuhl–Leibniz- Zentrum fuer Informatik.

[16] Prosenjit Bose, Pat Morin, Ivan Stojmenovic, and Jorge Urrutia. Routing with guaranteed delivery in ad hoc wireless networks. In Proceedings of the 3rd Inter- national Workshop on Discrete Algorithms and Methods for Mobile Computing and Communications (DIAL-M 1999), pages 48–55. ACM, 1999.

[17] Hervé Brönnimann and Michael T. Goodrich. Almost optimal set covers in ﬁnite VC-dimension. Discrete & Computational Geometry, 14(4):463–479, 1995.

[18] Adam Cannon and Lenore Cowen. Approximation algorithms for the class cover problem. Annals of Mathematics and Artiﬁcial Intelligence, 40(3-4):215–224, 2004.

[19] Robert D. Carr, Srinivas Doddi, Goran Konjevod, and Madhav Marathe. On the red-blue set cover problem. In Proceedings of the Eleventh Annual ACM- SIAM Symposium on Discrete Algorithms, SODA ’00, pages 345–353. Society for Industrial and Applied Mathematics, 2000.

[20] Timothy M. Chan. Faster core-set constructions and data-stream algorithms in ﬁxed dimensions. Computational Geometry, 35(1-2):20–35, 2006.

[21] Timothy M. Chan and Elyot Grant. Exact algorithms and apx-hardness results for geometric packing and covering problems. Compututational Geometry, 47(2):112–124, 2014. 97

[22] Timothy M. Chan and Nan Hu. Geometric red-blue set cover for unit squares and related problems. Computational Geometry, 48(5):380–385, 2015.

[23] Pierluigi Crescenzi and Alessandro Panconesi. Completeness in approximation classes. Information and Computation, 93(2):241–262, 1991.

[24] Joseph C. Culberson and Robert A. Reckhow. Covering polygons is hard. Journal of Algorithms, 17(1):2–44, 1994.

[25] Jason G DeVinney. The class cover problem and its application in pattern recog- nition. PhD thesis, Johns Hopkins University, 2003.

[26] Irit Dinur and David Steurer. Analytical approach to parallel repetition. In Proceedings of the 45th Annual ACM Symposium on the Theory of Computing (STOC 2014), pages 624–633. ACM, 2014.

[27] Guy Even, Dror Rawitz, and Shimon Shahar. Hitting sets when the VC- dimension is small. Information Processing Letters, 95(2):358–362, 2005.

[28] Uriel Feige. A threshold of ln n for approximating set cover. Journal of the ACM, 45(4):634–652, 1998.

[29] Joan Feigenbaum, Sampath Kannan, and Jian Zhang. Annotation and computational geometry in the streaming model. Technical Report, Yale University(YALEU/DCS/TR-1249), 2003.

[30] Dan Feldman, Andrew Sugaya, and Daniela Rus. An eﬀective coreset compression algorithm for large scale sensor networks. IPSN ’12, pages 257–268. Association for Computing Machinery, 2012.

[31] Jie Gao, Leonidas J. Guibas, John Hershberger, Li Zhang, and An Zhu. Geo- metric spanner for routing in mobile networks. In Proceedings of the 2nd ACM 98

Interational Symposium on Mobile Ad Hoc Networking and Computing (MobiHoc 2001), pages 45–55. ACM, 2001.

[32] Mohsen Ghaﬀari and Fabian Kuhn. Distributed MST and broadcast with fewer messages, and faster gossiping. In 32nd International Symposium on Distributed Computing, (DISC 2018), volume 121 of LIPIcs, pages 30:1–30:12. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018.

[33] Robert Gmyr and Gopal Pandurangan. Time-message trade-oﬀs in distributed algorithms. In 32nd International Symposium on Distributed Computing, pages 1–18, 2018.

[34] Mika Göös and Thomas Watson. Communication complexity of set-disjointness for all probabilities. In Approximation, Randomization, and Combinatorial Op- timization. Algorithms and Techniques( APPROX/RANDOM 2014 ), volume 28 of LIPIcs, pages 721–736. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2014.

[35] Sima Hajiaghaei Shanjani. Hardness of approximation for red-blue covering. In Proceedings of the 32nd Canadian Conference on Computational Geometry (CCCG 2020), pages 39–48, 2020.

[36] Sima Hajiaghaei Shanjani. Hardness of approximation for red-blue covering problems. In Computational Geometry: Young Researchers Forum 2020: Booklet of Abstracts (CG Week 2020), pages 39–48, 2020.

[37] Sima Hajiaghaei Shanjani and Valerie King. Communication costs in a geometric communication network. In Proceeding of International Conference on Distributed Computing and Networking (ICDCN ’21), pages 36–45. ACM, 2021. 99

[38] Sariel Har-Peled. Being fat and friendly is not enough. Computing Research Repository, abs/0908.2369, 2009.

[39] Johan Håstad. Some optimal inapproximability results. In Proceedings of the Twenty-Ninth Annual ACM Symposium on the Theory of Computing (STOC 1997), pages 1–10, 1997.

[40] John Hershberger and Subhash Suri. Adaptive sampling for geometric problems over data streams. In Proceedings of the Twenty-third ACM SIGACT-SIGMOD- SIGART Symposium on Principles of Database Systems, pages 252–262. ACM, 2004.

[41] Dorit S. Hochbaum, editor. Approximation Algorithms for NP-Hard Problems. PWS Publishing Co., 1996.

[42] Dorit S. Hochbaum and Wolfgang Maass. Fast approximation algorithms for a nonconvex covering problem. Journal of Algorithms, 8(3):305–323, 1987.

[43] Russell Impagliazzo and Ryan Williams. Communication complexity with syn- chronized clocks. In Proceedings of the 25th Annual IEEE Conference on Compu- tational Complexity (CCC 2010), pages 259–269. IEEE Computer Society, 2010.

[44] Piotr Indyk, Sepideh Mahabadi, Mohammad Mahdian, and Vahab S. Mirrokni. Composable core-sets for diversity and coverage maximization. In Proceed- ings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems (PODS’14), pages 100–108. ACM, 2014.

[45] Daniel Jung, Christina Kolb, Christian Scheideler, and Jannik Sundermeier. Competitive routing in hybrid communication networks. In Algorithms for Sen- sor Systems - 14th International Symposium on Algorithms and Experiments for 100

Wireless Sensor Networks (ALGOSENSORS 2018) Revised Selected Papers, volume 11410 of Lecture Notes in Computer Science, pages 15–31. Springer, 2018.

[46] Valerie King, Shay Kutten, and Mikkel Thorup. Construction and impromptu repair of an MST in a distributed network with o(m) communication. In Pro- ceedings of the 2015 ACM Symposium on Principles of Distributed Computing (PODC 2015), pages 71–80. ACM, 2015.

[47] Eyal Kushilevitz and Noam Nisan. Communication complexity. Cambridge Uni- versity Press, 1997.

[48] Shay Kutten, Gopal Pandurangan, David Peleg, Peter Robinson, and Amitabh Trehan. On the complexity of universal leader election. In ACM Symposium on Principles of Distributed Computing (PODC ’13), pages 100–109. ACM, 2013.

[49] Shay Kutten, Gopal Pandurangan, David Peleg, Peter Robinson, and Amitabh Trehan. On the complexity of universal leader election. Journal of ACM, 62(1):7:1–7:27, 2015.

[50] Xiang-Yang Li. Approximate MST for UDG locally. In Proceedings of the 9th Annual International Conference on Computing and Combinatorics (CO- COON 2003), volume 2697 of Lecture Notes in Computer Science, pages 364–373. Springer, 2003.

[51] Xiang-Yang Li. Applications of Computational Geometry in Wireless Networks, pages 197–264. Springer US, 2004.

[52] David Marchette. Class cover catch digraphs. Wiley Interdisciplinary Reviews: Computational Statistics, 2(2):171–177, 2010.

[53] William J. Masek. Some np-complete set covering problems. Technical report, 1979. 101

[54] Ali Mashreghi and Valerie King. Broadcast and minimum spanning tree with o(m) messages in the asynchronous CONGEST model. In 32nd International Symposium on Distributed Computing (DISC 2018), volume 121 of LIPIcs, pages 37:1–37:17. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2018.

[55] Ali Mashreghi and Valerie King. Brief announcement: Faster asynchronous MST and low diameter tree construction with sublinear communication. In 33rd International Symposium on Distributed Computing (DISC 2019), volume 146 of LIPIcs, pages 49:1–49:3. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019.

[56] Nabil H. Mustafa, Rajiv Raman, and Saurabh Ray. Settling the apx-hardness status for geometric set cover. In 2014 IEEE 55th Annual Symposium on Foun- dations of Computer Science, pages 541–550, 2014.

[57] Nabil H. Mustafa and Saurabh Ray. Improved results on geometric hitting set problems. Discrete & Computational Geometry, 44(4):883–895, 2010.

[58] A Naamad, D.T Lee, and W.-L Hsu. On the maximum empty rectangle problem. Discrete Applied Mathematics, 8(3):267–277, 1984.

[59] Jelani Nelson. A note on set cover inapproximability independent of universe size. Electronic Colloquium on Computational Complexity (ECCC), 14(105), 2007.

[60] János Pach and Gábor Tardos. Tight lower bounds for the size of epsilon-nets. In Proceedings of the 27th ACM Symposium on Computational Geometry, pages 458–463, 2011.

[61] David Peleg. Distributed Computing: A Locality-Sensitive Approach. Discrete Mathematics and Applications. Society for Industrial and Applied Mathematics, 2000. 102

[62] David Peleg. Approximation algorithms for the label-covermax and red-blue set cover problems. J. Discrete Algorithms, 5(1):55–64, 2007.

[63] Shaunna Plunkett-Levin. Problems related to lattice points in the plane. PhD thesis, Cardiﬀ University, 2011.

[64] Sergio Rajsbaum and Jorge Urrutia. Some problems in distributed computational geometry. Theoretical Compututer Science, 412(41):5760–5770, 2011.

[65] Alexander A. Razborov. On the distributional complexity of disjointness. The- oretical Computer Science, 106(2):385–390, 1992.

[66] Peter Robinson. Being fast means being chatty: The local information cost of graph spanners. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, pages 2105–2120. SIAM, 2021.

[67] Atish Das Sarma, Stephan Holzer, Liah Kor, Amos Korman, Danupon Nanongkai, Gopal Pandurangan, David Peleg, and Roger Wattenhofer. Dis- tributed veriﬁcation and hardness of distributed approximation. In Proceedings of the 43rd ACM Symposium on Theory of Computing (STOC 2011), pages 363– 372. ACM, 2011.

[68] Atish Das Sarma, Stephan Holzer, Liah Kor, Amos Korman, Danupon Nanongkai, Gopal Pandurangan, David Peleg, and Roger Wattenhofer. Dis- tributed veriﬁcation and hardness of distributed approximation. SIAM Journal on Computing, 41(5):1235–1265, 2012.

[69] Georg Schnitger and Bala Kalyanasundaram. The probabilistic communication complexity of set intersection. In Proceedings of the Second Annual Conference on Structure in Complexity Theory. IEEE Computer Society, 1987. 103

[70] Erik Jan van Leeuwen and Jan van Leeuwen. Structure of polynomial-time approximation. Theory of Computing Systems, 50(4):641–674, 2012.

[71] Vijay V. Vazirani. Approximation algorithms. Springer, 2001.

[72] Yu Wang, Xiang-Yang Li, and Ophir Frieder. Distributed spanners with bounded degree for wireless ad hoc networks. International Journal of Foundations of Computer Science, 14(2):183–200, 2003.