Simplex range reporting on a pointer machine

AbstractWe give a lower bound on the following problem, known as simplex range reporting: Given a collection P of n points in d-space and an arbitrary simplex q, find all the points in P ∩ q. It is understood that P is fixed and can be preprocessed ahead of time, while q is a query that must be answered on-line. We consider data structures for this problem that can be modeled on a pointer machine and whose query time is bounded by O(nδ + r), where r is the number of points to be reported and δ is an arbitrary fixed real. We prove that any such data structure of that form must occupy storage Ω(nd(1 − δ)− ε), for any fixed ε > 0. This lower bound is tight within a factor of nε

Output-Sensitive Tools for Range Searching in Higher Dimensions

Let $P$ be a set of $n$ points in ${\mathbb R}^{d}$. A point $p \in P$ is $k$\emph{-shallow} if it lies in a halfspace which contains at most $k$ points of $P$ (including $p$). We show that if all points of $P$ are $k$-shallow, then $P$ can be partitioned into $\Theta(n/k)$ subsets, so that any hyperplane crosses at most $O((n/k)^{1-1/(d-1)} \log^{2/(d-1)}(n/k))$ subsets. Given such a partition, we can apply the standard construction of a spanning tree with small crossing number within each subset, to obtain a spanning tree for the point set $P$, with crossing number $O(n^{1-1/(d-1)}k^{1/d(d-1)} \log^{2/(d-1)}(n/k))$. This allows us to extend the construction of Har-Peled and Sharir \cite{hs11} to three and higher dimensions, to obtain, for any set of $n$ points in ${\mathbb R}^{d}$ (without the shallowness assumption), a spanning tree $T$ with {\em small relative crossing number}. That is, any hyperplane which contains $w \leq n/2$ points of $P$ on one side, crosses $O(n^{1-1/(d-1)}w^{1/d(d-1)} \log^{2/(d-1)}(n/w))$ edges of $T$. Using a similar mechanism, we also obtain a data structure for halfspace range counting, which uses $O(n \log \log n)$ space (and somewhat higher preprocessing cost), and answers a query in time $O(n^{1-1/(d-1)}k^{1/d(d-1)} (\log (n/k))^{O(1)})$, where $k$ is the output size

Data Structure Lower Bounds for Document Indexing Problems

We study data structure problems related to document indexing and pattern matching queries and our main contribution is to show that the pointer machine model of computation can be extremely useful in proving high and unconditional lower bounds that cannot be obtained in any other known model of computation with the current techniques. Often our lower bounds match the known space-query time trade-off curve and in fact for all the problems considered, there is a very good and reasonable match between the our lower bounds and the known upper bounds, at least for some choice of input parameters. The problems that we consider are set intersection queries (both the reporting variant and the semi-group counting variant), indexing a set of documents for two-pattern queries, or forbidden- pattern queries, or queries with wild-cards, and indexing an input set of gapped-patterns (or two-patterns) to find those matching a document given at the query time.Comment: Full version of the conference version that appeared at ICALP 2016, 25 page

Complexity Theory, Game Theory, and Economics: The Barbados Lectures

This document collects the lecture notes from my mini-course "Complexity Theory, Game Theory, and Economics," taught at the Bellairs Research Institute of McGill University, Holetown, Barbados, February 19--23, 2017, as the 29th McGill Invitational Workshop on Computational Complexity. The goal of this mini-course is twofold: (i) to explain how complexity theory has helped illuminate several barriers in economics and game theory; and (ii) to illustrate how game-theoretic questions have led to new and interesting complexity theory, including recent several breakthroughs. It consists of two five-lecture sequences: the Solar Lectures, focusing on the communication and computational complexity of computing equilibria; and the Lunar Lectures, focusing on applications of complexity theory in game theory and economics. No background in game theory is assumed.Comment: Revised v2 from December 2019 corrects some errors in and adds some recent citations to v1 Revised v3 corrects a few typos in v

New deterministic algorithms for counting pairs of intersecting segments and off-line triangle range searching

We describe a new method for decomposing planar sets of segments and points. Using this method we obtain new efficient {\em deterministic} algorithms for counting pairs of intersecting segments, and for answering off-line triangle range queries. In particular we obtain the following results: \noindent (1) Given $n$ segments in the plane, the number $K$ of pairs of intersecting segments is computed in time $O(n^{1+\epsilon} + K^{1/3}n^{2/3 + \epsilon})$, where $\epsilon >0$ an arbitrarily small constant. \noindent (2) Given $n$ segments in the plane which are coloured with two colours, the number of pairs of {\em bi-chromatic} intersecting segments is computed in time $O(n^{1+\epsilon} + K_m^{1/3}n^{2/3 +\epsilon})$, where $K_m$ is the number of {\em mono-chromatic} intersections, and $\epsilon >0$ is an arbitrarily small constant. \noindent (3) Given $n$ weighted points and $n$ triangles on a plane, the sum of weights of points in each triangle is computed in time $O(n^{1+\epsilon} + {\cal K}^{1/3}n^{2/3 +\epsilon})$, where ${\cal K}$ is the number of vertices in the arrangement of the triangles, and $\epsilon>0$ an arbitrarily small constant. The above bounds depend sub-linearly on the number of intersections among segments $K$ (resp. $K_m$, ${\cal K}$), which is desirable since $K$ (resp. $K_m$, ${\cal K}$) can range from zero to $O(n^2)$. All of the above algorithms use optimal $\Theta(n)$ storage. The constants of proportionality in the big-Oh notation increase as $\epsilon$ decreases. These results are based on properties of the sparse nets introduced by Chazelle

Improved Algorithms for the Point-Set Embeddability problem for Plane 3-Trees

In the point set embeddability problem, we are given a plane graph $G$ with $n$ vertices and a point set $S$ with $n$ points. Now the goal is to answer the question whether there exists a straight-line drawing of $G$ such that each vertex is represented as a distinct point of $S$ as well as to provide an embedding if one does exist. Recently, in \cite{DBLP:conf/gd/NishatMR10}, a complete characterization for this problem on a special class of graphs known as the plane 3-trees was presented along with an efficient algorithm to solve the problem. In this paper, we use the same characterization to devise an improved algorithm for the same problem. Much of the efficiency we achieve comes from clever uses of the triangular range search technique. We also study a generalized version of the problem and present improved algorithms for this version of the problem as well

Segment Visibility Counting Queries in Polygons

Let $P$ be a simple polygon with $n$ vertices, and let $A$ be a set of $m$ points or line segments inside $P$. We develop data structures that can efficiently count the number of objects from $A$ that are visible to a query point or a query segment. Our main aim is to obtain fast, $O(\mathop{\textrm{polylog}} nm$), query times, while using as little space as possible. In case the query is a single point, a simple visibility-polygon-based solution achieves $O(\log nm)$ query time using $O(nm^2)$ space. In case $A$ also contains only points, we present a smaller, $O(n + m^{2 + \varepsilon}\log n)$-space, data structure based on a hierarchical decomposition of the polygon. Building on these results, we tackle the case where the query is a line segment and $A$ contains only points. The main complication here is that the segment may intersect multiple regions of the polygon decomposition, and that a point may see multiple such pieces. Despite these issues, we show how to achieve $O(\log n\log nm)$ query time using only $O(nm^{2 + \varepsilon} + n^2)$ space. Finally, we show that we can even handle the case where the objects in $A$ are segments with the same bounds.Comment: 27 pages, 13 figure

On Geometric Range Searching, Approximate Counting and Depth Problems

In this thesis we deal with problems connected to range searching, which is one of the central areas of computational geometry. The dominant problems in this area are halfspace range searching, simplex range searching and orthogonal range searching and research into these problems has spanned decades. For many range searching problems, the best possible data structures cannot offer fast (i.e., polylogarithmic) query times if we limit ourselves to near linear storage. Even worse, it is conjectured (and proved in some cases) that only very small improvements to these might be possible. This inefficiency has encouraged many researchers to seek alternatives through approximations. In this thesis we continue this line of research and focus on relative approximation of range counting problems. One important problem where it is possible to achieve significant speedup through approximation is halfspace range counting in 3D. Here we continue the previous research done and obtain the first optimal data structure for approximate halfspace range counting in 3D. Our data structure has the slight advantage of being Las Vegas (the result is always correct) in contrast to the previous methods that were Monte Carlo (the correctness holds with high probability). Another series of problems where approximation can provide us with substantial speedup comes from robust statistics. We recognize three problems here: approximate Tukey depth, regression depth and simplicial depth queries. In 2D, we obtain an optimal data structure capable of approximating the regression depth of a query hyperplane. We also offer a linear space data structure which can answer approximate Tukey depth queries efficiently in 3D. These data structures are obtained by applying our ideas for the approximate halfspace counting problem. Approximating the simplicial depth turns out to be much more difficult, however. Computing the simplicial depth of a given point is more computationally challenging than most other definitions of data depth. In 2D we obtain the first data structure which uses near linear space and can answer approximate simplicial depth queries in polylogarithmic time. As applications of this result, we provide two non-trivial methods to approximate the simplicial depth of a given point in higher dimension. Along the way, we establish a tight combinatorial relationship between the Tukey depth of any given point and its simplicial depth. Another problem investigated in this thesis is the dominance reporting problem, an important special case of orthogonal range reporting. In three dimensions, we solve this problem in the pointer machine model and the external memory model by offering the first optimal data structures in these models of computation. Also, in the RAM model and for points from an integer grid we reduce the space complexity of the fastest known data structure to optimal. Using known techniques in the literature, we can use our results to obtain solutions for the orthogonal range searching problem as well. The query complexity offered by our orthogonal range reporting data structures match the most efficient query complexities known in the literature but our space bounds are lower than the previous methods in the external memory model and RAM model where the input is a subset of an integer grid. The results also yield improved orthogonal range searching in higher dimensions (which shows the significance of the dominance reporting problem). Intersection searching is a generalization of range searching where we deal with more complicated geometric objects instead of points. We investigate the rectilinear disjoint polygon counting problem which is a specialized intersection counting problem. We provide a linear-size data structure capable of counting the number of disjoint rectilinear polygons intersecting any rectilinear polygon of constant size. The query time (as well as some other properties of our data structure) resembles the classical simplex range searching data structures