(Multivariate) -SUM as Barrier to Succinct Computation
Abstract
How does the time complexity of a problem change when the input is given succinctly rather than explicitly? We study this question for several geometric problems defined on a set of points in . As succinct representation, we choose a sumset (or Minkowski sum) representation: Instead of receiving explicitly, we are given sets of points that define as .
We investigate the fine-grained complexity of this succinct version for several -time computable geometric primitives. Remarkably, we can tie their complexity tightly to the complexity of corresponding -SUM problems. Specifically, we introduce as All-ints 3-SUM the following multivariate, multi-output variant of 3-SUM: given sets of size and set of size , determine for all whether there are and with . We obtain the following results:
-
1.
Succinct closest -pair requires time under the 3-SUM hypothesis, while succinct furthest -pair can be solved in time .
-
2.
Succinct bichromatic closest -Pair requires time iff the 4-SUM hypothesis holds.
-
3.
The following problems are fine-grained equivalent to All-ints 3-SUM: succinct skyline computation in 2D with output size and succinct batched orthogonal range search with given ranges. This establishes conditionally tight -time algorithms for these problems. We obtain further connections with All-ints 3-SUM for succinctly computing independent sets in unit interval graphs.
Thus, (Multivariate) -SUM problems precisely capture the barrier for enabling sumset-succinct computation for various geometric primitives.
Keywords and phrases:
Fine-grained complexity theory, sumsets, additive combinatorics, succinct inputs, computational geometryFunding:
Geri Gokaj: Research supported by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) – 462679611.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Computational geometryAcknowledgements:
We thank all reviewers for their in-depth review and feedback.Editors:
Anne Benoit, Haim Kaplan, Sebastian Wild, and Grzegorz HermanSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Consider an algorithmic problem on an input set of points in . How does the time complexity of the problem change when the input is given succinctly rather than explicitly? In this paper, we investigate this question when the succinct representation of is chosen as a sumset (or Minkowski sum) representation .
Our motivation is threefold:
-
1.
Complexity on structured input: How does the time complexity of the problem change when we are supplied with structural information about the input? As a case in point, this question has received considerable interest for the fundamental task of sorting. Indeed, the well-known Sorting problem studied by Fredman [20], and originally posed by Berlekamp111In the literature, the name Sorting is more common. However, throughout our paper will denote the explicit input and its succinct representation., asks to determine whether we can compute, given with , the sorted order of in time . Since the succinct representation gives a large partial order essentially for free – simply presort in time –, this question essentially boils to whether or not a partial solution structure helps significantly in determining the full output. The Sorting problem has several connections to problems in computational geometry such as polygon containment, computing the Minkowski sum of orthogonal polygons and minimizing the Hausdorff distance under translation for two segment sets, as described by the works of Barequet and Har-Peled [6], and Barrera [7].
Another example that has received considerable attention is the Pareto Sum problem (see, e.g., [27, 24]), which asks to compute the skyline of (see Section 4 for a formal definition). It is only natural to ask analogous questions for other numerical/geometric problems. In particular, a succinct sumset representation reveals additive structure of the problem, which may or may not simplify the algorithmic task considerably. -
2.
Algorithmic applications (sumset-compressed computational geometry): Let denote the optimal running time for solving a problem of interest on an input set of points in . For favorable inputs, it may be possible to find much smaller sets with – in principle compressions to size are possible. If we were able to solve the problem of interest in time rather than (aka decompress-and-solve running time), we could obtain significantly faster algorithms that reduce the running time from to . In fact, even small asymptotic improvements over might be algorithmically interesting.
-
3.
-SUM as precise barrier for succinct computations: Our setup offers another perspective on the -SUM problem. Specifically, for various problems, we shall prove that refuting a corresponding -SUM hypothesis is equivalent to solving the sumset-succinct version of the problem faster than via decompress-and-solve. That is, despite its simple definition (asking a very basic question about sumsets), the -SUM problem captures much more general primitives on succinct inputs. We believe that this yields valuable insights into the true expressiveness of -SUM and the plausibility of the corresponding hardness hypothesis.
1.1 Our setup
For any algorithmic problem defined on an input set , we consider the following sumset-succinct version as succinct-:
Problem
| Input: | |
|---|---|
| possibly additional inputs | |
| Output: |
Problem succinct-
| Input: | |
|---|---|
| possibly additional inputs | |
| Output: | where |
As a convention, we set , and . For ease of presentation, we will generally assume that , but our results can be adapted to the general case. Throughout the paper, we will assume that all input numbers are chosen from a polynomial range, i.e., for some arbitrarily large constant .
Let us consider a few (near-)linear time solvable problems . We observe that their succinct versions may have very different time complexities:
A succintly easy problem: Selection
Consider the problem Selection: Given and , return the -th largest element in . Selection is well known to be solvable in time ; see [8, 15]. Its succinct version succinct-Selection has received considerable attention as well [30, 29, 28, 19] and can be solved significantly faster than decompress-and-solve, specifically, in time .222The authors consider a slight variant in which is viewed as a multiset (or ).
A succinctly hard problem: Skyline computation
Consider the problem of skyline computation (aka non-dominance filtering or Pareto front computation), see, e.g. [32, 14, 22]: Given , compute the set of non-dominated points, i.e., all for which there is no with and component-wise. This problem can be solved in near-linear time , see, e.g., [32]. Its succinct version is known as Pareto Sum and naturally occurs in several multi-objective optimization algorithms, see Hespe et al. [27]. Notably, a conditional lower bound of that holds when the output size is has been proven under the -convolution hypothesis [21] and the 3-SUM hypothesis [24]. We shall investigate this problem in much more detail below.
On reductions to -SUM
The -SUM problem333Given sets do there exist s.t . is one of the first problems used for conditional lower bounds. Initially introduced to explain various quadratic-time barriers observed in computational geometry [23], it has since been used to show quadratic-time hardness for a wealth of problems from various fields [41, 35, 5, 34, 13]. Its generalization, the -SUM problem444The -SUM problem asks, given sets of numbers, whether there exist such that . The -SUM hypothesis states that for no there exists a time algorithm that solves -SUM., has led to further conditional lower bounds beyond quadratic-time solvable problems [18, 4, 1, 2]. For a more comprehensive overview, we refer to the survey of Williams [43].
An important aspect of our investigations is that we establish fine-grained equivalences with -SUM problems, which requires the somewhat unusual direction of reducing certain problems to -SUM. Conveniently, we may exploit for this task a recent completeness theorem [24]: This work introduces general classes of problems which can be reduced to -SUM, thereby simplifying the arguments needed to reduce sumset-related problems to -SUM. Specifically, we shall need the existential fragment of the class : It consists of problems whose inputs are sets , and free variables , and the task is to determine whether there exist such that holds, where is a fixed, but arbitrary linear arithmetic formula over the vector entries of and the free variables. (In particular, the dimensions are constant.) Each such problem is near-linear time reducible to -SUM. We will frequently argue in our reductions that subtasks can be expressed as an existential formula and exploit the completeness theorem.
Further related work
The authors in [9] explored connections of the sorting problem with the -convolution problem. Other works consider the fine-grained complexity of other notions of succinct inputs, such as representing sequences succinctly as grammar-based compressions [2, 1], or succinctly defined graphs using the notion of factored graphs [25].
1.2 Our results
We investigate the succinct versions of many well-studied geometric primitives solvable in near-linear time. While some turn out to be easy, many others can be tightly connected to the -SUM problem. In fact, we believe our results may serve as template to classify further problems according to their succinct complexity.
Some succinctly easy problems
For context, we observe that there is a large number of non-trivial geometric primitives (beyond selection) for which fast succinct computation is indeed possible.
As perhaps most prominent and well-known example, consider the convex hull problem: Given , compute the convex hull of . By a folklore identity, , with complexity . This yields -time algorithms for succinctly computing convex hulls, see also [17]. This fact leads us to the following general observation.
Observation 1.
If we can compute by a -time algorithm that receives as input only the convex hull of of size , then succinct- can be solved in time .
While the observation is simple, it leads to an interesting class of problems which can be solved in near-linear time in the size of the sumset compression. Some examples of problems which can be efficiently solved using only the convex hull of the input are the diameter of points, the maximum bounding box, the distance between two convex hulls and many more, described by Shamos in [36]. All these problems can be solved with a known technique originally introduced by Shamos [37, 36], which has subsequently been coined rotating calipers and further explored by Toussaint [39].
On Closest vs. Furthest Pair
Consider the problem Closest -Pair: Given , determine . Its natural maximization analogue is Furthest -Pair: Given , determine . Both problems are solvable in near-linear time whenever is constant [22, 10].
However, we observe that the succinct versions differ substantially in their time complexity: Succinct-Furthest -Pair can be solved in time , while for succinct-Closest -Pair we obtain a 3-SUM-based lower bound of already in 1D, using the fact that the EqDist problem is 3-SUM-hard [6]; see the full version of the paper.
Naturally, we may also consider the bichromatic case of the Closest -Pair problem: Given , determine . Here, the natural succinct version receives sets as inputs, and the task is to solve the problem for and . We prove that this succinct-Bichromatic -Pair problem is fine-grained equivalent to 4-SUM. The reduction to 4-SUM follows from observing that the decision problem can be formulated as an existential formula, which can be reduced to 4-SUM [24]. It remains an interesting question whether the monochromatic succinct Closest--Pair is fine-grained equivalent to 3-SUM (our results place it between 3-SUM and 4-SUM). For further fine-grained complexity results on Closest and Furthest Pair in higher dimensions; see e.g., [42] and [31].
Multivariate 3-SUM
The remaining problems that we study will exhibit a tight connection to a multivariate version of the -SUM problem. Specifically, we introduce the following problem:
Definition 2 (All-ints -SUM).
Given sets of size , and a set of size . Determine for each in if there exists with .
It is easy to see that this problem can be solved in time : The bound follows by solving, for each , the corresponding 2-SUM problem of detecting with , which is well-known to be solvable in time . The upper bound follows from computing explicitly, and solving the corresponding dictionary problem for each . This time bound turns out to be conditionally tight; see Section 3: For any with , we show using standard techniques that this problem cannot be solved in time with unless the 3-SUM hypothesis is false. Note that this establishes a conditionally tight answer for all : If with , then we obtain a conditional lower bound via padding, and a lower bound follows from the input size of the problem.
Perhaps surprisingly, this problem naturally captures the precise fine-grained complexity of various succinct geometric primitives. Note that when , All-ints 3-SUM is well known to be subquadratic equivalent to 3-SUM [40], but a fine-grained equivalence for with does not appear to follow from standard techniques. We will thus make use of a slight generalization of the completeness theorem for existential formulas, which is implicit in [24]. Consider the following problems: Given of sizes , and , respectively, compute for each , whether there exist such that a linear arithmetic formula over the entries in the vectors holds. For every linear arithmetic formula , we can reduce this problem to instances of All-ints -SUM. A standalone proof of this fact can be found in the full version of the paper.
Succint orthogonal range queries
Consider a batched (or offline) version of answering orthogonal range queries over , which we call Batched Orthogonal Range Searching: Given and orthogonal ranges , determine for each whether is empty. This problem can be solved in time for constant , see, e.g. [12]. We observe that succinct-Batched Orthogonal Range Searching is fine-grained equivalent to All-ints 3-SUM. To reduce from All-ints 3-SUM, use as succinct input sets for a 1-dimensional instance of succinct-Batched Orthogonal Range Searching and for choose . The other direction follows from observing that we may represent the succinct Orthogonal Range Searching problem as a suitable All-ints- formula. The details can be found in the full version of the paper.
Succinct skyline (Pareto Sum)
Recall the prominent geometric problem of skyline computation (aka non-dominance filtering or maxima of point sets computation), see, e.g. [32, 14, 22]: Given , compute the set of non-dominated points, i.e., all for which there is no with and component-wise. This (explicit) problem can be solved in time [32], where denotes the output size. For , Hespe et al. show how to compute its succinct variant, the Pareto Sum, in time . We prove that computing all non-dominated points of is fine-grained equivalent to All-ints 3-SUM.
Starting point of our reduction from All-ints 3-SUM to the Pareto Sum is the subquadratic reduction from 3-SUM to Pareto Sum given in [24], which uses Conv3-SUM as an intermediate step. Notably, however, our multivariate setting poses a perhaps unexpected challenge: The standard reductions from 3-SUM to Conv3-SUM [35, 11] do not readily transfer to a multivariate setting. Instead, we introduce a variant of Conv3-SUM that we call All-ints-MixedConv3-SUM()555The definition appears related in spirit (but different) to Factored -SUM defined in [16].:
Definition 3 (All-ints-MixedConv3-SUM).
Given sequences and , where each set is a set of integers, and a sequence of integers , determine for each whether there exists some and elements such that .
This problem can easily be solved in time . We carefully adapt the reduction from 3-SUM to convolution 3-SUM given in [11] to reduce All-ints 3-SUM to All-ints-MixedConv3-SUM. As a further technical challenge, our approach requires an equivalence between the problem of computing the complete Pareto Sum and computing the Pareto Sum inside a given query range. Specifically, in our lower bound, we need to allow as query ranges quadrants of the form ; with this choice, even for sets with a Pareto Sum as large as one may still give a query range with arbitrary small outputsize , e.g., . Interestingly, using an involved construction detailed in Section 4.1, we show that this problem reduces to its specical case of computing the complete Pareto set under the promise that its size is . As a by-product, this also shows that for any , there exist sets of size of incomparable vectors in with a Pareto Sum of constant size, which does not appear to have been proven before. After showing this equivalence, we reduce All-ints-MixedConv3-SUM to Pareto Sum, reminiscent of the reduction from Convolution 3-SUM to Pareto Sum in [24].
The reverse reduction from Pareto Sum to All-ints 3-SUM is also technically interesting: while Hespe et al. [27] show how to compute each of the output points successively in time per point, unfortunately, we cannot follow this approach in our reduction (calling an All-ints 3-SUM-oracle times would trivially exceed running time). Instead, we aim to identify the output points essentially simultaneously. To this end, we perform a divide-and-conquer approach. We maintain a set of already identified Pareto Sum points , as well as a list of up to active -intervals – an interval is deemed active if it contains at least one (unidentified) point of the Pareto Sum. At each level of the recursion, we split all active intervals into two halves. The key observation is the following: Given and an arbitrary list of intervals , we can compute for each whether it contains a point in the Pareto Sum (but not already in ) using only All-ints queries, which in turn can be reduced to All-ints 3-SUM instances. After levels of the recursion, each interval consists of at most a single integer, and can be resolved fully. The details can be found in Section 4.
Succinct independent set in unit interval graphs
Consider the maximum independent set problem (MIS) in unit interval graphs: Given a set of (open) unit intervals in , compute a maximum independent set , i.e., a pairwise non-intersecting subset of intervals maximizing its size. A simple greedy algorithm is well known to solve the problem in time , see, e.g. [26]. Taking the output size into account, this can be slightly improved to time , see [38].
For studying its connection with All-ints 3-SUM, the technical work spent for the equivalence to Pareto Sum pays off: On the lower bound side, we establish a fine-grained reduction from All-ints 3-SUM to succinct-MIS in unit interval graphs using a similar approach as for the Pareto Sum. In particular, we may reduce immediately from All-ints MixedConv3-SUM, and transfer conceptually similar arguments to the MIS setting.
On the upper bound side, we are not quite able to establish the reverse reduction. However, we show how to reduce computing a maximal independent set to All-ints 3-SUM, again exploiting careful parallel binary searches in a divide-and-conquer approach. It remains an interesting open problem to reduce the MIS problem in unit interval graphs to All-ints 3-SUM. The details can be found in the full version of the paper.
Summary
For the problems equivalent to All-ints 3-SUM, our results show that improving over decompress-and-solve running time is possible whenever the output size is small enough, specifically for some . We refer to Figure 1 for an overview of the reductions shown. In the full version of the paper, we provide a table which summarizes runtimes for various problems, when defined succinctly and explicitly.
2 Preliminaries
We make use of basic tools in fine-grained complexity, for a comprehensive overview; see the survey [43]. For our purposes, the basic notion of fine-grained reduction is as follows. Consider problems , , with presumed time complexities ,, we say there is a fine-grained reduction from to if for all there exists and an algorithm solving with oracle access to such that if all calls to are replaced by an -time algorithm, then runs in time . We say problems are fine-grained equivalent if there exist fine-grained reductions from to and to . Throughout the paper, will always denote a large number which we set as follows: With , we let .
3 Multivariate -SUM variants
Let us recall two central problems for our results.
Definition 4 (All-ints -SUM).
Given sets of size , and a set of size . Determine for each in if there exists with .
Definition 5 (All-ints-MixedConv3-SUM).
Given sequences of sets and of size , and a sequence of integers , determine for every if there exists an element and an element such that .
In order to show an equivalence between All-ints -SUM and All-ints-MixedConv-SUM, we make use of a family of hash functions defined by over a uniform random prime selected in . These hash functions satisfy the following properties.
-
almost-linearity, that is or .
-
-universality, that is
Throughout, we assume that with which can be achieved using a standard universe reduction. Furthermore, the above hash functions exhibit the following additional property.
Lemma 6 (Overfull buckets [11]).
Let be a family of -universal hash functions . Furthermore, let be chosen randomly. Let be a set of integers in . We call bad iff the number of elements equal to (excluding ) exceeds a parameter . The expected number of bad elements in is at most .
We adapt the approach of Chan and He [11] (originally used to show a deterministic reduction from Convolution -SUM to -SUM) to show the following.
Lemma 7.
Let , where . If we can solve All-ints-MixedConv3-SUM in time for some , then we can solve All-ints -SUM in time for some .
Proof.
We reduce from All-ints 3-SUM. Let be a prime number chosen from where with and to be chosen later. Let and , , . We call elements in bad if where . Furthermore, we call elements bad if where . Similarly, we call elements bad if where .
The expected number of bad elements in is . The expected number of bad elements in and is .
By making use of Markov’s inequality for the sets separately, the probability that the number of bad , and elements exceed 4 times its expectation is at most each. Thus by applying the union bound, there exists a hash function , represented by some suitable prime , where the number of bad elements for each set is bounded by at most 4 times the number of expected bad elements.
We find such a hash function by going naively through all primes . The primes can be generated in time by the sieve of Eratosthenes, and computing the bucket sizes takes time .
We proceed now as follows: For the bad elements in , we perform a bruteforce -SUM algorithm, which needs time . There are at most many bad elements, thus this takes time .
For the bad elements in and , we also perform a simple bruteforce algorithm, which needs time , resulting in a runtime .
For the remaining good elements in , which occur at most times, we proceed as follows: For each possible candidate in , we perform an All-ints-MixedConv-SUM instance for both cases of the almost-additiveness. For this, we get a runtime of . Concluding, we get a total runtime of
By setting , we equate the first two terms, reducing to a runtime of:
which is bounded by . We balance the expression by setting , resulting in the final runtime , for an . We remove the polylog factors by choosing an such that , and get the desired runtime . The reverse reduction is simpler and follows the standard reduction from convolution -SUM to -SUM.
Lemma 8.
Let , where . If All-ints -SUM can be solved in time , then we can solve All-ints MixedConv-SUM in time .
Proof.
We first convert the All-intsMixed-Conv-SUM problem into an All-ints -SUM problem. Consider the newly created sets , and a large number as follows:
Due to the large choice of it holds that there exist such that iff there exists such that and there exists such that .
Lemma 9 (All-ints queries [24]).
Let , with , and be a quantifier free linear arithmetic formula. If we can solve All-ints -SUM in time , then we can determine for each , whether there exist such that is satisfied in time .
The details can be found in the full version of the paper. We conclude with a simple -SUM lower bound for All-ints -SUM.
Lemma 10.
Let for . If we can solve All-ints -SUM in time for some , then the -SUM hypothesis fails.
Proof.
We reduce from -SUM and separate the set into sets of size . We perform then instances of All-ints -SUM that run in time for some .
4 Output sensitive Skyline
We recall the two variants of the Pareto Sum problem.
Definition 11 (Succinct Skyline/Pareto Sum).
Given a succinctly defined set , the skyline (aka Pareto front) of consists of all non-dominated vectors in . More formally compute the following set: where we denote the output size by .
Definition 12 (-Succinct Skyline/-Pareto Sum).
Given a succinctly defined set , and a quadrant the skyline (aka Pareto front) of consists of all non-dominated vectors in inside . More formally compute the following set: where again we denote the output size by .
In the following section, we show that the above problems are fine-grained equivalent, which will be necessary to show the fine-grained equivalence between the Pareto Sum problem and All-ints -SUM.
4.1 On the equivalence of succinct skyline and succinct skyline
Theorem 13.
If we can compute the Pareto Sum in time , then the -Pareto Sum of an instance with and output size can be computed in time .
Proof.
Assume the quadrant to be given in the form . The goal is to construct a Pareto Sum instance where only Pareto points with and are part of the output. The reduction consists of the following steps:
-
Step 1: Transform the point coordinates in such that the minimum coordinate value is at least 1 and adapt and accordingly. Define larger than the largest possible point coordinate in and set and where and .
-
Step 2: Transform the point coordinates in and such that the minimum coordinate values are again at least 1 and adjust accordingly. Let be larger than the new maximum coordinate of any point in . Augment with points and with points , which are derived from by swapping their - and -coordinates, respectively, and replacing by and by (the transformed) .
-
Step 3: Compute the Pareto Sum of .
-
Step 4: Delete all points with coordinates smaller than or larger than from , transform the coordinates of the remaining points in by reversing the transformations applied in Step 4, delete again elements with coordinate values smaller than or larger than and finally transform the coordinates once more by reversing the transformation applied in Step 2.
Applying the steps 1 and 2 takes time each. Step 3 takes time with . Step 4 takes time in . Below, we argue that the returned result is correct and that .
After the coordinate transformation in Step 1, the elements in and have coordinates in . Figure 2 illustrates the impact of adding and to and , respectively. Firstly, we observe that all elements with or – except for – have either or . Accordingly, none of these elements can dominate any element in as their maximum coordinate is bounded by . The point , however, dominates all points in with an -coordinate of at most . These points are all outside of based on our definition of . Next, we observe that only 12 points with or are non-dominated, see again Figure 2. For cells having a colored point in Figure 2 we argue in the following that they dominate the corresponding colored ranges by comparing the - and -coordinates of the dominating point to the - and -coordinates of the dominated range.
-
dominates (yellow) since and for the -coordinates and for the -coordinates and .
-
dominates two ranges, namely and (orange). The former is dominated since and hold for the -coordinates and and for the -coordinates. For the latter range we conclude that and for the -coordinates and and for the -coordinates.
-
dominates (purple) since and for the -coordinates and and for the -coordinates.
-
dominates (light green) since and for the -coordinates and and for the -coordinates.
-
dominates (turquoise) since and for the -coordinates and and for the -coordinates.
-
dominates (dark green) since and for the -coordinates and and for the -coordinates.
Step 2 repeats the very same process of coordinate transformation and augmentation, now with the goal to introduce a filter for the points with a -coordinate smaller than . The arguments from above apply again. Therefore, computing the Pareto Sum on in Step 3 results in of size at most . Thus, the filtering and back transformation in Step 4 takes time in . Summing up over all steps, the running time is in .
After completing Step 4, is guaranteed to contain all points of the -Pareto Sum of that are strictly inside , as the points with an -coordinate of at most and a -coordinate of at most are dominated by the newly introduced elements in the augmented sumset, and Pareto points that result from the augmentation steps are filtered. We remark that the reduction in the other direction is trivial. Given an instance of Pareto Sum, we can construct an instance of -Pareto Sum with the same solution by enclosing all points in inside a large quadrant i.e . Accordingly, these two problems are fine-grained equivalent.
Moreover, our reduction technique can be leveraged to show that there are arbitrarily large Pareto Sum instances, where and consist of incomparable vectors, for which the output size is constant. In prior work, it was only shown that for an instance with and an output size is possible [33]. But the question whether there exist sets with and a Pareto Sum of size has been open. Given any Pareto Sum instance, we can define as the maximum coordinate of any Pareto point in . Using the augmentation described in Step 2 in the proof of Theorem 13, all Pareto points of will be dominated and only 12 new Pareto points will be introduced. Thus, we get the following corollary.
Corollary 14.
For any , there exist sets of incomparable vectors with and output size of the Pareto Sum .
4.2 A lower bound from All-ints -SUM
Lemma 15.
If we can compute the output-sensitive -Pareto Sum of size for for sets in time , then we can solve All-ints MixedConv-SUM in time .
Proof.
Consider an All-ints MixedConv-SUM instance given by array of sets of size , and the array . Let , It is clear that the newly constructed sets are of size at most and the set of size at most . Let , and by the above construction, it holds that for an index there does not exist a , where and such that if and only if for all there exists , where one of the following two inequalities holds: or Let us create the following set of the left side of the inequalities observed, that is .
We will construct the following sets in , in order to integrate both above inequalities in a Pareto Sum problem.
We perform an output sensitive -Pareto Sum computation on the following sets, with a quadrant , which we determine in a bit.
The sumset then consists of the following sumsets:
We set the quadrant , thus forcing the output-sensitive -Pareto Sum to ignore everything besides the points in and .
Let us first argue that the points in need to be part of the output-sensitive skyline. We argue based on the indices , which separate the points in and into clusters of points. For each the points in are of the form For each the two points originally induced by index , now in are of the form For each , we now observe the points which are included in the Pareto Sum. Clearly, the Pareto front, will contain as it is the point with the largest -coordinate among the points landing at the cluster of points induced by index . Furthermore, the point is contained in the Pareto Sum as it is the point with the highest -coordinate among the points landing at the cluster of points induced by index . Let us prove the following claim.
Claim 16.
The Pareto front of the cluster of points induced by index will contain precisely the points if and only if there is no such that there exists an and with .
Proof.
As argued before the points , will always be in the Pareto Sum induced by index . Assume there exists an index such that there exists an and such that , then in the sumset there will be a point of the form:
The point does not dominate because of the -coordinate. Furthermore, the point does not dominate because of the -coordinate. Lastly, it is easy to see that the only points not dominated by or in the cluster of points induced by index need to be of the form . Concluding, the Pareto front of the cluster of points induced by index will contain precisely the points if and only if there exists a and and with . After having proven the claim, it remains to scan through the Pareto Sum and identify whether the Pareto front induced by each index consists of two points, concluding the reduction from All-ints MixedConv-SUM. Lastly, notice that the size of the Pareto front evaluated is at most . By a simple padding argument we can now show the following lower bound.
Lemma 17.
Let . There is no output-sensitive algorithm to compute the Pareto Sum of sets of size in time with guaranteed output size , where and , unless All-ints -SUM can be solved in time for an .
Proof.
Case is shown in Lemma 15, by making use of the fine-grained equivalence between All-ints -SUM and All-ints-MixedConv-3-SUM.
We reduce from the case , let . We construct an artificial blowup of the Pareto Sum output set of size . To this end, take a subset of of size from the set . Let the vectors in be numbered arbitrarily . Construct the following set:
The Pareto Sum will now consist of the original Pareto Sum of size combined, with of size . This holds due to the fact that all vectors in are incomparable to each other, and incomparable to the vectors , due to the shift chosen for each vector. Let us now make use of the -SUM hardness of All-ints -SUM to show the following lower bound, by a simple combination of Lemma 15 and Lemma 17.
Theorem 18.
Let , where . There is no algorithm to solve output sensitive Pareto Sum of output size , in time for an , unless the -SUM hypothesis fails.
Proof.
4.3 A reduction to All-ints -SUM
Lemma 19.
Given sets of size and closed intervals . We can compute for all intervals the highest point in with -coordinate in in time if All-ints -SUM can be solved in time .
Proof.
We consider a parallel binary search approach. Let and . An application of All-ints query to the set on the formula
gives us an answer for each interval , where , whether there exist points such that the -coordinate of lies on the interval and the -coordinate of is higher than . By appropriately changing the value of , for each interval and constructing a new formula in a logarithmic number of steps, we can find the height of the highest point in each interval via a parallel binary search.
We now continue computing the -coordinate of the highest point for each interval, which we can also compute by a binary search. Consider , where and construct the following set . An application of All-ints query to the set of the formula
gives us an answer for each Interval , whether there exists such that the -coordinate of lies on or to the right of and the -coordinate of is precisely the -coordinate of the highest point in the interval .
Thus, by appropriately changing the value of for each interval and constructing a new formula, in a logarithmic number of steps, we can find a corresponding -coordinate to the highest -coordinate in each interval via a parallel binary search. Notice that we can choose to binary search in such a way as to find for each interval the rightmost point, which equals the highest -coordinate. Lastly, we can also deduce if there is no point inside an interval at all.
For the runtime notice that a parallel binary search on an All-ints query runs in time by Lemma 9, where denotes the size of the universe.
Theorem 20.
If we can solve All-ints -SUM in time , then we can compute an output sensitive Pareto Sum in time
Proof.
We perform a divide and conquer approach, where we keep a collection of disjoint intervals , with the invariant that every interval contains at least one point the Pareto front of whose -coordinate lies in . Furthermore, keep a set which stores the points of the skyline of .
Start with the set of intervals given by one interval concluding the -coordinate of all points, . We now state the general procedure.
Firstly, compute the highest points inside all intervals in by an application of Lemma 19. In the beginning we directly, store this point in the set as it must be part of the Pareto front of .
Now, for each interval in , we create two intervals and , where is the middle -coordinate of the interval . Perform a call on Lemma 19 with and the set of intervals , to compute the highest points of the non-empty intervals. In the case of several highest points in an interval, Lemma 19 computes the rightmost highest point. We can now deduce for each of the intervals in if it contains at least one point in the Pareto front of . Clearly if the interval is empty, we can disregard it and keep the non-empty half. Assume for , we have that and are both non-empty, with the highest points being and respectively. If dominates the point , we can disregard the interval , as it can not be part of the Pareto front of , any further subdivision of would create only more dominated points by monotonicity. Otherwise, we know and . Let and , be the rightmost highest points of the intervals and respectively, which can be computed by a call to Lemma 19 for all non-empty intervals . We will keep the interval (store in ) iff does not dominate , and will keep the interval (and store in ) iff the point does not dominate . Continue recursively, with the set of non-disregarded intervals , and the stored Pareto front points , where we terminate the recursion and return the set when all intervals in are of length .
For the correctness, we remark that the invariant holds that every interval in holds at least one point in the Pareto front. For the runtime, notice that the length of the intervals is halved in every recursion step. Finally, we have a recursion depth of at most , where denotes the size of the universe, and in each recursion, we perform a call to Lemma 19 with at most intervals (including the computation of and ). Thus, we get a final runtime of .
5 Conclusion
We conclude with some open questions. It appears difficult to reduce All-ints -SUM to -SUM when , which would lead to a fine-grained equivalence between the problems. A first step might be to investigate if All-ints -SUM admits an efficient self-reduction. Furthermore, it remains to classify further problems into being succinctly-easy or succinctly-equivalent to variants of -SUM. Finally, it is interesting to study good representations of arbitrary sets as sumsets . In recent work [3], it was shown that determining perfect representability is NP-hard. However, perhaps we can efficiently compute approximate representations of sumsets, which may even lead to efficient (approximation) algorithms for explicit versions of various geometric primitives.
References
- [1] Amir Abboud, Arturs Backurs, Karl Bringmann, and Marvin Künnemann. Fine-grained complexity of analyzing compressed data: Quantifying improvements over decompress-and-solve. In Chris Umans, editor, 58th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October 15-17, 2017, pages 192–203. IEEE Computer Society, 2017. doi:10.1109/FOCS.2017.26.
- [2] Amir Abboud, Arturs Backurs, Karl Bringmann, and Marvin Künnemann. Impossibility results for grammar-compressed linear algebra. In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin, editors, Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. URL: https://proceedings.neurips.cc/paper/2020/hash/645e6bfdd05d1a69c5e47b20f0a91d46-Abstract.html.
- [3] Amir Abboud, Nick Fischer, Ron Safier, and Nathan Wallheimer. Recognizing sumsets is np-complete. In Yossi Azar and Debmalya Panigrahi, editors, Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2025, New Orleans, LA, USA, January 12-15, 2025, pages 4484–4506. SIAM, 2025. doi:10.1137/1.9781611978322.153.
- [4] Amir Abboud and Kevin Lewi. Exact weight subgraphs and the k-sum conjecture. In Fedor V. Fomin, Rusins Freivalds, Marta Z. Kwiatkowska, and David Peleg, editors, Automata, Languages, and Programming - 40th International Colloquium, ICALP 2013, Riga, Latvia, July 8-12, 2013, Proceedings, Part I, volume 7965 of Lecture Notes in Computer Science, pages 1–12. Springer, 2013. doi:10.1007/978-3-642-39206-1_1.
- [5] Amir Abboud and Virginia Vassilevska Williams. Popular conjectures imply strong lower bounds for dynamic problems. In 55th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2014, Philadelphia, PA, USA, October 18-21, 2014, pages 434–443. IEEE Computer Society, 2014. doi:10.1109/FOCS.2014.53.
- [6] Gill Barequet and Sariel Har-Peled. Polygon containment and translational min-hausdorff-distance between segment sets are 3sum-hard. Int. J. Comput. Geom. Appl., 11(4):465–474, 2001. doi:10.1142/S0218195901000596.
- [7] Antonio Hernández Barrera. Finding an o(n2 log n) algorithm is sometimes hard. In Proceedings of the 8th Canadian Conference on Computational Geometry, pages 289–294. Carleton University Press, 1996. URL: http://www.cccg.ca/proceedings/1996/cccg1996_0048.pdf.
- [8] Manuel Blum, Robert W. Floyd, Vaughan R. Pratt, Ronald L. Rivest, and Robert Endre Tarjan. Time bounds for selection. J. Comput. Syst. Sci., 7(4):448–461, 1973. doi:10.1016/S0022-0000(73)80033-9.
- [9] David Bremner, Timothy M. Chan, Erik D. Demaine, Jeff Erickson, Ferran Hurtado, John Iacono, Stefan Langerman, Mihai Puatracscu, and Perouz Taslakian. Necklaces, convolutions, and X+Y. Algorithmica, 69(2):294–314, 2014. doi:10.1007/S00453-012-9734-3.
- [10] Timothy M. Chan. Orthogonal Range Searching in Moderate Dimensions: k-d Trees and Range Trees Strike Back. In Boris Aronov and Matthew J. Katz, editors, 33rd International Symposium on Computational Geometry (SoCG 2017), volume 77 of Leibniz International Proceedings in Informatics (LIPIcs), pages 27:1–27:15, Dagstuhl, Germany, 2017. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.SoCG.2017.27.
- [11] Timothy M. Chan and Qizheng He. Reducing 3sum to convolution-3sum. In Martin Farach-Colton and Inge Li Gørtz, editors, 3rd Symposium on Simplicity in Algorithms, SOSA 2020, Salt Lake City, UT, USA, January 6-7, 2020, pages 1–7. SIAM, 2020. doi:10.1137/1.9781611976014.1.
- [12] Timothy M. Chan, Kasper Green Larsen, and Mihai Pătraşcu. Orthogonal range searching on the ram, revisited. In Ferran Hurtado and Marc J. van Kreveld, editors, Proceedings of the 27th ACM Symposium on Computational Geometry, Paris, France, June 13-15, 2011, pages 1–10. ACM, 2011. doi:10.1145/1998196.1998198.
- [13] Timothy M. Chan, Virginia Vassilevska Williams, and Yinzhan Xu. Hardness for triangle problems under even more believable hypotheses: reductions from real apsp, real 3sum, and OV. In Stefano Leonardi and Anupam Gupta, editors, STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 - 24, 2022, pages 1501–1514. ACM, 2022. doi:10.1145/3519935.3520032.
- [14] Wei-Mei Chen, Hsien-Kuei Hwang, and Tsung-Hsi Tsai. Maxima-finding algorithms for multidimensional samples: A two-phase approach. Comput. Geom., 45(1-2):33–53, 2012. doi:10.1016/J.COMGEO.2011.08.001.
- [15] Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, and Clifford Stein. Introduction to algorithms. MIT press, 2022.
- [16] Mina Dalirrooyfard, Andrea Lincoln, and Virginia Vassilevska Williams. New techniques for proving fine-grained average-case hardness. In Sandy Irani, editor, 61st IEEE Annual Symposium on Foundations of Computer Science, FOCS 2020, Durham, NC, USA, November 16-19, 2020, pages 774–785. IEEE, 2020. doi:10.1109/FOCS46700.2020.00077.
- [17] Mark de Berg, Otfried Cheong, Marc J. van Kreveld, and Mark H. Overmars. Computational geometry: algorithms and applications, 3rd Edition. Springer, 2008. doi:10.1007/978-3-540-77974-2.
- [18] Jeff Erickson. New lower bounds for convex hull problems in odd dimensions. SIAM J. Comput., 28(4):1198–1214, 1999. doi:10.1137/S0097539797315410.
- [19] Greg N. Frederickson and Donald B. Johnson. The complexity of selection and ranking in X+Y and matrices with sorted columns. J. Comput. Syst. Sci., 24(2):197–208, 1982. doi:10.1016/0022-0000(82)90048-4.
- [20] Michael L. Fredman. How good is the information theory bound in sorting? Theor. Comput. Sci., 1(4):355–361, 1976. doi:10.1016/0304-3975(76)90078-5.
- [21] Daniel Funke, Demian Hespe, Peter Sanders, Sabine Storandt, and Carina Truschel. Pareto sums of pareto sets: Lower bounds and algorithms. Algorithmica, pages 1–34, 2025.
- [22] Harold N. Gabow, Jon Louis Bentley, and Robert Endre Tarjan. Scaling and related techniques for geometry problems. In Richard A. DeMillo, editor, Proceedings of the 16th Annual ACM Symposium on Theory of Computing, April 30 - May 2, 1984, Washington, DC, USA, pages 135–143. ACM, 1984. doi:10.1145/800057.808675.
- [23] Anka Gajentaan and Mark H. Overmars. On a class of o(n2) problems in computational geometry. Comput. Geom., 5:165–185, 1995. doi:10.1016/0925-7721(95)00022-2.
- [24] Geri Gokaj and Marvin Künnemann. Completeness theorems for k-sum and geometric friends: Deciding fragments of linear integer arithmetic. In Raghu Meka, editor, 16th Innovations in Theoretical Computer Science Conference, ITCS 2025, January 7-10, 2025, Columbia University, New York, NY, USA, volume 325 of LIPIcs, pages 55:1–55:25. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPICS.ITCS.2025.55.
- [25] Shreya Gupta, Boyang Huang, Russell Impagliazzo, Stanley Woo, and Christopher Ye. The computational complexity of factored graphs. In Raghu Meka, editor, 16th Innovations in Theoretical Computer Science Conference, ITCS 2025, January 7-10, 2025, Columbia University, New York, NY, USA, volume 325 of LIPIcs, pages 58:1–58:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPICS.ITCS.2025.58.
- [26] Udaiprakash I. Gupta, D. T. Lee, and Joseph Y.-T. Leung. Efficient algorithms for interval graphs and circular-arc graphs. Networks, 12(4):459–467, 1982. doi:10.1002/NET.3230120410.
- [27] Demian Hespe, Peter Sanders, Sabine Storandt, and Carina Truschel. Pareto sums of pareto sets. In Inge Li Gørtz, Martin Farach-Colton, Simon J. Puglisi, and Grzegorz Herman, editors, 31st Annual European Symposium on Algorithms, ESA 2023, September 4-6, 2023, Amsterdam, The Netherlands, volume 274 of LIPIcs, pages 60:1–60:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ESA.2023.60.
- [28] Donald B. Johnson and Samuel D. Kashdan. Lower bounds for selection in x + y and other multisets. J. ACM, 25(4):556–570, October 1978. doi:10.1145/322092.322097.
- [29] Donald B. Johnson and Tetsuo Mizoguchi. Selecting the kth element in X + Y and x_1 + x_2 + … + x_m. SIAM J. Comput., 7(2):147–153, 1978. doi:10.1137/0207013.
- [30] Haim Kaplan, László Kozma, Or Zamir, and Uri Zwick. Selection from heaps, row-sorted matrices, and X+Y using soft heaps. In Jeremy T. Fineman and Michael Mitzenmacher, editors, 2nd Symposium on Simplicity in Algorithms, SOSA 2019, January 8-9, 2019, San Diego, CA, USA, volume 69 of OASIcs, pages 5:1–5:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/OASICS.SOSA.2019.5.
- [31] Karthik C. S. and Pasin Manurangsi. On closest pair in euclidean metric: Monochromatic is as hard as bichromatic. Comb., 40(4):539–573, 2020. doi:10.1007/S00493-019-4113-1.
- [32] David G. Kirkpatrick and Raimund Seidel. Output-size sensitive algorithms for finding maximal vectors. In Joseph O’Rourke, editor, Proceedings of the First Annual Symposium on Computational Geometry, Baltimore, Maryland, USA, June 5-7, 1985, pages 89–96. ACM, 1985. doi:10.1145/323233.323246.
- [33] Kathrin Klamroth, Bruno Lang, and Michael Stiglmayr. Efficient dominance filtering for unions and minkowski sums of non-dominated sets. Computers & Operations Research, 163:106506, 2024. doi:10.1016/J.COR.2023.106506.
- [34] Tsvi Kopelowitz, Seth Pettie, and Ely Porat. Higher lower bounds from the 3sum conjecture. In Robert Krauthgamer, editor, Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 1272–1287. SIAM, 2016. doi:10.1137/1.9781611974331.CH89.
- [35] Mihai Pătraşcu. Towards polynomial lower bounds for dynamic problems. In Leonard J. Schulman, editor, Proceedings of the 42nd ACM Symposium on Theory of Computing, STOC 2010, Cambridge, Massachusetts, USA, 5-8 June 2010, pages 603–610. ACM, 2010. doi:10.1145/1806689.1806772.
- [36] Franco P. Preparata and Michael Ian Shamos. Computational Geometry - An Introduction. Texts and Monographs in Computer Science. Springer, 1985. doi:10.1007/978-1-4612-1098-6.
- [37] MI Shamos. Computational geometry[ph. d. thesis], 1978.
- [38] Jack Snoeyink. Maximum independent set for intervals by divide and conquer with pruning. Networks, 49(2):158–159, 2007. doi:10.1002/NET.20150.
- [39] Godfried T Toussaint. Solving geometric problems with the rotating calipers. In Proc. IEEE Melecon, volume 83, page A10, 1983.
- [40] Virginia Vassilevska Williams and Ryan Williams. Subcubic equivalences between path, matrix and triangle problems. In 51th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2010, October 23-26, 2010, Las Vegas, Nevada, USA, pages 645–654. IEEE Computer Society, 2010. doi:10.1109/FOCS.2010.67.
- [41] Virginia Vassilevska Williams and Ryan Williams. Finding, minimizing, and counting weighted subgraphs. SIAM J. Comput., 42(3):831–854, 2013. doi:10.1137/09076619X.
- [42] Ryan Williams. On the difference between closest, furthest, and orthogonal pairs: Nearly-linear vs barely-subquadratic complexity. In Artur Czumaj, editor, Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2018, New Orleans, LA, USA, January 7-10, 2018, pages 1207–1215. SIAM, 2018. doi:10.1137/1.9781611975031.78.
- [43] Virginia Vassilevska Williams. On some fine-grained questions in algorithms and complexity. In Proceedings of the international congress of mathematicians: Rio de janeiro 2018, pages 3447–3487. World Scientific, 2018.
