Entropy-Bounded Computational Geometry Made Easier and Sensitive to Sortedness

TL;DR

This paper introduces a new entropy measure called range-partition entropy for computational geometry, providing simple algorithms for various problems with running times dependent on this measure.

Contribution

It unifies previous entropy measures in computational geometry and offers new algorithms with entropy-dependent running times.

Findings

Algorithms for 2D maxima, convex hulls, and visibility problems

Running times depend on the new range-partition entropy

Simplifies and improves understanding of entropy-bounded geometric algorithms

Abstract

We study entropy-bounded computational geometry, that is, geometric algorithms whose running times depend on a given measure of the input entropy. Specifically, we introduce a measure that we call range-partition entropy, which unifies and subsumes previous definitions of entropy used for sorting problems and structural entropy used in computational geometry. We provide simple algorithms for several problems, including 2D maxima, 2D and 3D convex hulls, and some visibility problems, and we show that they have running times depending on the range-partition entropy.

Equations

$$\mathrm{H}(X)=-\sum _{i=1}^{\rho (X)}\left(\frac{|R_i|}{n}\right)\log \left(\frac{|R_i|}{n}\right).$$

$$\mathrm{H}(\Pi )=-\sum _{i=1}^t\left(\frac{|S_i|}{n}\right)\log \left(\frac{|S_i|}{n}\right).$$

$$n(\mathrm{H}(S))=\sum _{S_k\in \Pi }|S_k|\log (n/|S_k|).$$

$$\begin{array}{r}\sum _{j=0}^{\lceil \log n\rceil }{n}_j\le \sum _{j=0}^{\lceil \log n\rceil }\sum _k\min \left\{|S_k|,O\left(\frac{n}{2^j}\right)\right\}\\ \le \sum _k\sum _{j=0}^{\lceil \log n\rceil }\min \left\{|S_k|,O\left(\frac{n}{2^j}\right)\right\}\\ \le \sum _{k}O(|S_k|\lceil \log (n/|S_k|)\rceil +|S_k|+\frac{|S_k|}{2}+\frac{|S_k|}{4}+\cdots +1)\\ \le \sum _{k}O(|S_k|(\lceil \log (n/|S_k|)\rceil +2))\in O(n(\mathrm{H}(\Pi )+1))\end{array}$$

$$n(\mathrm{H}(S))=\sum _{S_k\in \Pi }|S_k|\log (n/|S_k|).$$

$$w_{i+2}\ge w_{i+1}+w_i,$$

$$w_{i+1}\ge w_i.$$

Full text

1 Introduction

Beyond worst-case algorithm design is directed at designing algorithms whose running time is asymptotically the best possible relative to some metric of the input instance [17, 18], and there has been considerable work done, for example, on instance-optimal sorting algorithms; see, e.g., [15, 11, 8, 2, 4, 20, 19, 3]. Focusing on the sorting problem for a moment, let $X=[x_{1},x_{2},\ldots,x_{n}]$ be an input sequence of distinct elements that come from a total order, and let $\mathcal{R}=\{R_{1},R_{2},\ldots,R_{\rho(X)}\}$ be a division of $X$ into a set of maximal increasing or decreasing runs (i.e., consecutive elements in $X$). These previous papers define a type of entropy, $\mathrm{H}({X})$, for a set of elements, $X$, divided into runs as follows [15, 11, 8, 2, 4, 20, 19, 3]:

[TABLE]

Sequential comparison-based sorting has a runtime lower bound of $\Omega(n(1+\mathrm{H}({X})))$, and many instance-optimal sorting algorithms have running time $O(n(1+\mathrm{H}({X})))$, which can be as small as $O(n)$ depending on the input instance. For example, Auger, Jugé, Nicaud, and Pivoteau [2] show that the popular TimSort algorithm has this time, and similarly efficient stack-based mergesort algorithms have been given by Munro and Wild [15], Jugé [11], Gelling, Nebel, Smith, and Wild [8], Buss and Knop’ [4], Takaoka [20], and Barbay and Navarro [3]. At CCCG’24, Schou and Wang introduce PersiSort [19], which also has this running time. Still, we are not aware of any work on geometric problems beyond sorting that concern instance optimality with respect to run-based entropy.

Instead, given an input, $S$, to a geometric problem, such as convex hull or maxima set, Afshani, Barbay, and Chan [1] introduce the structural entropy, $\mathrm{H}(S)$ for $S$, and they provide algorithms that run in $O(n(1+\mathrm{H}(S)))$ time for several such problems, where $n$ is the size of the input, including 2D maxima and 2D and 3D convex hulls. In contrast to the entropy used for the sorting problem, however, structural entropy explicitly ignores any near-sortedness in the input, such as can occur, e.g., with convex polygons or monotone polygonal chains.

Our Results.

In this paper, we introduce a unification of the entropy used for sorting and the structural entropy of Afshani et al. [1], which we call range-partition entropy. This unification applied even for problems that do not have obvious structural entropy: for instance, in the visibility and lower-envelope problems we study, range-partition entropy equals the entropy of an embedded sorting problem. In other cases, such as for 3D convex hulls, sortedness provides no obvious advantage, and case range-partition entropy reduces to the structural entropy of Afshani et al.

We provide simple algorithms whose running times depend on the range-partiton entropy, $\mathrm{H}(S)$, of an input set of points, $S$. For example, we give algorithms for computing maxima sets and convex hulls for $n$ points in the plane in $O(n(1+\mathrm{H}(S)))$ time. These algorithms perform no worse than any other algorithm for any input on their respective worst permutations, while also taking advantage of sortedness in the input. We also show how to adapt any instance-optimal natural mergesort to compute the lower envelope of monotone polygonal chains or the visibility polygon of a point inside a convex polygon with convex holes in time that depends on the range-partition entropy. In addition, we give a simple randomized algorithm for computing the convex hull of $n$ points in $\mathbf{R}^{3}$ and show its expected running time to be $O(n(1+\mathrm{H}(S)))$.

2 Range-Partition Entropy

Let $S=(p_{1},p_{2},\ldots,p_{n})$ be the set of $n$ points in $\mathbf{R}^{d}$ input in this given order, for constant $d\geq 1$. Define a range partition of $S$ to be a set, $\Pi=\{(S_{1},R_{1}),(S_{2},R_{2}),\ldots,(S_{t},R_{t})\}$, such that

The $S_{i}$’s form a partition of $S$, i.e., $S=\bigcup_{i=1}^{t}S_{i}$ and $S_{i}\cap S_{j}=\emptyset$ for $i\not=j$. 2. 2.

The $R_{i}$’s are geometric ranges, such as intervals in $\mathbf{R}$, axis-aligned rectangles in $\mathbf{R}^{2}$, triangles in $\mathbf{R}^{2}$, or tetrahedra in $\mathbf{R}^{3}$, such that the set, $S_{i}$, is contained in the range, $R_{i}$.

For example, if $S$ is a set of points in $\mathbf{R}^{2}$, then $\Pi$ could be a partition of $S$ into subsets contained in a set of axis-aligned rectangles, which form the ranges.

Given a sequence, $S$, of points in $\mathbf{R}^{d}$, and a range partition, $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$, for $S$, we say that $\Pi$ is respectful if it satisfies the following constraints:

For each $i=1,2,\ldots,t$, $(S_{i},R_{i})$ satisfies a given local property, which depends only on $S_{i}$ and $R_{i}$. 2. 2.

For each $i=1,2,\ldots,t$, $(S_{i},R_{i})$ satisfies a given global compatibility property, which can depend on the other pairs, $(S_{j},R_{j})$, for $j\not=i$.

Given a set, $S$, of $n$ points in $\mathbf{R}^{d}$, the entropy, $\mathrm{H}(\Pi)$, of a partition, $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$, of $S$, is

[TABLE]

The range-partition entropy, $\mathrm{H}(S)$, of $S$ is the minimum $\mathrm{H}(\Pi)$ over all respectful partitions, $\Pi$.

We reformulate the sorting problem in this framework by considering the input sequence, $S=(x_{1},x_{2},\ldots,x_{n})$, to be points in $\mathbf{R}$, and we define a partition, $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$, where each range, $R_{i}$, is an interval, $[a,b]\subset\mathbf{R}$. In this case, the local property of each $(S_{i},R_{i})$ is that $S_{i}$ is a consecutive subsequence of elements in $S$ given in sorted order, and the global property is that the $R_{i}$ ranges are disjoint, i.e., $R_{i}\cap R_{j}=\emptyset$ for $i\not=j$. Accordingly, the minimum entropy, $\mathrm{H}(\Pi)$, for all respectful partitions, $\Pi$, is determined by a partition of the input sequence into maximal non-decreasing or non-increasing runs. Thus, our framework subsumes the notion of entropy used for the sorting problem. Also, as we discuss in more detail in subsequent sections, it also subsumes the structural entropy introduced by Afshani et al. [1].

3 2D Maxima Set

The problem we study in this section is to find the maxima set of a given set of points in the plane, where a point is considered maximal if no other point dominates it, having both greater $x$- and $y$-coordinates. Our algorithm for this problem is a simple a variant of Kirkpatrick and Seidel’s “marriage-before-conquest” method [12], which was also studied by Afshani et al. [1], except our algorithm takes advantage of near-sortedness.

As preprocessing, we find the point $p_{\max}$ in $S$ with maximum $x$-coordinate, guaranteed to be a maximum point. We prune from $S$ any point dominated by $p_{\max}$. Our remaining algorithm begins by checking in linear time if the input is sorted (e.g., by $x$- or $y$-coordinates). If so, it computes the maxima set in linear time by a simple plane-sweeping stack algorithm. Otherwise, in linear time, we partition the points into left and right subsets based on the median $x$-coordinate using a stable method, we find and add to the maxima set a point with largest $y$-coordinate in the right subset, and we remove all points dominated by this point. Then our algorithm recursively solves the maxima set problem for the remaining points in the left and right subsets. See Algorithm 1 in Appendix A.

Given an input sequence of $n$ points, $S$, in $\mathbf{R}^{2}$, define the constraints for a partition, $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$, where each $R_{i}$ is an axis-aligned rectangle, to be respectful in the context of computing the maxima set for $S$ (Figure 1):

The local property for each $(S_{i},R_{i})$ is that $R_{i}$ is an axis-aligned rectangle containing $S_{i}$ and either $S_{i}$ forms a sorted subsequence in $S$ or the upper right corner of $R_{i}$ is dominated by some point in $S$. 2. 2.

The global compatibility property is that, for $i,j=1,2,\ldots,t$, if $R_{i}$ is in not dominated by a single point in $S$ (which means $S_{i}$ is in sorted order in $S$), then it will not intersect another range, $R_{j}$, for $j\not=i$.

This generalizes the notion of structurally respectful partitions from Afshani et al. [1], which is equivalent to the local condition above for unsorted subsets. It is easy to construct inputs whose structural entropy is much higher than their range-partition entropy, such as a set of $n$ maxima points given in sorted order.

Theorem 3.1**.**

Given a sequence, $S$, of $n$ points in $\mathbf{R}^{2}$, the 2DMaximaSet algorithm runs in $O(n(1+\mathrm{H}(S)))$ time, where $\mathrm{H}(S)$ is the range-partition entropy of $S$.

Proof 3.2**.**

Let us analyze 2DMaximaSet via an accounting argument where a constant amount of work in our algorithm costs one cyber-dollar. Let $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$ be a respectful partition of $S$ with minimum range-partition entropy, $\mathrm{H}(S)$. Since $n(1+\mathrm{H}(S))=n+n(\mathrm{H}(S))$, let us focus on the term

[TABLE]

Thus, after charging each point in $S$ one cyber-dollar, we can show that 2DMaximaSet runs in time $O(n(1+\mathrm{H}(S)))$ by showing that the processing we perform for each set, $S_{k}\in\Pi$, contributes at most $O(|S_{k}|\log(n/|S_{k}|)+1)$ additional cyber-dollars to the running time of our algorithm. Let $T$ denote the recursion tree for 2DMaximaSet, where each node, $v$, of $T$ corresponds to a recursive call. Each node $v$ of $T$ is associated with an interval, $I_{v}=[a_{v},b_{v}]$, of $x$-coordinates for points of $S$ between discovered maximal points for ancestors of $v$ in $T$ (or with $b_{v}=p_{\max}$ for each node, $v$, on the right spine of $T$).

So, consider a subset, $S_{k}\in\Pi$ which has the local property for unsorted sets. Say that $S_{k}$ covers $v$ if the $x$-range for $R_{k}$ spans $I_{v}$ but not $I_{\mathrm{parent}(v)}$.

$S_{k}$* is contained in an axis-aligned box, $R_{k}$, that is strictly below the staircase. Thus, for any node, $v$ in $T$, if $S_{k}$ covers $v$, then all the points of $S_{k}$ are removed from any recursive calls associated with $v$ or its descendants in $T$, because they are all dominated by the upper-right corner of $R_{k}$, which in turn is dominated by, or just is the highest point to the right side of the interval and was previously discovered to be a maxima point. If $S_{k}$ covers a node, $v$ in $T$, then it does not participate in any recursive calls for descendants of $v$ in $T$. Thus, the maximum number of points in $S_{k}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}|,\lceil n/2^{j}\rceil\}$).*

Now consider a set $S_{k}$ that has the local property for a sorted subset and its range, $R_{k}$. $S_{k}$ also satisfies the global compatibility condition for $S_{k}$. That is, $R_{k}$ is an axis-aligned box that contains $S_{k}$ such that the points of $S_{k}$ are given in sorted order in $S$ and there is no other range intersecting $R_{k}$. We will consider $S_{k}$ in two parts. Let $p$ be the rightmost point that is above $R_{k}$. $S_{k}^{(\ell)}$ is the subset of $S_{k}$ that is dominated by $p$. $S_{k}^{(r)}$ is the remaining subset. Let $R_{k}^{(\ell)}$ (similarly $R_{k}^{(r)}$) be the rectangle that has the same $y$-range as $R_{k}$ but the minimum $x$-range such that it still contains $S_{k}^{(\ell)}$ (similarly $S_{k}^{(r)}$). Say that $S_{k}^{(\ell)}$ (similarly $S_{k}^{(r)}$) covers $v$ if the $x$-range for $R_{k}^{(\ell)}$ (similarly $R_{k}^{(r)}$) spans $I_{v}$ but not $I_{\mathrm{parent}(v)}$.

If $S_{k}^{(\ell)}$ covers a node $v$ in $T$, $b_{v}$ is $p$ or above $p$ and all the points of $S_{k}^{(\ell)}$ have been pruned away and are removed from any recursive calls associated with $v$ and its descendants. Thus, the maximum number of points in $S_{k}^{(\ell)}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\ell)}|,\lceil n/2^{j}\rceil\})$.

If $S_{k}^{(r)}$ covers a node $v$ in $T$, $a_{v}$ and $b_{v}$ are in $S_{k}^{(r)}$, and no points above or below it remain in the recursive call associated with $v$. Since $S_{k}^{(r)}$ as a subset of $S_{k}$ is sorted by $x$-coordinate, during the recursive call associated with $v$, our algorithm recognizes this and computes the maxima set in linear time and there are no more recursive calls. Thus, the maximum number of points in $S_{k}^{(r)}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(r)}|,\lceil n/2^{j}\rceil\})$.

Therefore, the maximum number of points in $S_{k}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\ell)}|,\lceil n/2^{j}\rceil\})+O(\min\{|S_{k}^{(r)}|,\lceil n/2^{j}\rceil\})=O(\min\{|S_{k}|,\lceil n/2^{j}\rceil\})$.

Let $n_{j}$ denote the total number of points in $S$ that survive to level $j$ in $T$, and note that the total time (in cyber-dollars) charged to the 2DMaximaSet algorithm is proportional to $\sum_{j=0}^{\lceil\log n\rceil}n_{j}$. The proof follows, then, by the following:

[TABLE]

4 2D Convex Hull

Here we apply a similar modification to leverage sortedness in 2D convex hulls. Finding the convex hull in $\mathbf{R}^{2}$ involves identifying the smallest convex polygon that encloses all input points and returning the ordered subset of points that lie on the boundary. As with maxima sets, our algorithm follows Kirkpatrick and Seidel’s approach as presented in [1] with a modification to check for sortedness.

The algorithm proceeds as follows. We begin by computing the upper hull. To do this, we first prune all points below the line connecting the leftmost and rightmost points of the input. Check if the points sorted. If a they are sorted, find the convex hull in linear time using Graham’s scan [9]. Otherwise, the points are partitioned into two subsets based on the median $x$-coordinate, using a stable method. Next, we identify the two points that form the edge of the upper hull and intersect the vertical line at the median $x$-coordinate. This step can be done in linear time using the same method as Kirkpatrick and Seidel [13]. All points below this edge are not in the convex set and can be pruned. Recursively solve each half. Finally, the convex hulls of both subsets are concatenated to obtain the upper hull. The lower hull is computed similarly. See Algorithm 2 in Appendix A.

Given an input sequence of $n$ points, $S$, in $\mathbf{R}^{2}$, let us define the constraints for a partition, $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$, where each $R_{i}$ is a triangle, to be respectful in the context of computing the convex hull for $S$ (see Figure 2):

The local property for each $(S_{i},R_{i})$ is that $R_{i}$ is a triangle containing the points of $S_{i}$ and either $S_{i}$ forms a sorted subsequence in $S$ or $R_{i}$ lies under the convex hull of $S$. 2. 2.

The global compatibility property is that, for $i,j=1,2,\ldots,t$, if $R_{i}$ does not lie under the convex hull of $S$ (which means $S_{i}$ is in sorted order in $S$), then it will not intersect another range, $R_{j}$, for $j\not=i$.

As for the sorting problem, this generalizes the notion of structurally respectful partitions of Afshani et al. [1], which is equivalent to the local condition above for unsorted subsets. Inputs whose structural entropy is much higher than their range-partition entropy include sets of $n$ points on a circle given in sorted order.

Theorem 4.1**.**

Given a set, $Q$, of $n$ points in $\mathbf{R}^{2}$ the 2DConvexHull algorithm runs in $O(n(1+\mathrm{H}(S)))$ time, where $\mathrm{H}(S)$ is the range-partition entropy of $S$.

Proof 4.2**.**

Let us analyze 2DConvexHull via an accounting argument where a constant amount of work in our algorithm costs one cyber-dollar. Let $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$ be a respectful partition of $S$ with minimum range-partition entropy, $\mathrm{H}(S)$. Since $n(1+\mathrm{H}(S))=n+n(\mathrm{H}(S))$, let us focus on the term

[TABLE]

Thus, after charging each point in $S$ one cyber-dollar, we can show that 2DConvexHull runs in time $O(n(1+\mathrm{H}(S)))$ by showing that the processing we perform for each set, $S_{k}\in\Pi$, contributes at most $O(|S_{k}|\log(n/|S_{k}|)+1)$ additional cyber-dollars to the running time of our algorithm. Let $T$ denote the recursion tree for 2DConvexHull, where each node, $v$, of $T$ corresponds to a recursive call. Each node $v$ of $T$ is associated with an interval, $I_{v}=[a_{v},b_{v}]$, of $x$-coordinates for points of $S$ between discovered convex hull points for ancestors of $v$ in $T$ (or with $b_{v}=p_{\max}$, the point with the largest $x$-coordinate for each node, $v$, on the right spine of $T$).

So, consider a subset, $S_{k}\in\Pi$ which has the local property for unsorted sets.

$S_{k}$* is contained in a triangle, $R_{k}$, that is strictly below the convex hull. We will consider $S_{k}$ in two parts. Let $p$ be the vertex of $R_{k}$ that is opposite the lowest edge. $S_{k}^{(\ell)}$ is the subset of $S_{k}$ that is to the left of $p$. $S_{k}^{(r)}$ is the remaining subset. Let $R_{k}^{(\ell)}$ (similarly $R_{k}^{(r)}$) be the triangle on the left (similarly right) obtained by splitting $R_{k}$ along $x=p_{x}$. $S_{k}^{(\ell)}$ is contained in $R_{k}^{(\ell)}$ and$S_{k}^{(r)}$ is contained in $R_{k}^{(r)}$. Say that $S_{k}^{(\ell)}$ (similarly $S_{k}^{(r)}$) covers a node $v$ of $T$ if the $x$-range for $R_{k}^{(\ell)}$ (similarly $R_{k}^{(r)}$) spans $I_{v}$ but not $I_{\mathrm{parent}(v)}$.*

If a node $v$ is covered by $S_{k}^{(\ell)}$ (similarly $S_{k}^{(r)}$), the edge between the convex hull points with the $x$-coordinate $a_{v}$ and $b_{v}$ lie above $R_{k}^{(\ell)}$ (similarly $R_{k}^{(r)}$). During the recursive call corresponding to $v$, all points below this edge are pruned and all points from $S_{k}^{(\ell)}$ (similarly $S_{k}^{(r)}$) are removed from descendants of $v$. Thus, the maximum number of points in $S_{k}^{(\ell)}$ (similarly $S_{k}^{(r)}$) that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\ell)}|,\lceil n/2^{j}\rceil\})$ (similarly $O(\min\{|S_{k}^{(r)}|,\lceil n/2^{j}\rceil\})$). Therefore, the maximum number of points in $S_{k}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\ell)}|,\lceil n/2^{j}\rceil\})+O(\min\{|S_{k}^{(r)}|,\lceil n/2^{j}\rceil\})=O(\min\{|S_{k}|,\lceil n/2^{j}\rceil\})$.

Now consider a set $S_{k}$ that has the local property for a sorted subset and its range, $R_{k}$. $S_{k}$ also satisfies the global compatibility condition for $S_{k}$. That is, $R_{k}$ is triangle that contains $S_{k}$ such that the points of $S_{k}$ are given in sorted order in $S$ and there is no other range intersecting $R_{k}$. We will consider $S_{k}$ in five parts. Since $R_{k}$ is a triangle, there can be at most two continuous sections of the convex hull that are strictly above $R_{k}$. Let $S_{k}^{(\ell)}$, $S_{k}^{(m)}$, and $S_{k}^{(r)}$ be the subsets of $S_{k}$ that is to the left, middle, and right of these sections respectively. Let $S_{k}^{(m\ell)}$ and $S_{k}^{(mr)}$ be the subsets of $S_{k}$ that are below each of these sections. Let $R_{k}^{(\ell)}$, $R_{k}^{(m\ell)}$, $R_{k}^{(m)}$, $R_{k}^{(mr)}$, and $R_{k}^{(r)}$ be the intersection of $R_{k}$ with the corresponding $x$-ranges. Say that $S_{k}^{(\mathcal{X})}$covers $v$ if the $x$-range for $R_{k}^{(\mathcal{X})}$ spans $I_{v}$ but not $I_{\mathrm{parent}(v)}$.

If $S_{k}^{(\mathcal{X})}$ is $S_{k}^{(m\ell)}$ or $S_{k}^{(mr)}$, and covers a node $v$ in $T$, $a_{v}$ and $b_{v}$ are points in the convex hull that are above $S_{k}^{(\mathcal{X})}$ and the points of $S_{k}^{(\mathcal{X})}$ will be pruned away and are removed from any recursive calls associated with $v$ and its descendants. Thus, the maximum number of points in $S_{k}^{(\mathcal{X})}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\mathcal{X})}|,\lceil n/2^{j}\rceil\})$.

If $S_{k}^{(\mathcal{X})}$ is $S_{k}^{(\ell)}$, $S_{k}^{(m)}$, or $S_{k}^{(r)}$, and covers a node $v$ in $T$, $a_{v}$ and $b_{v}$ are in $S_{k}^{(\mathcal{X})}$, and no points above or below it remain in the recursive call associated with $v$. Since $S_{k}^{(\mathcal{X})}$ as a subset of $S_{k}$ is sorted by $x$-coordinate, during the recursive call associated with $v$, our algorithm recognizes this and computes the convex hull in linear time and there are no more recursive calls. Thus, the maximum number of points in $S_{k}^{(\mathcal{X})}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\mathcal{X})}|,\lceil n/2^{j}\rceil\})$.

Therefore, the maximum number of points in $S_{k}$ that survive to level $j$ in $T$ is $O(\min\{|S_{k}^{(\ell)}|,\lceil n/2^{j}\rceil\})+O(\min\{|S_{k}^{(m\ell)}|,\lceil n/2^{j}\rceil\})+O(\min\{|S_{k}^{(m)}|,\lceil n/2^{j}\rceil\})+O(\min\{|S_{k}^{(mr)}|,\lceil n/2^{j}\rceil\})+O(\min\{|S_{k}^{(r)}|,\lceil n/2^{j}\rceil\})=O(\min\{|S_{k}|,\lceil n/2^{j}\rceil\})$.

Let $n_{j}$ denote the total number of points in $S$ that survive to level $j$ in $T$, and note that the total time (in cyber-dollars) charged to the 2DConvexHull algorithm is proportional to $\sum_{j=0}^{\lceil\log n\rceil}n_{j}$. The proof follows, then, since $\sum_{j=0}^{\lceil\log n\rceil}n_{j}\in O(n(\mathrm{H}(\Pi)+1)))$.

5 Visibility and Lower Envelope Problems

In this section, we show how to apply range-partition entropy to analyzing some lower envelope and visibility polygon problems. In these applications, there is no structural components, however, so the range-partition entropy is the same as the entropy in these applications as the entropy used for the sorting problem; hence, our algorithms also provide geometric applications of the entropy used for the sorting problem.

Lower envelope.

Given a set of $\rho$ disjoint monotone polygonal chains, $\mathcal{S}=\{S_{1},S_{2},\ldots,S_{\rho}\}$, of total size $n$, the first problem we study is to compute the piecewise-linear lower envelope of the chains in $\mathcal{S}$.

Let us define the constraints for a partition, $\Pi=\{(S_{1},R_{1}),\ldots,(S_{t},R_{t})\}$, where each $R_{i}$ is the polygonal chain formed by $S_{i}$, to be respectful in the context of computing the lower envelope for $S$ (see Figure 3):

The local property for each $(S_{i},R_{i})$ is that $R_{i}$ is the polygonal chain of $S_{i}$ and $S_{i}$ forms a sorted subsequence in $S$. 2. 2.

The global compatibility property is that, for $i,j=1,2,\ldots,t$, $R_{i}$ will not intersect another range, $R_{j}$, for $j\not=i$

In this context, each $R_{i}$ is simply the same as $S_{i}$, and is included only for consistency with the definition of a respectful partition used across problems. Since this application does not depend on its structural components, $R_{i}$ plays no additional role in the analysis.

Let $\mathcal{A}$ be a stack-based mergesort algorithm, like TimSort [16], be a sorting algorithm that leverages monotonic runs of an input sequence, $X$, of $n$ elements to run in $O(n(1+\mathrm{H}(X)))$ time, where $\mathrm{H}(X)$ is the range-partition entropy of $X$ (which is the same as the entropy previously studied for the sorting problem). We show how to adapt $\mathcal{A}$ to computing the lower envelope of the disjoint monotone chains in $\mathcal{S}$ in $O(n(1+\mathrm{H}(S)))$ time. The algorithm, $\mathcal{A}$, works by maintaining a stack of maximal non-decreasing runs and merging consecutive pairs of them using the merge algorithm from mergesort for merging two sorted sequences according to rules based on their sizes that leads to the $O(n(1+\mathrm{H}(X)))$ running time.

Our first adaptation of the algorithm, $\mathcal{A}$, is to change the merge algorithm to be a merge of two lower envelopes, where we merge the sequences by $x$-coordinates and determine, at each $x$-coordinate, the segment with the smallest $y$-value, compressing the sequence to eliminate segment endpoints not in the lower envelope. We assign each lower envelope a weight calculated as the sum of all contributing segments to the merged result, rather than the current number of segments in the lower envelope.

The adapted version of the algorithm, $\mathcal{A}$, maintains a stack of active chains. Suppose that the stack contains chains $S_{1},S_{2},\dots,S_{k}$, with corresponding weights $w_{1},w_{2},\dots,w_{k}$. We iterate through the input chains, pushing a new chain onto the stack at each iteration, as dictated by $\mathcal{A}$. After each insertion, we invoke the merge procedure to restore $\mathcal{A}$’s invariant conditions on the stack weights. For example, if $\mathcal{A}$ were TimSort, then we would ensure that the following invariants holds at the end of each iteration:

[TABLE]

[TABLE]

These conditions guarantee that the weights of sequences on the stack in TimSort grow at least as fast as the Fibonacci numbers, which ensures that the height of the stack remains logarithmic [2].

To merge two chains as dictated by $\mathcal{A}$, we perform a linear scan over their segments, selecting the smallest $y$-value at each $x$-coordinate. Since each input chain is $x$-monotone and disjoint, the merging process runs in linear time respect to the total number of contributing input segments, up to a constant factor. This is analogous to merging two sorted sequences. See Figure 3.

Although the current envelope may contain fewer segments due to pruning of segments after some merges, the total weight still reflects the work that would have been done by $\mathcal{A}$ over the original input segments, preserving the same invariants used in $\mathcal{A}$’s merge strategy.

Theorem 5.1**.**

Given an set, $S$, of $n$ line segments partitioned into $\rho$ disjoint monotone chains, we compute the lower envelope of the chains in $S$ in $O(n(1+\mathrm{H}(S)))$ time, where $\mathrm{H}(S)$ is the range-partition entropy of $S$.

Proof 5.2**.**

The proof follows from the analysis of the algorithm, $\mathcal{A}$. For example, Theorem 1 in the analysis of TimSort by Auger et al. [2] shows that TimSort runs in $O(n+n\mathrm{H}(X))$ time on an input, $X$, of length $n$, where $\mathrm{H}(X)$ is the range-partition entropy of $X$. the run-length distribution. Our adaptation of $\mathcal{A}$ into a lower envelope algorithm can be seen as analogous to $\mathcal{A}$ in the sense that each merge in our lower envelope algorithm runs in time proportional to the time needed to perform the merges in $\mathcal{A}$. Thus, the running time for our lower-envelope algorithm is $O(n(1+\mathrm{H}(S)))$.

Visibility polygon.

In the next problem we consider, we are given a convex polygon, $P$, containing a set of convex polygonal obstacles, with total complexity $n$, and a query point, $q$, in $P$’s interior, the problem is to compute the region of $P$ that is visible from $q$. We assume that $P$ and the convex obstacles in $P$ are provided as a set of $\rho$ disjoint convex chains, $S=\{S_{1},S_{2},\ldots,S_{\rho}\}$, where each chain represents either the outer boundary or an obstacle.

This visibility problem can be reduced to computing a lower envelope of monotone disjoint sequences, for which we provided an algorithm above. Namely, at each point along the chains, the visible segment of the polygon corresponds to the segment with the minimum radius with respect to $q$ rather than the minimum $y$-value in the lower envelope setting. For each chain, we prune the vertices outside this range by locating the two endpoints of the visible window from $q$. Once pruned, the remaining chains can be merged using a linear scan based on the angle each point makes with respect to $q$. As before, we maintain the weight of each chain as the sum of all contributing segments, which increases after each merge. See Figure 4.

Theorem 5.3**.**

Suppose we are given a polygon, $P$, and convex obstacles in its interior, which are given as a collection, $S$, of $\rho$ disjoint convex chains consisting of a total of $n$ vertices, where each chain represents the outer boundary or an obstacle. Then our visibility polygon algorithm runs in $O(n(1+\mathrm{H}(S)))$ time, where $\mathrm{H}(S)$ is the range-partition entropy of $S$.

Proof 5.4**.**

The proof for the running time follows Theorem 5.1. Instead of selecting the minimum $y$-value at each $x$-value in the proof of Theorem 5.1, however, we select the minimum radius at each angle with respect to the point $q$. Thus, our visibility polygon algorithm runs in $O(n(1+\mathrm{H}(S)))$ time.

Appendix A Pseudocode

In this section, we provide pseudocode descriptions of our 2D algorithms.

Appendix B 3D Convex Hull

In this section we simplify an algorithm of Afshani et al. [1] for convex hulls of points in $\mathbb{R}^{3}$, by finding a simple randomized replacement for a key subroutine used by Afshani et al. For the set of points $S\subset\mathbb{R}^{3}$, we say that a partition $\Pi$ of $S$ is structurally respectful if for each $S_{k}\in\Pi$, there is a tetrahedron $\Delta_{k}$ that contains all the points of $S_{k}$ and lies under the convex hull. The structural entropy $\mathrm{H}(\Pi)$ of a partition $\Pi$ is defined as $\sum_{S_{k}\in\Pi}(|S_{k}|/n)\log(n/|S_{k}|)$. The entropy of $S$ is the minimum over all structurally respectful partitions of $S$.

Theorem B.1** (Theorem 3.9 in [1]).**

Given a set, $S$, of $n$ points in $\mathbf{R}^{3}$, algorithm hull3d runs in $O(n(1+\mathrm{H}(S)))$ time, where $\mathrm{H}(S)$ is the range-partition entropy of $S$.

In this algorithm, Afshani et al. assume an efficient subroutine to partition the points using Matoušek’s partition theorem [14] or the recursive use of the eight-sectioning theorem [21]. The first of these methods runs in the required $O(n\log n)$ time, but the second requires $O(n^{6}\log n)$ time. Our contribution for this section is to show how to find an approximate eight-section in expected linear time by using random sampling and combinatorial partitioning to divide the space into fair enough octants. Recursively doing this gives us the required $O(n\log n)$ time for the subroutine. For completeness, we provide the description of the convex hull algorithm using this subroutine in Appendix C.

Lemma B.2**.**

For $n$ points in $\mathbb{R}^{3}$, we can find a partition of this set into octants such that each octant has between $\frac{n}{16}$ and $\frac{3n}{16}$ points, in expected linear time.

Proof B.3**.**

First, we sample the points with probability $p=n^{-9/10}$. By linearity of expectation, the expected sample size is $\mu=n^{1/10}$. By the multiplicative Chernoff bound with $\delta=0.5$, the probability that the sample size will be between $\frac{n^{1/10}}{2}$ and $\frac{3n^{1/10}}{2}$ is at least $1-2e^{-\frac{n^{1/10}}{12}}$. We repeat the sampling process until the sample size falls within this range.

Partitioning planes are generated by selecting three points from this subset. These three points define a plane in 3D space. We slightly perturb this plane such that each of the three points lies either above, on, or below the plane. This results in 27 distinct ways in which the three points can define the plane. Since there are $O(n^{1/10})$ points in the sample, the number of ways to choose three points from this sample is $O(n^{3/10})$, and for each combination of three points, there are 27 distinct partitions. Therefore, we obtain at most $27n^{3/10}$ unique partitions from single planes. To construct a full division into octants, three planes are combined, resulting in up to $O(n^{9/10})$ possible partitions of the space into eight regions.

The algorithm examines these partitions to find one that distributes the points evenly across all octants. We are guaranteed that there is such a fair partition due to [21]. Because checking whether a single partition is balanced takes $O(n^{1/10})$ time, the runtime is $O(n)$.

Consider a subset of the original set of points that has $cn$ points. The expected number of points that are sampled from this subset is $cn^{1/10}$. By a special case of Hoeffding’s inequality [10], the probability that the fraction of points that are in this subset among all points in the sample deviates from $c$ by more than $1/16$ is less than $2e^{\frac{-n^{1/10}}{128}}$.

After getting a partition that evenly divides the sample into octants, we check if the same partition also divides all the points evenly with every octant having between $\frac{n}{16}$ and $\frac{3n}{16}$ points. By the union bound, the probability that at least one octant falls outside this range is less than $16e^{-\frac{n^{1/10}}{128}}$. If any octant falls outside this range, we repeat the sampling. The expected number of times we would have to repeat is less than $2$.

Recursive application of this method gives us the following lemma which corresponds to Lemma 3.3 in [1] in the case where the points are in $\mathbb{R}^{3}$.

Lemma B.4**.**

For any set of points $Q$ in $\mathbb{R}^{3}$, we can partition $Q$ into $r$ subsets $Q_{1},\dots,Q_{r}$, each of size $\Theta(n/r)$ and find $r$ polyhedral cells $\gamma_{1},\dots,\gamma_{r}$ each with $O(\log r)$ faces such that $Q_{i}$ is contained in $\gamma_{i}$ and every plane intersects with $O(r^{\log_{8}7})$ cells. We can do this in $O(n\log r)$ time in expectation.

Appendix C 3D Convex Hull Algorithm

For completeness we present here hull3d, the algorithm of Afshani et al. [1] for three-dimensional convex hulls, but replacing their partitioning subroutine by our linear-time approximate eight-partition from Appendix B.

Steps 3 and 4 are done using Lemma 3.8 from [1], which refers to [6, 7, 5]. Step 5 is done using any worst case optimal convex hull algorithm which takes $O(n\log n)$ time.