Teaching Geometric Algorithms to Gracefully “Walk” and “Jump”

1. Teaching Geometric Algorithms to Gracefully “Walk” and “Jump” Kanat Tangwongsan ALADDIN 2005 Joint work with Umut Acar, Guy Blelloch, and Jorge Vittes.

2. A “Simple” Problem • The Convex Hull Problem • Given: a set SµR3 • Maintain: smallest convex set containing S Output: CH(S) Input: S

3. A “Simple” Problem (cont.) • The KineticConvex Hull Problem • points continuously moving • Imagine making a movie!

4. Facts… • Trivial solution: calculate the CH for every frame. • Better solution? Unfortunately, no knownefficient solution. • To support only insertion/deletion issuper complicated already. • Implication: Kinetic algorithm for CH in 3D is rather HOPELESS!

5. ...To Conserve Our Brain Cells, we chose a different approach…

6. In this Talk… • Recap of the self-adjusting framework. • Our design/implementation of a kinetic framework. • Generated the movie we see previously. • Discuss a few applications of the framework. • Jumping ahead in time and its beneficial consequences. • Analysis of two algorithms. • New problems for future work.

7. main main g f g f h h k m k m Self-Adjusting Computation Idea: Record who reads what and when Memory Some parts of the input change Note: Some part of the computation can be re-used by applying the memoization technique.

8. The Kinetic Framework • Static Geometric Algorithm: • Input: a set S µRdOutput: A(S) • Goal: enable straight-forward methodical transformation of a static geometric algorithm: • to handle continuous motion. • to allow insertion/deletion of points. • to allow motion parameters update at any time. • to support composition of algorithms.

9. The Kinetic Framework (cont.) • Idea: insert a tracking code into an existing code. • Builds on the self-adjusting computation framework. • immediate dynamization • Introduce certificate • test/comparison • expires when the current value is invalid. • Illustration (next slide). Our Kinetic Library Self-Adjusting Computation

10. The Kinetic Framework (cont.) [An Example] • Given: a list of moving points in R2. • Calculate: the right-most point (assuming no tie at all time) • Trivial algorithm: maintain the max so far and scan the list p2 Y Y p0 <L p1 p1 <L p2 p1 N N Y p2 p0 <L p2 N p0

11. The Kinetic Framework (cont.) certificate = comparsion result + expiration time • In theory: • able to kinetize every algorithm whose certificate’s expiration time can be computed. • Efficiency?not always! p2 Y Y p0 <L p1 p1 <L p2 p1 N N Y p2 p0 <L p2 N p0

12. Our Kinetic Library • SML library (compatible with SML/NJ and MLton) ~ 700 lines of SML code • Builds atop the self-adjusting library • A Library for Self-Adjusting Computation (to appear in ML 2005) • Priority queue of certificate failure times. Self-adjusting computation to reflect the changes. • We were able to kinetize • 2d: Graham-scan, Merge Hull, QuickHull, Randomized QuickHull • 3d: Incremental Hull • Benchmark: Pending

13. Training QuickHull to “Walk” fun split (p1,p2, pts, hull) = let val l = List.filter (fn p => lineSideTest((p1,p2),p)) pts in case l of nil => bp1::hull | h::t => let fun selectMin (a,b) = if (distCmp(a, b, (p1,p2)) then a else b val max = List.foldr selectMin h t val rest = split (max,bp2,l,hull) in split (bp1,max,l,rest) end end Static fun splitM (p1, p2, pts, hull) = let val l = filter (fn p => K.mkCert(lineSideTest((p1,p2),p)) pts in l ==> (fn cl => case cl of ML.NIL => ML.write (ML.CONS(p1,hull)) | ML.CONS(h,t) => hull ==> (fn chull => let fun select (a,b) = K.mkCert(distCmp(a,b,(vp1,vp2))) val rmax = minimum select l val rest = C.modref (rmax ==> (fn max => splitM (max,p2,l,hull))) in rmax ==> (fn max => splitM (p1,max,l,rest)) end)) end Kinetic

14. Jumping Time • An Open Problem [Guibas’98]: How can one skip ahead in time? • Fact: The set of “certificates” is a correctness proof wrt. running it from scratch. • Theorem: By advancing the time to t +  and updating the certificates corresponding to events in the queue up to the time t + , the resulting set of certificates after propagation agrees with running it from scratch. • Efficiency: no worse than processing each event one by one. t +  t Time

15. Jumping Time (cont.) • Benefits • Interested in events up to  precision? ( can be chosen to suit one’s need/machine) • Make video more efficiently • Dealing with less floating-point round-off error • New Problems • Suppose float precision up to , what should  be to avoid round-off error? • Jumping so far ahead in time? When is it faster to simply re-run it form scratch?

16. Introducing the Communist Model • Coined by Mulmuley’91 • Dynamic setting • Operations: insert/delete • Finite set U, and active set S. • Each element has an equal probabilityof being inserted or deleted from the active set. insert delete

17. Stable Randomized QuickHull • QuickHull (for computing 2d convex hull) • Very Fast in practice • Worst-case: O(n2) • Unstable (in self-adjusting framework) • Randomize it to stabilize.

18. Std-Qhull(p1,p2, s) Eliminate points under p1p2 to get s’ Pick max from p1p2 Qhull (p1, max, s’) Qhull (max, p2, s’) Idea: Randomly pair up points, and ensure that at least a fraction of points are eliminated with certain probability. Stable Randomized QuickHull (cont.) • Build on idea in Wenger’97 and B. Bhattacharya et al ’97, and T. Chan ’95.

19. Stable Randomized QuickHull (cont.) • Replace the step marked in red by • Pair up points above the line p1p2 • Pick a random pair, define a line and find the maximizer above that line. • Apply elimination (as extending from Chan’s) • There are n/4 pairs on expectation, and max {subproblem L, subproblem R} · 13/16 with probability ¸ 1/2 0 1 0 0 0 1 1

20. Stable Randomized QuickHull (cont.) • Extended Chan’s Elimination • Initial Runtime: O(nlogn) is obvious. • Theorem: Randomized QuickHull supports insertion/deletion in O(log2n) • Also perform well practically in kinetic setting, but QuickHull still outperforms it. max

21. Convex Hull in 3D • Incremental Hull • Simple and efficient • Generalizeable to arbitrary dimension • Idea: insert points one by one. remove visible faces, and tent new faces.

22. Key Requirements Given a point p, find a face f that p sees. Given a face f, find adjacent faces. Solutions For each face, keep a list of points that “belongs to” it. Keep a mapping from points to faces. Purely functional dictionary: treap Incremental Hull in 3D

23. Incremental Hull in 3D (cont.) Dynamized Treap Incremental Convex Hull in 3D Kinetic Convex Hull in 3D

24. Incremental Hull in 3D (cont.) • Fact: In a dynamized treap with uniform distribution of keys, an insertion/deletion takes O(logn) • Theorem: • O(nlog2n) for initial run • O(log2n) for each insert/delete (assuming the communist model). • Also experimentally verified. Time

25. Experimental Evaluation

26. Summary • Implemented a kinetic framework • Generated the movie we see previously. • Capable of skipping ahead in time. • Analyzed a few Kinetized/Dynamized examples • Graham-scan, Merge Hull, QuickHull, Randomized QuickHull, IHull3D • In progress • Trying to formalize the notion of “when an algorithm performs efficiently in this framework” a.k.a kinetic stability • Per event?

27. Questions ?

28. Thank You