Encoding 3SUM

TL;DR

This paper introduces an efficient data structure for the 3SUM problem that uses near-quadratic space and enables constant-time queries for determining the sign of sums of triples from three sets.

Contribution

It presents a novel encoding scheme for 3SUM that achieves constant query time with space complexity of approximately O(N^{3/2}), improving upon previous subquadratic solutions.

Findings

Achieves constant-time queries for 3SUM sign determination.

Uses approximately O(N^{3/2}) space for encoding.

Improves on previous subquadratic space solutions.

Abstract

We consider the following problem: given three sets of real numbers, output a word-RAM data structure from which we can efficiently recover the sign of the sum of any triple of numbers, one in each set. This is similar to a previous work by some of the authors to encode the order type of a finite set of points. While this previous work showed that it was possible to achieve slightly subquadratic space and logarithmic query time, we show here that for the simpler 3SUM problem, one can achieve an encoding that takes $\tilde{O}(N^{\frac 32})$ space for inputs sets of size $N$ and allows constant time queries in the word-RAM.

Tables

Table 1. Table 1 : Table of results

	Query time	Space (in bits)	Preprocessing time
Trivial	$O\left(1\right)$	$O\left(N^3\right)$	$O\left(N^3\right)$
Almost trivial	$O\left(1\right)$	$O\left(N^2\log N\right)$	$O\left(N^2\right)$
Order-type encoding [2]	$O\left(\log N\right)$	$O\left(\frac{N^2{\log }^2\log N}{\log N}\right)$	$O\left(N^2\right)$
Order-type encoding [2]	$O\left(\frac{\log N}{\log \log N}\right)$	$O\left(\frac{N^2}{{\log }^{1-ϵ}N}\right)$	$O\left(N^2\right)$
Numeric representation (§4)	$O\left(N\right)$	$O\left(N^2\right)$	$N^{O\left(1\right)}$
Space-optimal representation (§5)	$N^{O\left(1\right)}$	$O\left(N\log N\right)$	$N^{O\left(1\right)}$
Query-optimal (§6)	$O\left(1\right)$	$\tilde{O}\left(N^{1.5}\right)$	$O\left(N^2\right)$

Equations

$$\Delta =\{(x_1,\dots ,x_N,y_1,\dots ,y_N,z_1,\dots ,z_N)\mid x_i<x_{i+1},y_j<y_{j+1},z_k<z_{k+1}\forall i,j,k\in [N-1]\}$$

$$\forall i,j,k\in [N]$$

$$\forall i,j,k\in [N-1]$$

$$\forall i,j,k\in [N]$$

$$\forall i,j,k\in [N-1]$$

$$a_i+b_1+c_{N-i+1}$$

$$a_1+b_i+c_{N-i+1}$$

$$a_{i-1}+b_{i-2}+c_{N-i+1}$$

Full text

1 The Problem

Given three sets of $N$ real numbers $A=\{\,a_{1}<a_{2}<\cdots<a_{N}\,\}$, $B=\{\,b_{1}<b_{2}<\cdots<b_{N}\,\}$, and $C=\{\,c_{1}<c_{2}<\cdots<c_{N}\,\}$, we wish to build a discrete data structure (using bits, words, and pointers) such that, given any triple $(i,j,k)\in{[N]}^{3}$ it is possible to compute the sign of $a_{i}+b_{j}+c_{k}$ by only inspecting the data structure (we cannot consult $A$, $B$, or $C$). We refer to the map $\chi:{[N]}^{3}\to\{-,0,+\},(i,j,k)\mapsto\mathrm{sgn}(a_{i}+b_{i}+c_{k})$ as the 3SUM-type of the instance $\langle A,B,C\rangle$. Obviously, one can simply construct a lookup table of size $O(N^{3})$, such that triple queries can be answered in $O(1)$ time. We aim at improving on this trivial solution.

2 Motivation

In the 3SUM problem, we are given an array of numbers as input and are asked whether any three of them sum to 0. In the mid-nineties, this problem was identified as a bottleneck of many important problems in geometry, such as detection of affine degeneracies or motion planning [5]. Since then, it has become a central problem in fine-grained complexity theory [9]. It has long been conjectured to require $\Omega(N^{2})$ time. In 2014, it was shown to be solvable in $o(N^{2})$ time, but no algorithm with running time $O(N^{2-\delta})$ with constant $\delta>0$ is known [7].

Lower bounds exist in restricted models of computation. Most notably, $\Omega(N^{2})$ 3-linear queries are needed to solve 3SUM [4], and nontrivial lower bounds have also been proven for slightly more powerful linear decision trees [1]. However, in a recent breakthrough contribution, Kane, Lovett, and Moran showed that 3SUM could be solved using $O(N\log^{2}N)$ 6-linear queries [8], hence within a $O(\log N)$ factor of the information-theoretic lower bound.

Linear decision trees are examples of nonuniform algorithms, in which we are allowed to have different algorithms for different input sizes. Algebraic decision trees generalize linear decision trees by allowing decision based on the sign of constant-degree polynomials at each node [10].

Any decision tree identifying the 3SUM-type of a 3SUM instance yields a concise encoding of this 3SUM-type: just write down the outcome of the successive tests. Knowing the decision tree by convention, this sequence of bits is sufficient to recover the sign of any triple.

The question we consider here is how to make such a representation efficient, in the sense that not only does it use merely a few bits, but the answer to any triple query can be recovered efficiently. Understanding the interplay between nonuniform algorithms and such data structures hopefully sheds light on the intrinsic structure of the problem.

3 Results

See table 1 for a summary. As there are only $O(N^{3})$ queries, a table of size $(\log_{2}3)N^{3}+O(1)$ bits suffices to give constant query time [3]. This can be improved to $O(N^{2}\log N)$ bits of space by storing for each pair $(i,j)$ the values $k_{<}(i,j)=\max\{0\}\cup\{k\colon\,a_{i}+b_{j}+c_{k}<0\}$ and $k_{>}(i,j)=\min\{N+1\}\cup\{k\colon\,a_{i}+b_{j}+c_{k}>0\}$. For a query $(i,j,k)$, we compare $k$ against the values $k_{<}(i,j)$ and $k_{>}(i,j)$ to recover $\chi(i,j,k)$ in $O(1)$ time. All $k_{<}(i,j)$ and $k_{>}(i,j)$ can be computed in $O(N^{2})$ time via the classic quadratic time algorithm for 3SUM.

One seemingly simple representation is to store the numbers in $A$, $B$ and $C$; however these are reals and thus we need to make them representable using a finite number of bits. In Section 4 we show that a minimal integer representation of a 3SUM instance may require $\Theta(N)$ bits per value, which would give rise to a $O(N)$ query time and $O(N^{2})$ space, which is far from impressive. In [2] the problem of given a set of $N$ lines, to create an encoding of them so that the orientation of any triple (the order type) can be determined was studied; our problem is a special case of this where the lines only have three slopes. Can we do better for the case of 3SUM? We answer this in the affirmative. In Section 5 we show how to use an optimal $O(N\log N)$ bits of space with a polynomial query time. Finally, in section 6 we show how to use $\tilde{O}(N^{1.5})$ space to achieve $O(1)$-time queries.

4 Representation by numbers

A first natural idea is to encode the real 3SUM instance by rounding its numbers to integers. We show a tight bound of $\Theta(N^{2})$ bits for this representation.

Lemma 1**.**

Every 3SUM instance has an equivalent integer instance where all values have absolute value at most $2^{O(N)}$. Furthermore, there exists an instance of 3SUM where all equivalent integer instances require numbers at least as large as the $N$th Fibonacci number and where the standard binary representation of the instance requires $\Omega(N^{2})$ bits.

Proof.

Every 3SUM instance $A=\{\,a_{1}<a_{2}<\ldots<a_{N}\,\}$, $B=\{\,b_{1}<b_{2}<\cdots<b_{N}\,\}$, and $C=\{\,c_{1}<c_{2}<\cdots<c_{N}\,\}$ can be interpreted as the point $(a_{1},\ldots,a_{N},b_{1},\ldots,b_{N},c_{1},\ldots,c_{N})$ in $\mathbb{R}^{3N}$. Let us use the variables $x_{1},\ldots,x_{N}$ to encode the first $N$ dimensions of $\mathbb{R}^{3N}$, $y_{1},\ldots,y_{N}$ to encode the next $N$ dimensions, and $z_{1},\ldots,z_{N}$ for the remaining dimensions. Consider the subset of $\mathbb{R}^{3N}$

[TABLE]

and the set $\Pi$ of $N^{3}$ hyperplanes $x_{i}+y_{j}+z_{k}=0$, where $i,j,k\in[N]$. Let $\mathcal{A}$ be the arrangement defined by $\Pi$ inside $\Delta$. Instances of 3SUM correspond to points in $\Delta$. Moreoever, two 3SUM instances have the same 3SUM-type if and only if they are in the same cell of $\mathcal{A}$.

Consider an instance $\langle A,B,C\rangle$ and let $\sigma=\sigma(A,B,C)$ be the cell of $\mathcal{A}$ that contains it. Then $\sigma$ is the cell defined by the inequalities

[TABLE]

Let $\sigma^{\prime}$ be the subset of $\mathbb{R}^{3N}$ defined by the following inequalities:

[TABLE]

Clearly $\sigma^{\prime}$ is contained in $\sigma$. Moreover, for a sufficiently large $\lambda>0$ the scaled instance $\langle\lambda A,\lambda B,\lambda C\rangle$ belongs to $\sigma^{\prime}$. Therefore, $\sigma^{\prime}$ is nonempty.

Since $\sigma^{\prime}$ is defined by a collection of linear inequalities defining closed halfspaces, there exists a point $p$ in $\sigma^{\prime}$ defined by a subset of at most $3N$ inequalities, where the inequalities are actually equalities. Let us assume for simplicity that exactly $3N$ equalities define the point $p$. Then, $p=(x,y,z)$ is the solution to a linear system of equations $M[x~{}y~{}z]^{T}=\delta$ where $M$ and $\delta$ have their entries in $\{-1,0,1\}$ and each row of $M$ has at most three non-zero entries. The solution $p$ to this system of equations is an instance equivalent to $\langle\lambda A,\lambda B,\lambda C\rangle$.

Because of Cramer’s rule, the system of linear equations has solution with entries $\det(M_{i})/\det(M)$, where $M_{i}$ is the matrix obtained by replacing the $i$th column of $M$ by $\delta$. We use the following simple bound on the determinant. Since $\det(M)=\sum_{\pi}\mathrm{sgn}(\pi)\prod_{i}m_{i,\pi(i)}$, where $\pi$ iterates over the permutations of $[3N]$, there are at most $3^{3N}$ summands where $\pi$ gives non-zero product $\prod_{i}m_{i,\pi(i)}$ (we have to select one non-zero entry per row), and the product is always in $\{-1,0,1\}$. Therefore $|\det(M)|\leq 3^{3N}$. Similarly, $|\det(M_{i})|\leq 4^{3N}$ because each row of $M_{i}$ has at most $4$ non-zero entries. We conclude that the solution to the system $M[x~{}y~{}z]^{T}=\delta$ are rationals that can be expressed with $O(N)$ bits. This solution gives a 3SUM instance with rationals that is equivalent to $\langle A,B,C\rangle$. Since all the rationals have the common denominator ($\det(M)$), we can scale the result by $\det(M)$ and we get an equivalent instance with integers, where each integer has $O(N)$ bits.

The proof of the second statement is by implementing the Fibonacci recurrence in each of the arrays $A,B,C$. This can be achieved by letting:

[TABLE]

The first two sets of equations ensure that the two arrays $A$ and $B$ are identical, while the array $C$ contains the corresponding negated numbers, in reverse order. From the inequalities in the third group, and depending on the choice of the initial values $a_{1},a_{2}$, each array contains a sequence growing at least as fast as the Fibonacci sequence. ∎

Note that this is a much smaller lower bound than for order types of points sets in the plane, the explicit representation of which can be shown to require exponentially many bits per coordinate [6].

5 Space-optimal representation

By considering the arrangement of hyperplanes defining the 3SUM problem, we get an information-theoretic lower bound on the number of bits in a 3SUM-type.

Lemma 2**.**

There are $2^{\Theta(N\log N)}$ distinct 3SUM-types of size $N$.

Proof.

3SUM-types of size $N$ are in one-to-one correspondence with cells of the arrangement of $N^{3}$ hyperplanes in $\mathbb{R}^{3N}$. The number of such cells is $O(N^{9N})$ and is easily shown to be at least ${(N!)}^{2}$. ∎

In order to reach this lower bound, we can simply encode the label of the cell of the arrangement in $\Theta(N\log N)$ bits. However, decoding the information requires to construct the whole arrangement which takes $N^{O(N)}$ time. An alternative solution is to store a vertex of the arrangement of hyperplanes $a_{i}+b_{j}+c_{k}\in\{\,-1,0,1\,\}$. There exists such a vertex that has the same 3SUM-type as the input point, as shown in the proof of Lemma 1. To answer any query, either recompute the vertex from the basis then answer the query using arithmetic, or use linear programming. Hence we can build a data structure of $O(N\log N)$ bits such that triple queries can be answered in polynomial time.

Note that we do not exploit much of the 3SUM structure here. In particular, the same essentially holds for $k$-SUM, and can also be generalized to a Subset Sum data structure of $O(N^{2})$ bits, from which we can extract the sign of the sum of any subset of numbers.

6 Subquadratic space and constant query time

Our encoding is inspired by Grønlund and Pettie’s $\tilde{O}(N^{1.5})$ non-uniform algorithm for 3SUM [7]. Our data structure stores three components, which we call the differences, the staircase and the square neighbors.

Differences.

Partition $A$ and $B$ into blocks of $\sqrt{N}$ consecutive elements. Let $D$ be the set of all differences of the form $a_{i}-a_{j}$ and $b_{k}-b_{\ell}$ where the items come from the same block. There are $O(N^{1.5})$ such differences. Sort $D$ and store a table indicating for each difference in $D$ its rank among all differences in $D$. This takes $O(\log N)$ bits for each of the $O(N^{1.5})$ differences, for a total of $O(N^{1.5}\log N)$ bits.

Staircase.

Look at the table $G$ formed by all sums of the form $a_{i}+b_{j}$, which is monotonic in its rows and columns due to $A$ and $B$ being sorted and view it as being partitioned into a grid $G^{\prime}$ of size $\sqrt{N}\times\sqrt{N}$ where each square of the grid is also of size $\sqrt{N}\times\sqrt{N}$. For each element $c\in C$, for each $i\in[1,\sqrt{N}]$ we store the largest $j$ such that some elements of the square $G^{\prime}[i,j]$ are $<c$, denote this as $V[c,i]$. We also store, for each $c\in C$, for each $j\in[1,\sqrt{N}]$ the smallest $i$ such that some elements of the square $G^{\prime}[i,j]$ are $\geq c$, denote this as $H[c,j]$. We thus store, in $V$ and $H$, $\sqrt{N}$ values of size $O(\log N)$ for each of the $N$ elements of $C$, for a total space usage of $O(N^{1.5}\log N)$ bits. We call this the staircase as this implicitly classifies, for each $c\in C$, whether each square has elements larger than $c$, smaller than $c$, or some larger and some smaller; only $O(\sqrt{N})$ can be in the last case, which we refer to as the staircase of $c$.

Square neighbors.

For each element $c\in C$, for each of the $O(\sqrt{N})$ squares on the staircase, we store the location of the predecessor and successor of $c$ in the squares $G^{\prime}[i,V[c,i]]$ and $G^{\prime}[H[c,j],j]$, for $i,j\in[1,\sqrt{N}]$. This takes space $O(N^{1.5}\log N)$.

To execute a query $(a_{i},b_{j},c_{k})$, only a constant number of lookups in the tables stored are needed. If $j<\sqrt{N}\cdot H[k,i]$, then we know $a_{i}+b_{j}>c_{k}$. If $i>\sqrt{N}\cdot V[k,j]$, then we know $a_{i}+b_{j}<c_{k}$. If neither of these is true, then the square $G^{\prime}[\lceil i/\sqrt{N}\rceil,\lceil j/\sqrt{N}\rceil]$ is on the staircase of $c_{i}$ and thus using the square neighbors table we can determine the location of the predecessor and successor of $c_{k}$ in this square; suppose they are at $G[s_{i},s_{j}]$ and $G[p_{i},p_{j}]$ and thus $G[s_{i},s_{j}]\leq c_{k}\leq G[p_{i},p_{j}]$. One need only determine how these two compare to $G[i,j]=a_{i}+b_{j}$ to answer the query. But this can be done using the differences as follows: to compare $G[s_{i},s_{j}]$ to $G[i,j]$ this would be determining the sign of $(a_{i}+b_{j})-(a_{s_{i}}+b_{s_{j}})$ which is equivalent to determining the result of comparing $a_{i}-a_{s_{i}}$ and $b_{j}-b_{s_{j}}$, which since both are in the same square, these differences are in $D$ and the comparison can be obtained by examining their stored ranks. By doing this for the predecessor and successor we will determine the relationship between $a_{i}+b_{j}$ and $c_{k}$.