1. Optimal Planar Point Enclosure Indexing Lars Arge, Vasilis Samoladas and Ke Yi Department of Computer Science Duke University Technical University of Crete

2. 2 Two Dual Problems Range searchingPoint enclosure √ √? Internal memory External memory √

3. 3 Outline 1.Previous results in internal memory 2.Computation models in external memory 3.Previous results in external memory 4.Our lower bound result 5.Matching upper bound 6.Conclusions

4. 4 Previous Results: Internal Memory Computation model: Pointer machine Range searching (T is the output size) –O(N) space, O(N ε +T) time ([BM 80]) –O(N logN / loglogN) space, O(logN+T) time [Chazelle 88] *Tight for O(log c N+T) query structures, [Chazelle 90] –Can do better on a RAM –Other tradeoffs … Point enclosure [Chazelle 86] –Ө(N) space, Ө(logN+T) time –Optimal in both space and time

5. 5 External Memory: Models External pointer machine –Natural generalization of the internal pointer machine –Each node contains B data objects –Out-degree 2 →B Bounding-volume hierarchy (Non-replicating index structure) –Tree structure –Each object is stored only once Indexability model [HKP 97] D P M Block I/O

6. 6 External Memory: Models Indexability model –No “structure” at all! –Only models layout of data –Each block contains B data objects –Can “magically” find the smallest set Π of blocks whose union contains all results –Cost is defined to be |Π| Bounding volume hierarchy R-trees, kd-trees External pointer machine All other known results Indexability model 1D range searching

7. 7 Range searching (n=N/B) –Similar to internal memory, tradeoff between space and time –O(log B n+T/B) query time *O(n log n / loglog B n) space [ASV 99] –Tight in external pointer machine [SR 95] –Improved to indexability model [ASV 99] –O(n) space *O( ) time [kdB-tree, GI 99, KS 99] –Tight in bounding-volume hierarchies *Can do O(n ε +T/B) with constant redundancy –Tight in indexability model [ASV 99] Previous Results: External Memory

8. 8 Point enclosure –Ω( ) for bounding-volume hierarchies [ABGHH 01] –Easy to get a O(n) space, O(log 2 n+T/B) query structure ProblemInternal memoryExternal memory 1D range(N, log N + T)(n, log B n + T/B) 1D point enclosure (N, log N + T)(n, log B n + T/B) 2D range (N, N ε +T) (n, n ε +T/B) 2D point enclosure (N, log N + T) B 2 (n, log n + T/B)? (n, log n+T/B) (nB ε, log B n+T/B)

9. 9 Indexability Model in Details N data objects laid out in disk blocks, possibly with redundancy Each block holds at most B objects Cost of a query q: minimum # blocks needed to retrieve all answers –Can find those blocks without cost Redundancy r and access overhead A –r: Average # copies in the index *Size is rn blocks –A: Ratio of the query cost to the ideal cost in the worst case *Any query can be covered by blocks (A ≤ B) Lower bound expressed as a tradeoff between r and A –2D range searching [ASV 99]

10. 10 Previous Results in Indexability Model Set queries [HKP 97] –A set S of N objects, queries can be any subset of S –For any r≤n/B, A=B –Trivial Range searching – [HKP 97] – – [SP 98] –Only tight for the special case when points form a grid – [ASV 99]

11. 11 Redundancy Theorem [SP 98] (Asymptotic version) For N data objects, if there exist m queries q 1, …, q m, such that for any 1 ≤ i,j ≤ m, i ≠ j, |q i | ≥ B, |q i ∩q j | ≤ B/A 2, then, we have the redundancy Combinatorial in nature Used successfully to obtain the range searching lower bound

12. 12 Point Enclosure Lower Bound Construction (1) Set of queries: the Fibonacci lattice (one of low-discrepancy point sets) –m points in a m×m grid –Only property used: any rectangle with area αm contains between and points Set of objects –Tiling rectangles of αt i ×m/t i –t=(m/α) 1/B, i=1,…,B –m=αN/B – Θ (B·m 2 /(αm)) = Θ (N) rectangles are constructed –|q i | ≥ B is satisfied

13. 13 Point Enclosure Lower Bound Construction (2) Any A that satisfies |q i ∩q j | ≤ B/A 2 will become a lower bound Make A as large as possible For a rectangle to cover q 1 and q 2, we must have αt i ≥x and m/t i ≥y, or x/α≤ t i ≤ m/y q 1 and q 2 are two points from the Fibonacci lattice, so xy≥c 2 m # such rectangles ≤

14. 14 Point Enclosure Lower Bound Construction (3) Disprove earlier (n, log B n+T/B) conjecture Still a square root factor away What’s wrong? The construction technique, or the model itself?

15. 15 Refine the Indexability Model O(log B n + |q|/B) Search costRetrieval cost Observation: retrieval cost is relatively high for small queries Refine: add an addictive factor! –Old: any query q is covered by blocks –New: Any query q is covered by blocks Modify the Redundancy Theorem accordingly –The two conditions: |q i | ≥B, |q i ∩q j | ≤ B/A 2 |q i | ≥BA 0, |q i ∩q j | ≤ B/A 1 2

16. 16 The Refined Redundancy Theorem For N data objects, if there exist m queries q 1, …, q m, such that for any 1 ≤ i,j ≤ m, i ≠ j, |q i | ≥ BA 0, |q i ∩q j | ≤ B/(2A 1 ) 2, then, we have the redundancy Proof Sketch: Each query can be covered by blocks, and apply the original Redundancy Theorem with A=2A 1

17. 17 Fix the Construction Old construction –|q| = B –B layers of tiling rectangles –Size of Fibonacci lattice m=αN/B –Total # rectangles: N New construction –|q| = BA 0 –BA 0 layers of tiling rectangles –Size of Fibonacci lattice m=αN/(BA 0 ) –Total # rectangles: N

18. 18 Range Searching vs. Point Enclosure Range searching –Original model –New model Point enclosure Dual bounds in external memory! r

19. 19 Matching Upper Bounds (1) In the external pointer machine model Only interested in the case A 1 =O(1) Goal: for any r ≤ B, design an index with redundancy r that answers query in O(log r n+T/B) I/Os Building block: one-sided segment intersection queries –Given N horizontal segments –Report all segment directly above a query point Persistent B-tree (modified) –O(n) space, O(log B n+T/B) query –Search on the x-coordinate of the query point –Retrieve the segments

20. 20 Matching Upper Bounds (2) Divide plane into r horizontal slabs Associate two one-sided segment intersection structures to each slab –One for all top sides of rectangles that cross its bottom boundary –One for all bottom sides of rectangles that cross its top boundary and all bottom sides of rectangles that completely span the slab Recursively handle rectangles that fall completely within a slab, resulted in a tree with fanout r Any rectangle is stored at most r times: redundancy is r Query: follow the tree top-down, ask two one-sided queries at each level. O(log r n log B N+T/B) I/Os → O(log r n+T/B) by fractional cascading

21. 21 Conclusions 1.A tight lower bound on the tradeoff between the redundancy and access overhead of any index for the 2D point enclosure queries, given in the new indexability model 2.A matching upper bound in the external pointer machine The END