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

Kanat TangwongsanALADDIN 2005

Joint work with Umut Acar, Joint work with Umut Acar, Guy Blelloch, and Jorge Vittes.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:Input: S S

Output: Output: CHCH((S)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 gh

k m

main

f g

h

k m

Memory

Some parts of the input changeSome parts of the input change

IdeaIdea: Record who reads what and when : 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 µ Rd Output: A(S)

• Goal: enable straight-forward methodical transformation of a static geometric algorithm:– to handle continuous motioncontinuous motion.– to allow insertion/deletion of pointsinsertion/deletion of points.– to allow motion parameters updatemotion parameters update at any

time.– to support compositioncomposition 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 R2.• Calculate: the right-most point (assuming

no tie at all time)• Trivial algorithm: maintain the max so far and

scan the list

p0 <L p1 p1 <L p2

Y

p0 <L p2

N

p2

p1

p2

p0

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!

p0 <L p1 p1 <L p2

Y

p0 <L p2

N

p2

p1

p2

Y

Y

N

N

p0

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 end

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

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.

Timet 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(n2) – 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/2

0 1 0 0 0 1 1

Stable Randomized QuickHull (cont.)

• Extended Chan’s Elimination

• Initial Runtime: O(nlog n) is obvious.• Theorem: Randomized QuickHull

supports insertion/deletion in O(log2 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.)

DynamizedTreap

IncrementalConvex Hull

in 3D

KineticConvex 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(nlog2 n) for initial run– O(log2 n) for each insert/delete (assuming

the communist model).

• Also experimentally verified.

TimeTime

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