6 research outputs found
All non-trivial variants of 3-LDT are equivalent
The popular 3-SUM conjecture states that there is no strongly subquadratic
time algorithm for checking if a given set of integers contains three distinct
elements that sum up to zero. A closely related problem is to check if a given
set of integers contains distinct such that .
This can be reduced to 3-SUM in almost-linear time, but surprisingly a reverse
reduction establishing 3-SUM hardness was not known.
We provide such a reduction, thus resolving an open question of Erickson. In
fact, we consider a more general problem called 3-LDT parameterized by integer
parameters and . In this problem, we need to
check if a given set of integers contains distinct elements
such that . For some combinations
of the parameters, every instance of this problem is a NO-instance or there
exists a simple almost-linear time algorithm. We call such variants trivial. We
prove that all non-trivial variants of 3-LDT are equivalent under subquadratic
reductions. Our main technical contribution is an efficient deterministic
procedure based on the famous Behrend's construction that partitions a given
set of integers into few subsets that avoid a chosen linear equation
Data Structures Meet Cryptography: 3SUM with Preprocessing
This paper shows several connections between data structure problems and
cryptography against preprocessing attacks. Our results span data structure
upper bounds, cryptographic applications, and data structure lower bounds, as
summarized next.
First, we apply Fiat--Naor inversion, a technique with cryptographic origins,
to obtain a data structure upper bound. In particular, our technique yields a
suite of algorithms with space and (online) time for a preprocessing
version of the -input 3SUM problem where .
This disproves a strong conjecture (Goldstein et al., WADS 2017) that there is
no data structure that solves this problem for and for any constant .
Secondly, we show equivalence between lower bounds for a broad class of
(static) data structure problems and one-way functions in the random oracle
model that resist a very strong form of preprocessing attack. Concretely, given
a random function (accessed as an oracle) we show how to
compile it into a function which resists -bit
preprocessing attacks that run in query time where
(assuming a corresponding data structure lower bound
on 3SUM). In contrast, a classical result of Hellman tells us that itself
can be more easily inverted, say with -bit preprocessing in
time. We also show that much stronger lower bounds follow from the hardness of
kSUM. Our results can be equivalently interpreted as security against
adversaries that are very non-uniform, or have large auxiliary input, or as
security in the face of a powerfully backdoored random oracle.
Thirdly, we give non-adaptive lower bounds for 3SUM and a range of geometric
problems which match the best known lower bounds for static data structure
problems
Perfect Binary Space Partitions
In this paper we discuss some results on perfect binary space partitions on sets of non-intersecting line segments in two dimensions. A binary space partition is a scheme for recursively dividing a configuration of objects by hyperplanes until all objects are separated. A binary space partition is called perfect when none of the objects is cut by the hyperplanes used by the binary space partition. Given a set of n non-intersecting line segments, our method constructs a perfect binary space partition, or decides that no perfect binary space partition exists for the arrangement of line segments, in O(n 2 log n) time
Perfect binary space partitions
A binary space partition is a recursive partitioning of a configuration of objects by hyperplanes until all objects are separated. A binary space partition is called perfect if none of the objects is cut by the hyperplanes used by the binary space partition. We present an algorithm that, given a set S of n non-intersecting line segments in the plane, constructs a perfect binary space partition for S, or decides that no perfect binary space partition exists for S, in O(min(n2, n log3 n+m log n)) time, where m is the number of edges in the visibility graph of S. We also prove that deciding whether a set of segments admits a perfect BSP is 3 -hard