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

A “Simple” Problem The Convex Hull Problem –Given: a set S µ R 3 –Maintain: smallest convex set containing S Input: S Output: CH(S)

A “Simple” Problem (cont.) The Kinetic Convex Hull Problem –points continuously moving Imagine making a movie!

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

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

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.

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

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

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). Self-Adjusting Computation Our Kinetic Library

The Kinetic Framework (cont.) [An Example] Given: a list of moving points in R 2. Calculate: the right-most point (assuming no tie at all time) Trivial algorithm: maintain the max so far and scan the list p 0 < L p 1 p 1 < L p 2 Y p 0 < L p 2 N p2p2 p1p1 p2p2 p0p0 Y Y N N

The Kinetic Framework (cont.) In theory: –able to kinetize every algorithm whose certificate’s expiration time can be computed. Efficiency? not always! p 0 < L p 1 p 1 < L p 2 Y p 0 < L p 2 N p2p2 p1p1 p2p2 Y Y N N p0p0 certificate = comparsion result + expiration time

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

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 fun splitM (p1, p2, pts, hull) = letval 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 Static Kinetic

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. Time t t + 

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?

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 probability of being inserted or deleted from the active set. insert delete

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

Stable Randomized QuickHull (cont.) 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. Build on idea in Wenger’97 and B. Bhattacharya et al ’97, and T. Chan ’95.

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/

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

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.

Incremental Hull in 3D 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 (cont.) Dynamized Treap Incremental Convex Hull in 3D Kinetic Convex Hull in 3D

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

Experimental Evaluation

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?

Questions ?

Thank You