1. Dynamic Data Structures for Simplicial Thickness Queries
Danny Z. Chen and Haitao Wang
Computer Science and Engineering
University of Notre Dame
Indiana, USA

2. Outline Problem definitions Related work Our solutions
Further discussions

3. Simplicial thickness
Given: A set S of simplices in d-D space (d>1 is fixed), a point p
The simplicial thickness of p: The number of simplices in S containing p 2 3 1

4. Simplicial thickness query
Given: A set P of n points and a simplex set S in d-space (S=Ø initially)
Objective: Design a data structure to support
Simplex insertion: Insert a simplex to S
Simplex deletion: Delete a simplex from S
Simplicial thickness query: Given a query simplexσ, report the point with the minimum simplicial thickness among all points inσ∩P

5. Related work No previous work on the problem
Simplex range searching [Chazelle 90, Matousek 92, 93]
Dynamic versions supporting point insertions and deletions [Matousek 92]
Standard dynamic data structure design techniques [Overmars 83]

6. Our solution We propose a data structure with the following bounds:
O(n logn) time and O(n) space
Support the simplex insertion, deletion, simplicial thickness query in O(n1-1/d(logn)O(1)) time each (e.g., n1/2(log n)O(1) when d=2)
Based on simplicial partitions [Matousek 92]

7. Simplicial partition [Matousek]
Given a point set P, its simplicial partition is ∏={(P1, △1)…(Pm, △m)}:
Pi’s are pairwise disjoint subsets which form a partition of P
Each △i is a simplex containing Pi

8. Special simplicial partition
We call a simplicial partition special if max{|Pi|}<2min{|Pi|}
Given a half-space:
Easy: Process the points in the simplices which do not intersect its boundary
Problem: How to handle those simplices intersecting its boundary?

9. Partition tree [Matousek]
For a point set P, build a partition tree T by constructing special simplicial partitions on P recursively:
Each internal node v corresponds to a subset Pv, a simplex △v, and a special simplicial partition ∏v of Pv
Each leave corresponds to a constant size subset

10. A partition tree

11. Time and space
T can be constructed in O(n logn) time and O(n) space [Matousek 92]

12. Our new data structure T’
T’ is similar to T
But, in addition, we also store two values k1(v) and k2(v) at each node v
Some new concepts are needed

13. Poke
A simplex s pokes another simplex s’ if s∩s’≠Ø and s does not contain s’ completely
blue pokes red
red also pokes blue
blue pokes red

14. Intersection set (IS)
For each node v, define IS(v) as the set of simplices in IS(parent(v)) which poke △v (if v is the root, IS(v)=S)

15. Definitions of k1(v) and k2(v)
k1(v): The number of simplices in IS(parent(v)) which contain △v completely (k1(v)=0 if v is the root)
k2(v): The minimum simplicial thickness among all points in Pv with respect to the simplices in IS(v)
For each point pi in a leaf node v, we also store k1(pi) as the number of simplices in IS(v) which contain pi

16. Construction time and space
O(n) space
O(nlogn) time

17. An observation (for insertion)
k2(v)=min{k1(v’)+k2(v’)}
k2(v)=min{k1(p)} v v v’ p
For an internal node v
For a leaf node v

18. Simplex insertionσ
Update k1 values: Beginning from the root, for each internal node v:
Ifσcontains △v, we increase k1(v) by 1
If σpokes △v, we process all children of v recursively
Update k2 values: By the preceding observation

19. Simplex insertionσ(cont.)
The time complexity is O(n1-1/d(log n)O(1))
Simplex deletion can be handled analogously

20. An observation (for query)
If we apply simplex insertion on the query simplexσ, the k1 values of some nodes and points will be increased.
We call those nodes and points the ending nodes

21. An observation (cont.)
For each ending node, we define a thickness value
k2(v)
k1(p)
The query answer is the minimum of these values

22. Simplicial thickness queryσ
As we going down in the tree, we accumulate the sum of k1 values from the root to the current node
We also maintain the current minimum thickness value
Query time is O(n1-1/d(log n)O(1))

23. Applications Point approximation:
Input: A point set P in the plane, an integer g>0, andε>0
Output: A piecewise linear function f to approximate P with g outliers, s.t.,
The complexity of f is minimized
The maximum vertical point error is no more thanε
The number of outliers is no more than g

24. An example
error
Outlier

25. A sub-problem
Given P’ which is a subset of P, and an integer q (0≤q≤g) with P’=Ø initially, derive a data structure to support three operations:
Point insertion: Insert a point from P\P’ to P’
Point deletion: Delete a point from P’
Feasibility test: Determine whether there exists a line segment to approximate the points in P’ with at most q violations and with error no more than the givenε

26. 3-D k-level lowest point query
Given: A set P of n planes in 3-D space, an integer k>0, a constantε>0, and P’ P
Objective: A data structure to support the following operations
Plane insertion: Insert a plane of P\P’ to P’
Plane deletion: Delete a plane from P’
k-level lowest point query: Determine whether the lowest point on the k-level of the plane arrangement of P’ has z-coordinate larger thanε

27. Further discussions Weighted version: Each simplex has a weight
Max version: Query the point with the maximum simplicial thickness

28. Thank you