Preprocessing Ambiguous Imprecise Points

TL;DR

This paper introduces the ambiguity measure for uncertain regions and demonstrates efficient preprocessing for sorting and quadtree reconstruction, with bounds related to ambiguity and interval entropy.

Contribution

It defines the ambiguity measure as a finer overlap metric and shows how to preprocess regions to enable fast reconstruction based on this measure.

Findings

Preprocessing of disks in $O(n \,\log n)$ time enables fast reconstruction.

Ambiguity $A(R)$ bounds the reconstruction time and can be efficiently computed.

In 1D, ambiguity relates to interval entropy and approximates graph entropy for interval orders.

Abstract

Let ${R} = \{R_1, R_2, ..., R_n\}$ be a set of regions and let $ X = \{x_1, x_2, ..., x_n\}$ be an (unknown) point set with $x_i \in R_i$. Region $R_i$ represents the uncertainty region of $x_i$. We consider the following question: how fast can we establish order if we are allowed to preprocess the regions in $R$? The preprocessing model of uncertainty uses two consecutive phases: a preprocessing phase which has access only to ${R}$ followed by a reconstruction phase during which a desired structure on $X$ is computed. Recent results in this model parametrize the reconstruction time by the ply of ${R}$, which is the maximum overlap between the regions in ${R}$. We introduce the ambiguity $A({R})$ as a more fine-grained measure of the degree of overlap in ${R}$. We show how to preprocess a set of $d$-dimensional disks in $O(n \log n)$ time such that we can sort $X$ (if $d=1$) and reconstruct a quadtree on $X$ (if $d\geq 1$ but constant) in $O(A({R}))$ time. If $A({R})$ is sub-linear, then reporting the result dominates the running time of the reconstruction phase. However, we can still return a suitable data structure representing the result in $O(A({R}))$ time. In one dimension, ${R}$ is a set of intervals and the ambiguity is linked to interval entropy, which in turn relates to the well-studied problem of sorting under partial information. The number of comparisons necessary to find the linear order underlying a poset $P$ is lower-bounded by the graph entropy of $P$. We show that if $P$ is an interval order, then the ambiguity provides a constant-factor approximation of the graph entropy. This gives a lower bound of $\Omega(A({R}))$ in all dimensions for the reconstruction phase (sorting or any proximity structure), independent of any preprocessing; hence our result is tight.

Equations

$$H(\mathcal{R})=\log n-\underset{\mathcal{I}\in E(\mathcal{R})}{\min }\left\{\frac{1}{n}\sum _{I_i\in \mathcal{I}}-\log |I_i|\right\}.$$

$$H(\mathcal{R})=\log n-\underset{\mathcal{I}\in E(\mathcal{R})}{\min }\left\{\frac{1}{n}\sum _{I_i\in \mathcal{I}}\left(\log n-\log (n|I_i|)\right)\right\}=\underset{\mathcal{I}\in E(\mathcal{R})}{\max }\left\{\frac{1}{n}\sum _{I_i\in \mathcal{I}}\log (n|I_i|)\right\}.$$

$$H(\mathcal{R})=\frac{1}{n}\underset{W\sim E(\mathcal{R})}{\max }\left\{\log \left(\prod _{w_i\in W}n{w}_i\right)\right\}.$$

$$A^{\pi }(\mathcal{R})=\log \left(\prod _{R_i\in \mathcal{R}}|{\Gamma }_i^{\pi }|\right)\le \log \left(\prod _{w_i\in W}(n{w}_i{)}^2\right)\le 2nH(\mathcal{R}).$$

$$2^{nH(\mathcal{R})}\ge \prod _{R_i\in A}\frac{|{\Gamma }_i^{\pi }|+1}{2}\prod _{R_i\in B}\frac{|{\Gamma }_i^{\pi }|+1}{2}\prod _{R_i\in C}\frac{|{\Gamma }_i^{\pi }|+1}{2}\prod _{R_i\in D}\frac{|{\Gamma }_i^{\pi }|+1}{2}\ge {\left(\frac{2}{2}\right)}^a{\left(\frac{3}{2}\right)}^b{\left(\frac{4}{2}\right)}^c{\left(\frac{4}{2}\right)}^d.$$

$$2^{nH(\mathcal{R})}\ge \prod _{R_i\in \mathcal{R}}\frac{|{\Gamma }_i^{\pi }|+1}{2}\ge \prod _{R_i\in A}|{\Gamma }_i^{\pi }|\prod _{R_i\in B}\frac{3}{4}|{\Gamma }_i^{\pi }|\prod _{R_i\in C}\frac{2}{3}|{\Gamma }_i^{\pi }|\prod _{R_i\in D}\frac{1}{2}|{\Gamma }_i^{\pi }|={\left(\frac{3}{4}\right)}^b{\left(\frac{2}{3}\right)}^c{\left(\frac{1}{2}\right)}^d{2}^{A^{\pi }(\mathcal{R})},$$

$$2^{nH(\mathcal{R})}\cdot 2^{nH(\mathcal{R})}\ge {\left(\frac{3}{2}\right)}^b{\left(\frac{4}{2}\right)}^c{\left(\frac{4}{2}\right)}^d\cdot {\left(\frac{3}{4}\right)}^b{\left(\frac{2}{3}\right)}^c{\left(\frac{1}{2}\right)}^d{2}^{A^{\pi }(\mathcal{R})}\ge 2^{A^{\pi }(\mathcal{R})},$$

$$2nH(\mathcal{R})\ge A^{\pi }(\mathcal{R}).$$

$$H(\mathcal{R},\lambda ):=\frac{1}{n}\underset{W\sim E(\mathcal{R})}{\max }\left\{\log \left(\prod _{w_i\in W}\lambda w_i\right)\right\}.$$

$$\forall \lambda ,\mu ,\mu w_i=\left(\frac{\mu }{\lambda }\right)\lambda w_i\Rightarrow 2^{nH(X,\mu )}={\left(\frac{\mu }{\lambda }\right)}^{|X|}{2}^{nH(X,\lambda )}.$$

$$2^{nH(X\cup Y)}=\underset{\lambda \in [0,n]}{\max }\{2^{nH(X,\lambda )}\cdot 2^{nH(Y,n-\lambda )}\}.$$

$$\text{Induction Hypothesis: }\forall j\le ijH({\mathcal{R}}_{\le j},j)\le 3A^{\pi }({\mathcal{R}}_{\le j}).$$

$$(i+1)H({\mathcal{R}}_{\le (i+1)},i+1)=iH({\mathcal{R}}_i,i)+\log 1\le 3A^{\pi }({\mathcal{R}}_{\le i})+3\log |{\Gamma }_{i+1}|=3A^{\pi }({\mathcal{R}}_{\le (i+1)}).$$

$$(i+1)H({\mathcal{R}}_{\le (i+1)},i+1)\le iH({\mathcal{R}}_{\le i},i)+\log \left({\left(\frac{i+1}{i}\right)}^i\right)+\log ((i+1)w_{i+1})\le iH({\mathcal{R}}_{\le i},i)+\log e+\log ((i+1)w_{i+1}).$$

$$nH({\mathcal{R}}_{\le (i+1)},i+1)\le nH({\mathcal{R}}_{\le i},i)+3\log |{\Gamma }_{i+1}|$$

Full text

Preprocessing Ambiguous Imprecise Points

Ivor van der Hoog

, 

Irina Kostitsyna

, 

Maarten Löffler

 and 

Bettina Speckmann

In one dimension, $\mathcal{R}$ is a set of intervals and the ambiguity is linked to interval entropy, which in turn relates to the well-studied problem of sorting under partial information. The number of comparisons necessary to find the linear order underlying a poset $P$ is lower-bounded by the graph entropy of $P$. We show that if $P$ is an interval order, then the ambiguity provides a constant-factor approximation of the graph entropy. This gives a lower bound of $\Omega(A(\mathcal{R}))$ in all dimensions for the reconstruction phase (sorting or any proximity structure), independent of any preprocessing; hence our result is tight. Finally, our results imply that one can approximate the entropy of interval graphs in $\mathcal{O}(n\log n)$ time, improving the $\mathcal{O}(n^{2.5})$ bound by Cardinal et al.

1. Introduction

A fundamental assumption in classic algorithms research is that the input data given to an algorithm is exact. Clearly this assumption is generally not justified in practice: real-world data tends to have (measurement or labeling) errors, heterogeneous data sources introduce yet other type of errors, and “big data” is compounding the effects. To increase the relevance of algorithmic techniques for practical applications, various paradigms for dealing with uncertain data have been introduced over the past decades. Many of these approaches have in common that they represent the uncertainty, imprecision, or error of a data point as a disk in a suitable distance metric which we call an uncertainty region. We focus on a fundamental problem from the realm of computation with uncertainties and errors: given a set of imprecise points represented by uncertainty regions, how much proximity information do the regions contain about the imprecise points?

Preprocessing model.

We study this problem within the preprocessing framework initially proposed by Held and Mitchell [14]. In this framework we have a set $\mathcal{R}=\{R_{1},R_{2},\ldots,R_{n}\}$ of regions and an point set $X=\{x_{1},x_{2},\ldots,x_{n}\}$ with $x_{i}\in R_{i}$ This model has 2 consecutive phases: a preprocessing phase followed by a reconstruction phase. In the preprocessing phase we have access only to $\mathcal{R}$ and we typically want to preprocess $\mathcal{R}$ in $\mathcal{O}(n\log n)$ time to create some linear-size auxiliary data structure which we will denote by $\Xi$. In the reconstruction phase, we have access to $X$ and we want to construct a desired output on $X$ using $\Xi$ faster than would be possible otherwise. Löffler and Snoeyink [21] were the first to use this model as a way to deal with data uncertainty: one may interpret the regions $\mathcal{R}$ as imprecise points, and the points in $X$ as their true (initially unknown) locations. This interpretation of the preprocessing framework has been successfully applied to various problems in computational geometry [5, 6, 9, 10, 19, 27]. Several results restrict $\mathcal{R}$ to be a set of disjoint (unit) disks in the plane, while others consider partially overlapping disks. Traditionally, the ply $\Delta(\mathcal{R})$ of $\mathcal{R}$, which measures the maximal number of overlapping regions, has been used to measure the degree of overlap, leading, for example, to reconstruction times of $O(n\log\Delta(\mathcal{R}))$.

The ply is arguably a somewhat coarse measure of the degree of overlap of the regions. Consider the following example: suppose that we have a collection of $\sqrt{n}$ disks in the plane that overlap in one point and that the remainder of $\mathcal{R}$ is mutually disjoint (see Figure 1 left). Then $\Delta(\mathcal{R})=\sqrt{n}$ and the resulting time complexity of the reconstruction phase is $\mathcal{O}(n\log n)$ even though it might be possible to achieve better bounds ($\mathcal{R}$ is arguably not in a worst-case configuration for that given ply, see Figure 1 right).

Ambiguity.

We introduce the ambiguity $A(\mathcal{R})$ as a more fine-grained measure of the degree of overlap in $\mathcal{R}$. The ambiguity is based on the number of regions each individual region intersects (see Figure 1). We count this number with respect to particular permutations of the regions: for each region we count only the overlap with regions that appear earlier in the permutation. A proper technical definition of ambiguity can be found in Section 2. We also show how to compute a $3$-approximation of the ambiguity in $\mathcal{O}(n\log n)$ time.

Ambiguity and entropy.

In one dimension, $\mathcal{R}$ is a set of intervals and the ambiguity is linked to interval (and graph) entropy (see Appendix A for a definition), which in turn relates to the well-studied problem of sorting under partial information. Fredman [12] shows that if the only information we are given about a set of values is a partial order $P$, and $e(P)$ is the number of linear extensions (total orders compatible with) of $P$, then we need at least $\Omega(\log e(P))$ comparisons to sort the values. Brightwell and Winkler prove that computing the number of linear extensions $e(P)$ is $\#P$-complete [4]. Hence efforts have concentrated on computing approximations, most notably via the concept of graph entropy as introduced by Körner [17]. Specifically, Khan and Kim [16] prove that $\log e(P)=\Theta(n\cdot H(G))$ where $H(G)$ denotes the entropy of the incomparability graph $G$ of the poset $P$. To the best of our knowledge there is currently no exact algorithm to compute $H(G)$. Cardinal et al. [7] describe the fastest known algorithm to approximate $H(G)$, which runs in $\mathcal{O}(n^{2.5})$ time. See Appendix A for a more in-depth discussion of sorting and its relation to graph entropy.

We consider the special case where the partial order is induced by uncertainty intervals. We define the entropy $H(\mathcal{R})$ of a set of intervals as the entropy of their intersection graph (which is also an incomparability graph) using the definition of graph entropy given by Körner. In this setting we prove that the ambiguity $A(\mathcal{R})$ provides a constant-factor approximation of the interval entropy (see Section 2). Since we can compute a constant-factor approximation of the ambiguity in $\mathcal{O}(n\log n)$ time, we can hence also compute a constant-factor approximation of the entropy of interval graphs in $\mathcal{O}(n\log n)$ time, thereby improving the result by Cardinal et al. [7] for this special case.

Ambiguity and reconstruction.

Since $\Omega(\log e(P))$ is a lower bound for the number of comparisons needed to complete $P$ into a total order, $\Omega(A(\mathcal{R}))$ is a lower bound for the reconstruction phase in the preprocessing model when $\mathcal{R}$ is a set of intervals and the goal is to sort the unknown points in $X$. This lower bound extends to higher dimensions and to proximity structures in general, independent of any preprocessing.

The ambiguity $A(\mathcal{R})$ ranges between [math] and $\Theta(n\log n)$ for a set of $n$ regions $\mathcal{R}$. If the value of $A(\mathcal{R})$ lies between $\Theta(n)$ and $\Theta(n\log n)$ then we can preprocess $\mathcal{R}$ in $\mathcal{O}(n\log n)$ time and sort in $\mathcal{O}(A(\mathcal{R}))$ time (in one dimension for arbitrary intervals) or build a quadtree in $\mathcal{O}(A(\mathcal{R}))$ time (in all dimensions for unit disks).

If the ambiguity lies between [math] and $\Theta(n)$, then reporting the results explicitly in $\Omega(n)$ time dominates the reconstruction time. But the ambiguity suggests that the information-theoretic amount of work necessary to compute the results should be lower than $\Theta(n)$. To capture this, we hence introduce a new variant of the preprocessing model, which allows us to return a pointer to an implicit representation of the results.

Specifically, in one dimension, $\mathcal{R}$ is a set of intervals and we aim to return the sorted order of the unknown points in $X$. If, for example, all intervals are mutually disjoint, then $A(\mathcal{R})=\mathcal{O}(1)$ and we have essentially no time for the reconstruction phase. However, a binary search tree $T$ on $\mathcal{R}$, which we can construct in $\mathcal{O}(n\log n)$ time in the preprocessing phase, actually captures all necessary information. In the reconstruction phase we can hence return a pointer to $T$ as an implicit representation of the sorted order. In Section 3 we show how to handle arbitrary sets of intervals in a similar manner. That is, we describe how to construct in $\mathcal{O}(n\log n)$ time an auxiliary data structure $\Xi$ on $\mathcal{R}$ in the preprocessing phase (without access to $X$), such that, in the reconstruction phase (using $X$), we can construct a linear-size AVL-tree $T$ on $X$ in $\mathcal{O}(A(\mathcal{R}))=\mathcal{O}(\log e(\mathcal{R}))$ time, which is tight.

In all dimensions, we consider $\mathcal{R}$ to be a set of unit disks and our aim is to return a quadtree $T$ on the points in $X$ where each point in $X$ lies in a unique quadtree cell. Note that in 2 dimensions, $T$ also allows us to construct e.g. the Delaunay triangulation of $X$ in linear time [5]. However, we show that constructing such a quadtree explicitly in $\mathcal{O}(A(\mathcal{R}))$ time is not possible, and the work necessary to distinguish individual points could dominate the running time and overshadow the detail in the analysis brought by the ambiguity measure. We hence follow Buchin et al. [5] and use so-called $\lambda$-deflated quadtrees which contain up to a constant $\lambda$ points in each leaf. From $T$ one can construct a quadtree on $X$ where each point lies in a unique quadtree cell in linear time. In Section 4 we describe how to reconstruct a linear-size $\lambda$-deflated quadtree $T$ (with a suitable constant $\lambda$) in $\mathcal{O}(A(\mathcal{R}))=\mathcal{O}(\log e(\mathcal{R}))$ time, which is tight (in fact, in one dimension our result also extends to non-unit intervals).

2. Ambiguity

We introduce a new measure on a set of regions $\mathcal{R}$ to reflect the degree of overlap, which we call the ambiguity. The sequence in which we process regions matters (refer to Section 2.1), thus we distinguish between the $\pi$-ambiguity defined on a given permutation of the regions in $\mathcal{R}$, and the minimum ambiguity defined over all possible permutations. We demonstrate several properties of the ambiguity, and discuss its relation to graph entropy when $\mathcal{R}$ is a set of intervals in one dimension.

Processing permutation.

Let $\mathcal{R}$ be a set of $n$ regions and let $\mathcal{R}^{\pi}=\langle R_{1},R_{2},\ldots,R_{n}\rangle$ (note that for all $i$, the region $R_{i}$ could be any region depending on the permutation $\pi$) be the sequence of elements in $\mathcal{R}$ according to a given permutation $\pi$. Then we say that $\pi$ is a processing permutation of $\mathcal{R}$. Furthermore, let $\mathcal{R}^{\pi}_{\leq i}:=\{R_{j}\mid j\leq i\}$ be the prefix of $\mathcal{R}^{\pi}$, that is, the first $i$ elements in the sequence $\mathcal{R}^{\pi}$. A permutation $\pi$ is containment-compatible if $R_{i}\subset R_{j}$ implies $i<j$ for all $i$ and $j$ [11]. When $\pi$ is clear from context, we denote $\mathcal{R}^{\pi}$ by $\mathcal{R}$.

Contact set (for a permutation $\pi$).

For a region $R_{i}\in\mathcal{R}^{\pi}$ we define its contact set $\Gamma^{\pi}_{i}$ to be the set of regions which precede or are equal to $R_{i}$ in the order $\pi$, and which intersect $R_{i}$: $\Gamma^{\pi}_{i}:=\{R_{j}\in\mathcal{R}^{\pi}_{\leq i}\mid R_{j}\cap R_{i}\not=\varnothing\}$. Note that a region is always in its own contact set. A region $R_{i}$ whose contact set $\Gamma^{\pi}_{i}$ contains only $R_{i}$ itself is called a bottom region (refer to Figure 2).

Ambiguity.

For a set of regions $\mathcal{R}$ and a fixed permutation $\pi$ we define the $\pi$-ambiguity $A^{\pi}(\mathcal{R}):=\sum_{i}\log|\Gamma^{\pi}_{i}|$ (with the logarithm to the base 2). Observe that bottom regions do not contribute to the value of the $\pi$-ambiguity. The ambiguity of $\mathcal{R}$ is now the minimal $\pi$-ambiguity over all permutations $\pi$, $A(\mathcal{R}):=\min_{\pi\in\Pi}A^{\pi}(\mathcal{R})$.

2.1. Properties of ambiguity

We show the following properties of ambiguity: (1) the $\pi$-ambiguity may vary significantly with the choice of the processing permutation $\pi$, (2) in one dimension, the $\pi$-ambiguity for any containment-compatible permutation $\pi$ on a set of intervals $\mathcal{R}$ implies a 3-approximation on the entropy of the interval graph of $\mathcal{R}$, and (3) the permutation that realizes the ambiguity is containment-compatible. Therefore in one dimension, the ambiguity of a set of intervals $\mathcal{R}$ implies a 3-approximation of the entropy of the interval graph of $\mathcal{R}$.

We start with the first property: it is easy to see that the processing permutation $\pi$ has a significant influence on the value of the $\pi$-ambiguity (refer to Figure 3). Even though $\pi$-ambiguity can vary considerably, we show that if we restrict the permutations to be containment-compatible, their $\pi$-ambiguities lie within a constant factor of the ambiguity.

Interval entropy.

The entropy of a graph $G$ was first introduced by Körner [17]. Since then several equivalent definitions appeared [26]. We define the interval entropy $H(\mathcal{R})$, for a set of intervals $\mathcal{R}$, as the entropy of the intersection graph of $\mathcal{R}$. While investigating the question of sorting an arbitrary poset, Cardinal et al.[7] found an interesting geometrical interpretation of the poset entropy, which applies to our interval entropy: let a poset $P$ describe a set of (open) intervals $\mathcal{R}$ combinatorially, that is, for each $R_{i}$ we know which intervals intersect $R_{i}$, are contained in $R_{i}$, contain $R_{i}$, and are disjoint from $R_{i}$. Denote by $E(\mathcal{R})$ the infinite set of sets of intervals on the domain $(0,1)$ (that is, each $\mathcal{I}\in E(\mathcal{R})$ is a set of intervals, where each interval $I_{i}\in\mathcal{I}$ has endpoints in $(0,1)$) which induce the same poset as $\mathcal{R}$. Then Cardinal *et al.*prove the following lemma (see Figure 4 for an illustration):

Lemma 2.1** ([7], Lemma 3.2 paraphrased).**

[TABLE]

We show that the $\pi$-ambiguity for any containment-compatible $\pi$ is a 3-approximation of $n\cdot H(\mathcal{R})$. To achieve this we rewrite the lemma from Cardinal *et al.*in the following way,

[TABLE]

An embedding $\mathcal{I}$ gives each interval $I_{i}$ a size between [math] and $1$. To simplify the algebra later, we re-interpret this size as the fraction (weight) of the domain $(0,1)$ that $I_{i}$ occupies. We associate with each $\mathcal{I}\in E(\mathcal{R})$ a set of weights $W$ such that for all $i$, $w_{i}=|I_{i}|$; we write $W\sim E(\mathcal{R})$. From now on we consider embeddings on the domain $(0,n)$: an interval then has a size $n|I_{i}|=nw_{i}$. The formula for the entropy becomes:

[TABLE]

Ambiguity and entropy.

Next, we show that the interval entropy gives an upper bound on the ambiguity. The entropy of $\mathcal{R}$ is the maximum over all embeddings on $(0,n)$, so any embedding of $\mathcal{R}$ on the domain $(0,n)$ gives a lower bound on $H(\mathcal{R})$. We will create an embedding with a corresponding weight assignment $W$ such that:

[TABLE]

We start with the original input embedding of $\mathcal{R}$ and we sort the coordinates of all the endpoints (both left- and right-). To each endpoint $p$ we assign a new coordinate $\frac{k}{2}$ if $p$ is the $k$th endpoint in the sorted order (indexing from 0). Thus, we obtain an embedding of $\mathcal{R}$ on $(0,n-\frac{1}{2})$. For any containment-compatible permutation $\pi$, the length of each interval $R_{i}$ in this embedding is at least $\frac{1}{2}|\Gamma^{\pi}_{i}|$, as each interval $R_{i}$ contains at least $|\Gamma^{\pi}_{i}|-1$ endpoints of the intervals from its contact set in its interior. Also note that the distance between every right endpoint and the consecutive endpoint to the right is $\frac{1}{2}$. Thus, we can increase the coordinate of every right endpoint by $\frac{1}{2}$ and obtain an embedding of $\mathcal{R}$ on $(0,n)$ with a corresponding weight assignment $W$, such that the length of each interval $R_{i}$ is at least $\frac{1}{2}(|\Gamma^{\pi}_{i}|+1)$. This allows us to prove the following lemma:

Lemma 2.2**.**

For any containment-compatible permutation $\pi$ of a set of intervals $\mathcal{R}$,

$A^{\pi}(\mathcal{R})\leq 2nH(\mathcal{R})$.

Proof 2.3**.**

Consider the embedding and corresponding weight assignment $W$ constructed above. Consider any containment-compatible permutation $\pi$. We split the intervals of $\mathcal{R}$ into four sets depending on the size of their contact set: let $A:=\{R_{i}\mid|\Gamma^{\pi}_{i}|=1\}$, $B:=\{R_{i}\mid|\Gamma^{\pi}_{i}|=2\}$, $C:=\{R_{i}\mid|\Gamma^{\pi}_{i}|=3\}$ and $D:=\mathcal{R}\backslash\{A,B,C\}$. Let these sets contain $a,b,c$ and $d$ intervals respectively. Then, using Equation (1) for the entropy,

[TABLE]

On the other hand,

[TABLE]

as

Then, using Equation (3) we get

[TABLE]

and therefore

[TABLE]

We continue by showing that the ambiguity also gives an upper-bound for the interval entropy. Starting with a helper lemma:

Lemma 2.4**.**

Suppose $\mathcal{R}$ is partitioned into two sets $X$ and $Y$ such that for each $R\in X,R^{\prime}\in Y$, $R$ and $R^{\prime}$ are disjoint. In any weight assignment $W$ that realizes $H(\mathcal{R})$, the intervals in $X$ together have length $|X|$ and the intervals in $Y$ together have length $|Y|$ on the domain $(0,n)$.

Proof 2.5**.**

In Equation (1) we rewrote the formula for entropy in terms of weights: for any weight assignment $W\sim E(\mathcal{R})$, $w_{i}$ is the proportion that $R_{i}$ occupies on the domain, and we embedded $\mathcal{R}$ on the domain $(0,n)$. We can similarly embed $\mathcal{R}$ on the domain $(0,\lambda)$ for an arbitrary scalar $\lambda$. We define the relative entropy of $\mathcal{R}$ (refer to Figure 5 (top)) as:

[TABLE]

Observe that $H(\mathcal{R},n)=H(\mathcal{R})$ and that:

[TABLE]

If the intervals in $X$ can occupy a width of at most $\lambda$, then it is always optimal to give the intervals in $Y$ a total width of $n-\lambda$ (since the entropy maximizes the product of the lengths of intervals in $X$ and $Y$). This implies:

[TABLE]

See Figure 5 (bottom) for an illustration of the argument. If we now substitute Equation (4) into this equation we get that the maximum is realized if $\lambda=|X|$ which proves the lemma.

Lemma 2.6**.**

Let $\pi$ be any containment-compatible permutation, then $nH(\mathcal{R})\leq 3A^{\pi}(\mathcal{R})$.

Proof 2.7**.**

We defined $\mathcal{R}_{\leq i}$ as the prefix of $\mathcal{R}$. We prove the lemma with induction on $i$.

[TABLE]

For $i=1$ both the lefthand and the righthand side are [math]. So we assume that the lemma holds for all $j\leq i$ and we prove it for $j=i+1$. $H(\mathcal{R}_{\leq i+1},i+1)$ is the relative entropy of $\mathcal{R}_{\leq(i+1)}$ on the domain $(0,i+1)$. We know that $3A^{\pi}(\mathcal{R}_{\leq(i+1})=3A^{\pi}(\mathcal{R}_{\leq i})+3\log|\Gamma_{i+1}|$. We make a distinction between two cases: $|\Gamma_{i+1}|=1$ or otherwise. If $|\Gamma_{i+1}|=1$ then $R_{i+1}$ is disjoint from $R_{\leq i}$. Lemma 2.4 guarantees, that if we want to embed $R_{\leq i}\cup\{R_{i+1}\}$ on $(0,i+1)$ that $R_{i+1}$ gets a size of $1$. The remaining intervals get embedded with a total width of $i$ which they already had in the previous iteration. So:

[TABLE]

In the second case $|\Gamma_{i+1}|$ is at least $2$. The other intervals used to be optimally embedded on $(0,i)$ and are now embedded on $(0,i+1)$. So each of them expands with at most a factor $\frac{i+1}{i}$ or algebraically:

[TABLE]

There are $i-|\Gamma_{i+1}|$ intervals disjoint from $R_{i+1}$ so Lemma 2.4 guarantees that $(i+1)w_{i+1}\geq|\Gamma_{i+1}|\geq 2$. It follows that:

[TABLE]

which implies the Lemma.

Lemmas 2.2 and 2.6 imply the following theorem.

Theorem 2.8**.**

For any set of intervals $\mathcal{R}$ in one dimension, for any containment-compatible permutation $\pi$ on $\mathcal{R}$, $A^{\pi}(\mathcal{R})$ is a $3$-approximation of $nH(\mathcal{R})$.

Corollary 2.9**.**

For any set of intervals $\mathcal{R}$ in one dimension, the ambiguity $A(\mathcal{R})$ is a $3$-approximation of $nH(\mathcal{R})$.

Proof 2.10**.**

The permutation which realizes the ambiguity of $\mathcal{R}$ must always be containment-compatible. This is because swapping a region $R$ with a region $R^{\prime}$ that contains $R$ in the permutation $\pi$ always improves the $\pi$-ambiguity.

Let $e(\mathcal{R})$ be the number of linear extensions of the poset induced by $\mathcal{R}$. In the proof of Lemma 3.2 [7] Cardinal *et al.*show that $\log e(\mathcal{R})\leq nH(\mathcal{R})\leq 2\log e(\mathcal{R})$. This implies that the interval graph entropy is a lower-bound for constructing any unique linear order underlying a poset. Proximity structures depend on sorting [8]. Thus, we conclude:

Theorem 2.11**.**

Reconstructing a proximity structure on $\mathcal{R}$ is lower-bounded by $\Omega(A(\mathcal{R}))$.

3. Sorting

Let $\mathcal{R}=\{R_{1},R_{2},\ldots,R_{n}\}$ be a set of intervals and let $X=\{x_{1},x_{2},\ldots,x_{n}\}$ be a set of points (values) with $x_{i}\in R_{i}$. We show how to construct an auxiliary structure $\Xi$ on $\mathcal{R}$ in the preprocessing phase without using $X$, such that, in the reconstruction phase, we can construct a linear-size binary search tree $T$ on $X$ in $\Theta(A(\mathcal{R}))$ time. To achieve this, we first construct a specific containment-compatible permutation $\pi$ of $\mathcal{R}$, and then show how to maintain $\Xi$ when we process the intervals in this order.

3.1. Level permutation

We need a processing permutation $\pi$ of $\mathcal{R}$ with the following conditions:

1. (i)

$\pi$ is containment-compatible, 2. (ii)

intervals containing no interval of $\mathcal{R}$ come first and are ordered from right to left and 3. (iii)

we can construct $\pi$ in $\mathcal{O}(n\log n)$ time.

In Section 2.1 we showed that if condition (i) holds, the $\pi$-ambiguity is a lower-bound for sorting $X$. In Section 3.2 we show that condition (ii) is useful to reconstruct an AVL-tree on $X$ in $\mathcal{O}(A^{\pi}(\mathcal{R}))$ time. Condition (iii) bounds the time used in the preprocessing phase.

Below, we define two natural partitions of $\mathcal{R}$ based on the containment graph of $\mathcal{R}$: the height partition and the depth partition. However, a permutation compatible with the height partition satisfies conditions (i) and (ii) but not (iii), and a permutation compatible with the depth partition satisfies conditions (i) and (iii) but not (ii). Therefore, we define a hybrid partition, which we call the level partition, which implies a permutation which does satisfy all three conditions, below.

Containment graph.

For a set of intervals $\mathcal{R}$, its containment graph $G(R)$ represents the containment relations on $\mathcal{R}$. $G(R)$ is a directed acyclic graph where $R_{i}$ contains $R_{j}$ if and only if there is a directed path from $R_{i}$ to $R_{j}$ and all intervals $R\in\mathcal{R}$ that are contained in no other interval of $\mathcal{R}$ share a common root. The bottom intervals are a subset of the leaves of this graph. Note that $G(\mathcal{R})$ can have quadratic complexity (Figure 6).

Height and Depth partition.

We define the height partition as the partition of $\mathcal{R}$ into $m$ levels $\mathcal{H}=H_{1}\ldots H_{m},H_{i}\subseteq\mathcal{R}$ where all $R\in H_{j}$ have height (minimal distance from $R$ to a leaf) $j+1$ in $G(\mathcal{R})$ or equivalently: the intervals in $H_{j+1}$ contain no intervals in $\mathcal{R}\backslash H_{\leq j}$ (Figure 7). We analogously define the depth partition as the partition of $\mathcal{R}$ into $m$ levels $\mathcal{D}=D_{1}\ldots D_{m},D_{i}\subseteq\mathcal{R}$ where all $R\in D_{j}$ have depth (maximal distance from the root to $R$) $(m-j)$ in $G(\mathcal{R})$. Clearly any permutation compatible with $\mathcal{H}$ or $\mathcal{D}$ satisfies condition (i). All leaves of $G(\mathcal{R})$ have height $1$ so per definition are all in $H_{1}$ and thus any permutation compatible with $\mathcal{H}$ that sorts $H_{1}$ satisfies condition (ii). Clearly the same is not true for $\mathcal{D}$. On the other hand, in Lemma 3.1 we show how to construct $\mathcal{D}$ in $\mathcal{O}(n\log n)$ time. It is unknown whether the height partition can be created in $\mathcal{O}(n\log n)$ time (see Appendix C).

Lemma 3.1**.**

For any set of intervals $\mathcal{R}$ we can construct $\mathcal{D}$ in $\mathcal{O}(n\log n)$ time.

Proof 3.2**.**

We iteratively insert intervals from left to right; refer to Appendix B.

Level partition.

We now define the level partition: a hybrid between $\mathcal{H}$ and $\mathcal{D}$: $\mathcal{L}=L_{1}\ldots L_{m}$, where all $R\in L_{j}$ have depth $(m-j)$ in $G(\mathcal{R})$ except for the leaves of $G(\mathcal{R})$, which are in $L_{1}$ regardless of their depth. We can compute the level partition from $\mathcal{D}$ in $\mathcal{O}(n\log n)$ time by identifying all leaves of $G(\mathcal{R})$ with a range query. The level permutation is the permutation where intervals in $L_{i}$ precede intervals in $L_{j}$ and where within each level the intervals are ordered from right to left. It can be constructed from $\mathcal{L}$ in $\mathcal{O}(n\log n)$ time by sorting.

Theorem 3.3 follows directly from the preceding discussion.

Theorem 3.3**.**

The level permutation satisfies conditions (i), (ii) and (iii).

3.2. Algorithm

We continue to describe a preprocessing and reconstruction algorithm to preprocess a set of intervals $\mathcal{R}$ in $\mathcal{O}(n\log n)$ time such that we can sort $X$ in $\Theta(A(\mathcal{R}))$ time.

Anchors.

Let $\pi$ be the level permutation of $\mathcal{R}$. In the preprocessing phase we build an AVL-tree $T$ on the bottom intervals. In the reconstruction phase, we insert each remaining $x_{i}\in X$ into $T$ in the order $\pi$ in $\mathcal{O}(A^{\pi}(\mathcal{R}))$ time. This implies that for bottom intervals we are not allowed to spend even constant time and for each non-bottom interval $R_{i}$, we want to locate $x_{i}$ in $T$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time. To achieve this, we supply every non-bottom interval $R$ with an anchor denoted by $\bot^{\pi}(R_{i})$. For a non-bottom interval $R\not\in L_{1}$, we define its anchor as an arbitrary interval contained in $R$. All intervals in $L_{1}$ are ordered from right to left, so for any non-bottom interval $R\in L_{1}$, its right endpoint is contained in the interval preceding it and we make this interval the anchor of $R$ (refer to Figure 8).

Preprocessing phase.

The auxiliary structure $\Xi$ is an AVL-tree $T$ on the bottom intervals, augmented with a set of pointers leading from intervals to their anchors. We will implement $T$ as a leaf-based AVL-tree, i.e., where values are stored in the leaves, and inner nodes are decision nodes. Finally, we will use a doubly linked list to connect the leaves of the tree.

Let $X^{b}\subset X$ be the points corresponding to bottom intervals. Bottom intervals are mutually disjoint and we can build an AVL-tree $T$ on $X^{b}$ without knowing their true values. Recall that a Fibonacci tree is a tree binary where for every inner node, its left subtree has a depth 1 greater than its right subtree. A Fibonacci tree is a valid AVL-tree and we construct the AVL-tree over $X^{b}$ as a Fibonacci tree where we add at most $|X^{b}|$ dummy leaves with value $\infty$ to ensure that the total number of nodes is a Fibonacci number. Refer to Figure 8 for an example. We remove the bottom intervals from $\mathcal{R}$ and for each non-bottom interval $R$ we identify its anchor $\bot^{\pi}(R)$ and we supply $R$ with a pointer to $\bot^{\pi}(R)$. As the final step of the preprocessing phase we connect the leaves of $T$ in a doubly linked list. To summarize: $\Xi$ consists of a graph of intervals connected by anchor pointers and an AVL-tree $T$. Each bottom interval is in $T$ and each non-bottom interval has a directed path to a node in $T$.

Lemma 3.4**.**

We can construct the auxiliary structure $\Xi$ in $\mathcal{O}(n\log n)$ time.

Proof 3.5**.**

The level partition and permutation can be constructed in $\mathcal{O}(n\log n)$ time and with it we get access to the intervals in $L_{1}$ sorted from right to left. We scan $L_{1}$ from right to left and for each interval $R\in L_{1}$ we either identify it as a bottom interval or to supply it with its anchor. We identify for each $R\not\in L_{1}$ its anchor in logarithmic time using a range query. We construct the Fibonacci tree on $X^{b}$ with leaf pointers in $\mathcal{O}(n\log n)$ time [23].

Reconstruction phase.

During the reconstruction phase, we need to maintain the balance of $T$ when we insert new values. $T$ contains bottom intervals which we are not allowed to charge even constant time, so the classical amortized-constant analysis [22] of AVL-trees does not immediately apply. Nonetheless we show in Appendix E:

Lemma 3.6**.**

Let $T$ be an AVL-tree where each inner node has two subtrees with a depth difference of 1. We can dynamically maintain the balance of $T$ in amortized $\mathcal{O}(1)$ time.

Theorem 3.7**.**

Given $\Xi$, we can reconstruct an AVL-tree on $X$ in $\Theta(A^{\pi}(\mathcal{R}))$ time.

Proof 3.8**.**

Given $\Xi$ and the level permutation $\pi$ we want to sort the points in $X$ (insert them into $T$) in $\mathcal{O}(A^{\pi}(\mathcal{R}))$ time. Because $T$ starts as a Fibonacci tree, Lemma 3.6 guarantees that we can dynamically maintain the balance of $T$ with at most $\mathcal{O}(A^{\pi}(\mathcal{R}))$ operations. The bottom intervals are already in $T$, thus we need to insert only the remaining $x_{i}\in X\backslash X^{b}$, in the order $\pi$, into $T$ in $\log|\Gamma^{\pi}_{i}|$ time plus some additional time which we charge to the anchor (each anchor will only get charged once).

Whenever we process a non-bottom interval $R_{i}$ we know that its anchor is already inserted in $T$. By construction, there are at most $\mathcal{O}(|\Gamma^{\pi}_{i}|)$ leaves in $T$ which have coordinates on the domain of $R_{i}$ (because these values can come only from intervals in the contact set of $R_{i}$). We know that we must insert $x_{i}$ next to one of these $\mathcal{O}(|\Gamma^{\pi}_{i}|)$ leaves in $T$. This means that if we have a pointer to any leaf on the domain of $R_{i}$, then we locate $x_{i}$ in $T$ with at most $O(\log|\Gamma^{\pi}_{i}|)$ edge traversals. During these traversals, we collapse each interval we encounter to a point. We obtain such a pointer from $\bot^{\pi}(R_{i})$. Assume $\bot^{\pi}(R_{i})\subset R_{i}$. Then the leaf corresponding to $\bot^{\pi}(R_{i})$ must lie on the domain of $R_{i}$. Otherwise, $R_{i}$ and $\bot^{\pi}(R_{i})$ are both in the level $L_{1}$ (illustrated in Figure 9) and $\bot^{\pi}(R_{i})=R_{i-1}$ and must contain the right endpoint of $R_{i}$. With a similar analysis, $R_{i-1}$ can locate the right endpoint of $R_{i}$ in $T$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i-1}|$ time. In both cases we found a leaf of $T$ in $R_{i}$ and locate $x_{i}$ in $T$ in $O(\log|\Gamma^{\pi}_{i}|)$ time. Each interval in $L_{1}$ has a unique anchor, so each anchor in $L_{1}$ is charged this extra work once.

4. Quadtrees

Let $\mathcal{R}=\{R_{1},R_{2},\ldots,R_{n}\}$ be a set of unit intervals in a bounding box (interval) $\mathcal{B}$ (we discuss how to extend the approach later) and let $X=\{x_{1},x_{2},\ldots,x_{n}\}$ be a set of points (values) with $x_{i}\in R_{i}$. We show how to construct an auxiliary structure $\Xi$ on $\mathcal{R}$ in the preprocessing phase without using $X$, such that, in the reconstruction phase, we can construct a linear-size quadtree $T$ on $X$ in $\Theta(A(\mathcal{R}))$ time. We recall several standard definitions.

Point quadtrees.

Suppose that we have a $d$-dimensional point set $X$ in a bounding hypercube $\mathcal{B}$. A quadtree on $(\mathcal{B},X)$ is defined as follows: split operator is an operator that splits any $d$-dimensional hypercube into $2^{d}$ equal-sized hypercubes called cells. We recursively split $\mathcal{B}$ until each point $p\in P$ lies within a unique cell [24]. A $\lambda$-deflated quadtree is a more relaxed quadtree where $\mathcal{B}$ is split until each leaf cell contains at most $\lambda$ points [6].

Region quadtrees.

Let $\mathcal{R}$ be a set of $d$-dimensional disks in a bounding hypercube $\mathcal{B}$. Let $\mathcal{T}(\mathcal{B})$ be the infinite set of possible quadtree cells on $\mathcal{B}$. For each $R_{i}\in\mathcal{R}$, we define its storing cell denoted by $C_{i}$ as the largest cell in $\mathcal{T}(\mathcal{B})$ that is contained in $R_{i}$ and contains the center of $R_{i}$ [20]. $T_{i}$ is the subtree induced by $C_{i}$. The neighborhood of $R_{i}$ is the set of possible cells $C\in\mathcal{T}(\mathcal{B})$ with size $|C_{i}|$ that are intersected by $R_{i}$. We consider the quadtree $T$ on $\mathcal{R}$ to be the unique compressed quadtree where for each $R_{i}\in\mathcal{R}$, its neighborhood is in $T$.

Edge oracle tree.

Depending on $\mathcal{B}$ and $X$, the quadtree on $(\mathcal{B},X)$ does not necessarily have logarithmic depth (Figure 10) thus, point location in $T$ is non-trivial. Har-Peled [13] introduced a fast point-location structure (later dubbed edge-oracle tree [20]) for any quadtree $T$. The edge-oracle tree $E$ is created through centroid decomposition. Any tree with bounded degree $\delta$ has at least one centroid edge which separates a tree of $n$ nodes into two trees with at least $\frac{n}{\delta}$ and at most $n-\frac{n}{\delta}$ nodes each. Moreover, one of these 2 trees is a subtree of $T$ (a tree induced by a node as a root). For any subtree $T^{\prime}$ of $T$, we define its corresponding node in $E$ (edge in $T$) as the lowest node in $E$ which splits $T$ into two parts, one of which contains $T^{\prime}$ and the other contains the root of $T$. This node must exist, is unique and the subtree containing $T^{\prime}$ has $\mathcal{O}(|T^{\prime}|)$ nodes (refer to Figure 11).

Given a query point $q$, we can find the leaf cell $C_{q}$ that contains $q$ in the following way: each decision node $v$ of $E$ has 2 children where 1 child node $w$ corresponds to a subtree $T_{w}$ of $T$. We test whether $q$ is contained in $w$ in $\mathcal{O}(1)$ time by checking the bounding box of $T_{w}$.

We wish to preprocess $\mathcal{R}$ such that we can reconstruct a linear-size $\lambda$-deflated quadtree $T$ for $X$ with pointers between leaves. However, $T$ does not necessarily have linear size and dynamically maintaining pointers between leaves is non-trivial. To achieve this, one needs to maintain a compressed and smooth quadtree $T$ (refer to Appendix D for details) and Hoog et al.[15] show how to dynammically maintain a smooth compressed quadtree with constant update time. We will build such a quadtree augmented with an edge-oracle tree initialized as a Fibonacci tree. We proceed analogously to the approach in Section 3.

4.1. 1-dimensional quadtrees on unit-size intervals

We show how to construct an auxiliary structure $\Xi$ on $\mathcal{R}$ without using $X$, such that we can construct a $2$-deflated quadtree $T$ on $(\mathcal{B},X)$ in $\Theta(A(\mathcal{R}))$ time.

Preprocessing phase.

The auxiliary structure $\Xi$ will be a smooth compressed quadtree $T$ on the intervals $\mathcal{R}$ augmented with an edge-oracle tree $E$ on $T$, anchor pointers, and a containment-compatible processing permutation $\pi$ of $\mathcal{R}$. Given $T$, we initialize $E$ as a Fibonacci tree, possibly adding dummy leaves111We may need to allow parents of leaves of $T$ to have a single dummy leaf.. We supply each $R_{i}$ with a pointer to the node in $E$ corresponding to $T_{i}$ and we call this its anchor $\bot^{\pi}(R_{i})$.

Lemma 4.1**.**

The auxiliary structure $\Xi$ can be constructed in $\mathcal{O}(n\log n)$ time.

Proof 4.2**.**

Hoog et al. [15] show that for any set of $d$-dimensional disks $\mathcal{R}$, its smooth compressed quadtree $T$ on $\mathcal{R}$ with corresponding edge-oracle tree $E$ can be constructed in $\mathcal{O}(n\log n)$ time and that this tree has a worst-case constant update time. We turn $E$ into a Fibonacci tree by inserting at most $\mathcal{O}(n)$ dummy leaves in $\mathcal{O}(n\log n)$ time in total.

Reconstruction phase.

By construction, each leaf in $T$ intersects at most 2 bottom intervals of $\mathcal{R}$ (since these are mutually disjoint). Therefore, we can construct a $2$-deflated quadtree on $X$ by inserting each $x_{i}\in X\backslash X^{b}$ in the order $\pi$ into $T$. We observe the following:

Lemma 4.3**.**

When we process an interval $R_{i}\in\mathcal{R}$, $R_{i}$ intersects $\mathcal{O}(|\Gamma^{\pi}_{i}|)$ leaf cells of $T$.

Proof 4.4**.**

There can be at most 2 bottom intervals (left and right) of $R_{i}$ whose neighborhood intersects $R_{i}$. All the other leaves on the domain of $R_{i}$ are caused by either already processed points on the domain of $R_{i}$ or are dummy nodes. For each dummy node there is a corresponding non-dummy node also on the domain of $R_{i}$.

Lemma 4.5**.**

When we process an interval $R_{i}$, we can locate, for any point $q\in R_{i}$, the leaf $C_{q}\in T$ which contains $q$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time.

Proof 4.6**.**

If $C_{q}\in T_{i}$ then $R_{i}$ has an anchor to $T_{i}$ and from this anchor we locate $C_{q}$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time. Suppose $C_{q}$ is to the left of $T_{i}$. We locate the left-most leaf of $T_{i}$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time and traverse its neighbor pointer. The neighboring cell must lie in a subtree $T_{q}$ neighboring $T_{i}$ with $\mathcal{O}(|\Gamma^{\pi}_{i}|)$ nodes and this tree must contain $C_{q}$ (Lemma 4.3). We now have a pointer to a node in $T_{q}$ and from this node we locate $C_{q}$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time.

Theorem 4.7**.**

Given $\Xi$, we can construct a $2$-deflated quadtree on $X$ in $\Theta(A^{\pi}(\mathcal{R}))$ time.

Proof 4.8**.**

Given $\Xi$ and any containment-compatible permutation $\pi$, we want to insert $X$ into $T$ in $O(A^{\pi}(\mathcal{R}))$ time. An insertion in $T$ creates $2$ additional leaves in $T$ (and therefore also in $E$) and Lemma 3.6 guarantees that we can dynamically maintain the balance of $E$ with at most $O(A^{\pi}(\mathcal{R}))$ operations. If we only consider the point set $X^{b}\subset X$ corresponding to the bottom intervals then $T$ is already a $2$-deflated quadtree on $X^{b}$ independent of where the points of $X^{b}$ lie in their uncertainty intervals. Therefore, we only need to insert the remaining $x_{i}\in X\backslash X^{b}$, in the order $\pi$, into $T$ in $\log|\Gamma^{\pi}_{i}|$ time (potentially collapsing some of the bottom intervals when necessary). Using Lemma 4.5 we can locate the quadtree leaf $C_{x_{i}}$ that contains $x_{i}$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time. This leaf is intersected by at most 2 bottom intervals, which we collapse into points whose location we locate in constant time using the leaf pointers. Thus each non-bottom interval inserts at most 3 points into $T$ in $\mathcal{O}(\log|\Gamma^{\pi}_{i}|)$ time.

4.2. Generalization

If we stay in one dimension, then the result of Theorem 4.7 in fact generalizes to the case where $\mathcal{R}$ is a set of arbitrary intervals since Lemma 4.3 and 4.5 do not depend on the intervals being unit size. However, the result also generalizes to the case where $\mathcal{R}$ is a set of unit-size disks in $d$ (constant) dimensions: first of all, any permutation of $\mathcal{R}$ is containment-compatible. If the disks are unit size then each disk intersects at most $K_{d}$ bottom disks where $K_{d}$ is the kissing number so Lemma 4.3 generalizes. For any disk $R_{i}\in\mathcal{R}$, recall that $T_{i}$ was the subtree of the storing cell of $R_{i}$. Any point $q\in R_{i}$ must lie in the perimeter of $T_{i}$ which consists of at most $\mathcal{O}(5^{d})$ subtrees of size $\mathcal{O}(|\Gamma^{\pi}_{i}|)$ therefore, Lemma 4.5 also generalizes. The result is even more general: this approach works for any collection $\mathcal{R}$ of unit-size fat convex regions similar to, e.g. [5]. Interestingly, generalizing the result of Theorem 4.7 both to higher dimensions and to non-unit regions at the same time is not possible: in Appendix F we show that, independent of preprocessing, reconstructing a $\lambda$-deflated quadtree has a lower bound of $\Omega(\log n)$, which could be more than $A(\mathcal{R})$.

5. Conclusion

We introduced the ambiguity $A(\mathcal{R})$ of a set of regions $\mathcal{R}$ as a more fine-grained measure of the degree of their overlap. We applied this concept to uncertainty regions representing imprecise points. In the preprocessing model we show that the ambiguity is a natural lower bound for the time complexity of the reconstruction of any proximity structure. We achieved these results via a link to the entropy of partial orders which is of independent interest. If the regions are intervals in 1D we show how to sort in $\Theta(A(\mathcal{R}))$ time, if the regions are unit balls in any dimension we show how to reconstruct quadtrees $\Theta(A(\mathcal{R}))$ time.

In the future we plan to investigate if our results can be generalized to other promixity structures such as Delaunay triangulations, minimum spanning trees, and convex hulls. In principle it is possible to convert quadtrees into all of these structures in linear time [18]. However, it is not clear how to do so, when working with an implicit representation of the results in the case that $A(\mathcal{R})$ is sub-linear.

Appendix A Entropy of comparability and incomparability graphs

Körner [17] introduce the notion of the entropy of a graph. Let for any graph $G$, $\mathcal{A}_{G}$ be the space of independent sets of $G$. $\mathcal{A}_{G}$ is a convex subspace of $[0,1]^{n}$ where each integer-coordinate point in the space represents an independent subset of $G$. Let $\vec{x}=(x_{1},x_{2}\ldots x_{n})$ be any (real-valued) point in $\mathcal{A}_{G}$. Körner defines the graph entropy of $G$ as: $H(G):=\frac{1}{n}\max_{\vec{x}\in\mathcal{A}_{G}}\sum_{i}-\log x_{i}$ and this function is inspired by Shannon entropy.

Let $P$ be an arbitrary poset. The comparability graph $G_{P}$ of $P$ is the graph where there is an edge between $a,b\in P$ if $a$ and $b$ are comparable. The incomparability graph of $P$ is the graph where there is an edge $a,b\in P$ if $a$ and $b$ are incomparable and it is denoted by $\bar{G}_{P}$ since this is the complement of $G_{P}$. Khan and Kim [16] define the entropy $H(P)$ of a poset $P$ as the entropy of $G_{P}$. The more natural quantity to consider, however, is the entropy of the incomparability graph of $P$, which Khan and Kim denote by $H(\bar{P})$ (note that $H(P)+H(\bar{P})=\log n$). They continue to show that the time it takes to sort a poset $P$ is lower-bounded by $\Omega(nH(\bar{P}))$.

Cardinal et al.[7] further investigate how to sort posets using this notion of entropy. They note that certain posets $P$ are induced by a set of intervals $\mathcal{R}$; they call these interval orders. Moreover, they show for every poset $P$, there exists an interval order $P^{\prime}$ with $H(P)=H(P^{\prime})$ (and hence also $H(\bar{P})=H(\bar{P^{\prime}})$). This allows them to approximate $H(\bar{P})$ for any poset $P$, by searching for a corresponding $P^{\prime}$.

Appendix B Building the depth partition

We present the proof of Lemma 3.1 in Section 3.1, which states that for any set of intervals $\mathcal{R}$ we can construct the depth partition $\mathcal{D}$ in $\mathcal{O}(n\log n)$ time.

Proof B.1**.**

To construct $D_{1}\ldots D_{m}$ we process the intervals of $\mathcal{R}$ sorted by their left endpoints from left to right. For each level $D_{i}$ we maintain the value $r_{i}$ as the maximum of the right endpoints of the intervals in $D_{i}$ and we maintain the invariant that $r_{i+1}\geq r_{i}$. Let $m$ be the (unknown) maximal level. Initially, we have $D_{m}$ as the empty set, no other sets and $r_{m}=-\infty$. We insert the first interval into $D_{m}$ and set $r_{m}$ to be the right endpoint of the interval.

We then construct the remaining partition by iterating over the intervals in their sorted order. Consider the iteration where we are inserting an interval $R$ (refer to Figure 12). Let there be $\ell$ levels at this iteration $(D_{m}\ldots D_{m-\ell})$. We compare the right endpoint of $R$ denoted by $r$ with the values $r_{m},r_{m-1},\ldots,r_{m-\ell}$. We find the minimal $j$ such that $r_{j}>r$ using binary search. All intervals in $D_{j}$ have a left endpoint left of $R$, so $R$ must be contained in an interval in $D_{j}$ and we therefore insert $R$ in the level $D_{j-1}$ and update $r_{j-1}$. This gives a partition where all intervals in a level $D_{j}$ have depth $m-j$ in the containment graph $G(\mathcal{R})$.

Appendix C Building the height partition

In Section 3.1, we introduced the height partition $\mathcal{H}$ as a natural partition of a set of intervals which would suit our needs, except for the fact that it is unclear how to compute it efficiently. We briefly expand on this here.

Lemma C.1**.**

For any set of intervals $\mathcal{R}$, we can construct $\mathcal{H}$ in $\mathcal{O}(n\log^{2}n)$ time.

Proof C.2**.**

Observe that an interval $(x_{1},x_{2})$ contains $(y_{1},y_{2})$ if and only if $x_{1}\leq y_{1}\wedge y_{2}\leq x_{2}$. We use this information plus a 3-dimensional dynamic range tree [8] to construct the height partition. We sort the intervals from narrow to wide and insert them into the correct level in this order. The least wide interval $(a,b)$ cannot contain an interval of $\mathcal{R}$ so we store this interval in $S_{1}$ and we insert it in the dynamic range tree as the 3-dimensional point $(a,b,1)$.

Consider the iteration where we process an interval $(c,d)$. By this time we have already processed all intervals which could be contained in $(c,d)$. We query the range tree with the following range: $(c,\infty)\times(-\infty,d)\times(-\infty,\infty)$ and we find the interval in this range with the maximal $z$-coordinate in $\mathcal{O}(\log^{2}n)$ time. This gives us the interval $(e,f)$ which of all intervals contained in $(c,d)$, is stored in the highest level $S_{j}$. Thus, $(c,d)$ contains no intervals in $\mathcal{R}\backslash S_{\leq j}$ and must be stored in level $S_{j+1}$. Lastly we insert the point $(c,d,j+1)$ into the range tree in $\mathcal{O}(\log^{2}n)$ time and we continue the iteration.

Let for an interval $(c,d)$, $R_{\mid(c,d)}$ be the intervals in $\mathcal{R}$ that are contained in $(c,d)$. During the construction of the height partition we want for $(c,d)$ to find the interval in $R_{\mid(c,d)}$ that is stored in the highest level. We project each interval $(a,b)\in R_{\mid(c,d)}$ to the point $(a,b,j)$ where $j$ is the level of $(a,b)$. We then perform a 3-dimensional range query on the range: $(c,\infty)\times(-\infty,d)\times(-\infty,\infty)$ to find the interval on this domain with the maximal $z$-coordinate. This leads to an interesting open problem which we will call dynamic $2.5$-queries:

Let $\mathcal{R}$ be a set of $n$ intervals where each interval $R_{i}$ has a weight $w_{i}$. Can we dynamically maintain a linear-size data structure on $\mathcal{R}$, with $\mathcal{O}(\log n)$ update time that can answer the following query in logarithmic time: for an interval $(c,d)\in\mathcal{R}$, what is the interval in $R_{\mid(c,d)}$ with the maximal weight?

Range queries with the range: $(q_{1},\infty)\times(q_{2},\infty)\ldots\times(q_{k},\infty)$ are called $k$-dimensional dominance queries. Range and dominance queries have 3 variants: reporting, counting and max. Here in the first 2 variants the goal is to report or count all the points within the range and where with the latter the goal is to return the maximal point within the range for some definition of maximal.

The query we posed above lies somewhere between a 2-dimensional and a 3-dimensional dominance max-query since the third dimension does not have a specified range. 2-dimensional dominance queries can be solved with a dynamic linear-size data structure with $\log n$ update and query time. Saxena [25] shows how static 3-dimensional dominance reporting can be solved using $\mathcal{O}(n\log n)$ space and construction time with $\mathcal{O}(\log n+S)$ query time where $S$ is the size of the output. This approach can be easily adapted to provide the element with the maximal $z$-coordinate instead but there is few hope for linear space and $\mathcal{O}(\log n)$ update time. At a similar time, Afshani [1] proposed a static data structure that answers 3-dimensional dominance reporting with $\mathcal{O}(n\log n)$ construction time, linear space and $\mathcal{O}(\log n+S)$ query time where $S$ is the size of the output. However, their approach cannot be adapted to dominance-max queries since it is based on an amortized-analysis using the size $S$. Our problem has more “freedom” than a full 3-dimensional range query.

Appendix D Basic properties of quadtrees

Here we recall two basic properties of $d$-dimensional quadtrees, in particular compression and smoothness. A quadtree $T$ on a real-valued point set $X$ is compressed so that the quadtree has linear space. A smooth quadtree is a quadtree where each leaf is comparable in size to its adjacent leaves and smoothness is a prerequisite for having neighbor pointers between adjacent leaves.

Compression.

Depending on $\mathcal{B}$ and the point set $X$, the quadtree on $(\mathcal{B},X)$ does not always have linear size (Figure 10). If two points of $X$ lie close, we potentially require an unbounded number of splits before they lie within a unique cell. The remedy for this is to use $\alpha$-compressed quadtrees [13]. For any quadtree $T$, if there exists a path of cells $v_{1},v_{2}\dots v_{i}$ with $i$ greater than a constant $\alpha$, such that the cells on this path contain only points which lie in $v_{i}$, then we do not explicitly construct this path. Instead, $v_{1}$ directly becomes the parent cell of the much smaller $v_{i}$. For any point set $P$, there exists a linear-size $\alpha$-compressed quadtree and this can be made dynamic with $\mathcal{O}(\alpha)$ update time [13].

Smoothness.

A quadtree is smooth if each leaf is comparable in size to its adjacent leaves. It has been long recognized that smooth quadtrees are useful in many applications [3], and smooth quadtrees can be computed in linear time (and have linear complexity) from their non-smooth counterparts [8, Theorem 14.4]. In the previous sections, we used pointers between leaves of our AVL-tree to facilitate fast point location. Suppose you want to dynamically maintain a $d$-dimensional quadtree $T$, with $d>1$, where each leaf in $T$ has pointers to adjacent leaves. Bennet and Yap [2] show that this is possible with constant update time if and only we maintain a smooth quadtree. Hoog et al.[15, Theorem 20] show how to dynamically maintain a smooth compressed quadtree with constant update time.

Appendix E Amortized-constant balancing of an AVL tree

In Section 3.2, we need to maintain a dynamic balanced AVL tree in amortized constant time per update, even when the initial tree contains more elements than the number of updates we will perform. Hence, a traditional amortization scheme which assumes the tree is build using update operations, does not immediately apply. We show here that if we construct an initial AVL tree which is as imbalanced as possible (while remaining a valid AVL tree), we can in fact perform all future updates in contant time amortized only over the number of future updates.

We present the proof of Lemma 3.6, which states that when $T$ is an AVL tree for which every internal node has two subtrees with a depth difference of 1, we can dynamically maintain the balance of $T$ in amortized $\mathcal{O}(1)$ time.

Proof E.1** (Proof of Lemma 3.6).**

An AVL tree is a binary search tree where each inner node $v\in T$ has a balance constant $b(v)\in\{-1,0,+1\}$. If $b(v)=-1$, the left subtree of $v$ has a depth 1 greater than the right subtree, if $b(v)=0$ then both subtrees of $v$ have equal size and else $b(v)=+1$. Let $x$ be a value that we want to insert into $T$ and $v$ be the leaf that would become the parent of $x$. An insertion replaces $v$ with a decision node that is the parent of $x$ and $v$. Melhorn and Tsakalidis [22] note that an insertion can recursively change balance constants all the way to the root. In particular, they observe that an insert will change a path of [math]’s into $+1$ or $-1$ until it reaches a node $\bar{v}$ where it will change $b(\bar{v})$ from $\{-1,+1\}$ to [math] with a so called terminating action: either the insert triggers a rotation around $\bar{v}$, or the insert guarantees that the left and right subtree of $\bar{v}$ are equal size. In both cases, the parent of $\bar{v}$ does not have to adjust its balance constant and the balancing process terminates.

Our tree $T$ started out a tree where all the balance constants were $-1$ and $+1$. This means that whenever we insert a new value in $T$, it might change arbitrarily many [math]-nodes into $+1$ or $-1$, but for each of these nodes, there was a unique insert that created the [math] value. This implies that performing all the balance changes takes amortized constant time.

Appendix F $d$-dimensional quadtrees of arbitrary disks

In Section 4 we show how to preprocess a set $\mathcal{R}$ of uncertainty regions consisting of unit disks, such that in the reconstruction phase we can construct a $K_{d}$-deflated quadtree on the underlying point set $X$ in $\Theta(A(\mathcal{R}))$ time. One key observation we make, is that if $\mathcal{R}$ is a set of $d$-dimensional unit disks (for any metric), then any permutation $\pi$ on $\mathcal{R}$ is a containment-compatible permutation. Suppose that $\mathcal{R}$ is an arbitrary set of $d$-dimensional disks, then it is not clear if a containment-compatible permutation can be computed in $\mathcal{O}(n\log n)$ time (In Section 3 we used range queries to find this permutation but this is not fast enough in $d\geq 3$). Even if it would be possible to find a containment-compatible permutation $\pi$, then it still would not be possible to reconstruct a $\lambda$-deflated quadtree of $X$ in $A(\mathcal{R})$ time if the ambiguity of $\mathcal{R}$ is below $\log n$:

Theorem F.1**.**

Let $\lambda$ be a constant. There exists a collection of discs in two dimensions $\mathcal{R}$ with an $A(\mathcal{R})=\lambda$ with a corresponding point set $X$ such that reconstructing a $\lambda$-deflated quadtree on $X$ takes at least $\Omega(\log n)$ time.

Proof F.2**.**

We prove the theorem by constructing an example for arbitrary $\lambda$ illustrated by Figure 13.