Teaching Geometric Algorithms to Gracefully

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 µ R 3
• Maintain smallest convex set containing S

Output CH(S)
Input S
3
A Simple Problem (cont.)

• The Kinetic Convex Hull Problem
• points continuously moving
• Imagine making a movie!

4
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!

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
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 µ Rd Output 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 ltL p1
p1 ltL p2
p1
N
N
Y
p2
p0 ltL p2
N
p0
11
The Kinetic Framework (cont.)
certificate comparsion result expiration time

• In theory
• able to kinetize every algorithm whose
  certificates expiration time can be computed.
• Efficiency? not always!

p2
Y
Y
p0 ltL p1
p1 ltL p2
p1
N
N
Y
p2
p0 ltL 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 gt lineSideTest((p1,p2),p))
pts in case l of nil gt
bp1hull ht gt 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 gt K.mkCert(lineSideTest((p1,p2),p)
) pts in l gt (fn cl gt
case cl of ML.NIL gt ML.write
(ML.CONS(p1,hull)) ML.CONS(h,t) gt
hull gt (fn chull gt let fun
select (a,b) K.mkCert(distCmp(a,b,(vp1,vp2)))
val rmax minimum select l
val rest C.modref (rmax gt (fn max gt
splitM (max,p2,l,hull))) in rmax
gt (fn max gt splitM (p1,max,l,rest)) end))
end
Kinetic
14
Jumping Time

• An Open Problem Guibas98 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 ones 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 Mulmuley91
• 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
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
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 Wenger97 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 Chans)
• 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 Chans 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
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
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

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(log n)
• Theorem
• O(nlog2 n) for initial run
• O(log2 n) 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