Download presentation

Presentation is loading. Please wait.

Published byAntonia Walker Modified over 3 years ago

1
Oct 18, 2001Talk @ MIT1 Survey and Recent Results: Robust Geometric Computation Chee Yap Department of Computer Science Courant Institute New York University

2
Oct 18, 2001Talk @ MIT2 OVERVIEW n Part I: NonRobustness Survey n Part II: Exact Geometric Computation F Core Library F Constructive Root Bounds n Part III: New Directions F Moore’s Law and NonRobustness F Certification Paradigm n Conclusion

3
Oct 18, 2001Talk @ MIT3 Numerical Nonrobustness Phenomenon

4
Oct 18, 2001Talk @ MIT4 Part I: OVERVIEW n The Phenomenon n What is Geometric? n Taxonomy of Approaches n EGC and relatives

5
Oct 18, 2001Talk @ MIT5 Numerical Non-robustness n Non-robustness phenomenon y crash, inconsistent state, intermittent n Round-off errors y benign vs. catastrophic y quantitative vs. qualitative

6
Oct 18, 2001Talk @ MIT6 Examples n Intersection of 2 lines y check if intersection point is on line n Mesh Generation y point classification error (dirty meshes) n Trimmed algebraic patches in CAD y bounding curves are approximated leading to topological inconsistencies n Front Tracking Physics Simulation y front surface becomes self-intersecting

7
Oct 18, 2001Talk @ MIT7 Responses to Non-robustness n “It is a rare event” n “Use more stable algorithms” n “Avoid ill-conditioned inputs” n “Epsilon-tweaking” n “There is no solution” n “Our competitors couldn’t do it, so we don’t have to bother”

8
Oct 18, 2001Talk @ MIT8 Impact of Non-robustness n Acknowledged, seldom demanded n Economic/productivity Impact y barrier to full automation y scientist/programmer productivity y mission critical computation fail F Patriot missile, Ariadne Rocket n E.g. Mesh generation y a preliminary step for simulations y 1 failure/5 million cells [Aftosmis] y tweak data if failure

9
Oct 18, 2001Talk @ MIT9 What is Special about Geometry?

10
Oct 18, 2001Talk @ MIT10 Geometry is Harder n Geometry = Combinatorics+Numerics n E.g. Voronoi Diagram

11
Oct 18, 2001Talk @ MIT11 Example: Convex Hulls 21 21 3 3 44 55 6 6 7 78 8 9 9 InputConvex HullOutput 21 3 4 5 6 7

12
Oct 18, 2001Talk @ MIT12 Consistency n Geometric Object Consistency Relation ( P ) E.g. D is convex hull or Voronoi diagram n Qualitative error inconsistency D = (G, L,P) G=graph, L=labeling of G

13
Oct 18, 2001Talk @ MIT13 Examples/Nonexamples n Consistency is critical y matrix multiplication y shortest paths in graphs (e.g. Djikstra’s algorithm) y sorting and geometric sorting y Euclidean shortest paths

14
Oct 18, 2001Talk @ MIT14 Taxonomy of Approaches

15
Oct 18, 2001Talk @ MIT15 Gold Standard n Must understand the dominant mode of numerical computing n “F.P. Mode” : y machine floating point y fixed precision (single/double/quad) y IEEE 754 Standard n What does the IEEE standard do for nonrobustness? Reduces but not eliminate it. Main contribution is cross-platform predictability. n Historical Note

16
Oct 18, 2001Talk @ MIT16 Type I Approaches n Basic Philosophy: to make the fast but imprecise (IEEE) arithmetic robust n Taxonomy y arithmetic (FMA, scalar vector, sli, etc) y finite resolution predicates ( -tweaking, - predicates [Guibas-Salesin-Stolfi’89] ) y finite resolution geometry (e.g., grids) y topology oriented approach [Sugihara-Iri’88]

17
Oct 18, 2001Talk @ MIT17 Example n Grid Geometry [Greene-Yao’86] n Finite Resolution Geometries

18
Oct 18, 2001Talk @ MIT18 Example n What is a Finite Resolution Line? y A suitable set of pixels [graphics] y A fat line [generalized intervals] y A polyline [Yao-Greene, Milenkovic, etc] y A rounded line [Sugihara] fat line: polyline: aX+bY+c=0; (a<2 L, b<2 L, c<2 2L ) rounded line:

19
Oct 18, 2001Talk @ MIT19 Example n Topology Oriented Approach of Sugihara-Iri: Voronoi diagram of 1 million points n Priority of topological part over numerical part n Identify relevant and maintainable properties: e.g. planarity n Issue: which properties to choose?

20
Oct 18, 2001Talk @ MIT20 Exact Approach n Idea: avoid all errors n Big number packages (big integers, big rationals, big floats, etc) n Only rational problems are exact n Even this is a problem [Yu’92, Karasick- Lieber-Nackman’89]

21
Oct 18, 2001Talk @ MIT21 Algebraic Computation n Algebraic number: y y P(x) = x 2 – 2 = 0 n Representation: P(x), 1, 2) n Exact manipulation: y comparison y arithmetic operations, roots, etc. n Most problems in Computational Geometry textbooks requires only +, –, , ,

22
Oct 18, 2001Talk @ MIT22 Type II Approach n Basic Philosophy: to make slow but error-free computation more efficient n Taxonomy y Exact Arithmetic (naïve approach) y Expression packages y Compiler techniques y Consistency approach y Exact Geometric Computation (EGC)

23
Oct 18, 2001Talk @ MIT23 Consistency Approach n Goal: ensure that no decisions are contradictory n Parsimonious Algorithms [Fortune’89] : only make tests that are independent of previous results n NP-hard but in PSPACE

24
Oct 18, 2001Talk @ MIT24 Consistency is Hard n [Hoffmann, Hopcroft, Karasick’88] Geometric Object D = (G, L) G is realizable if there exists L such that (G, L) is consistent Algorithm AL: I G(I), L(I)) AL is geometrically exact if G(I) is the exact structure for input I AL is consistent if G(I) is realizable n Intersecting 3 convex polygons is hard (geometry theorem proving)

25
Oct 18, 2001Talk @ MIT25 Exact Geometric Computation

26
Oct 18, 2001Talk @ MIT26 Part II: OVERVIEW n Exact Geometric Computing (EGC) n The Core Library n Constructive Root Bounds

27
Oct 18, 2001Talk @ MIT27 How to Compute Exactly in the Geometric Sense n Algorithm = sequence of steps y construction steps y conditional or branching steps n Branching based on sign of predicate evaluation Output combinatorial structure G in D=(G,L) is determined by path n Ensure all branches are correct this guarantees that G is exact!

28
Oct 18, 2001Talk @ MIT28 Exact Geometric Computation (EGC) n Exactness in the Geometry, NOT the arithmetic (cf.geometric exactness) n Simple but profound implications y We can now use approximate arithmetic [Dube-Yap’94] y EGC tells us exactly how much precision is needed n No unusual geometries y No need to invent new algorithms -- “standard” algorithms apply y no unusual geometries n General solution (algebraic case) y Not algorithm-specific solutions!

29
Oct 18, 2001Talk @ MIT29 Constant Expressions n = set of real algebraic operators. n = set of expressions over . n E.g., if , x 1 x 2 then is the integer polynomials over x 1 x 2. n Assume are constant operators ( no variables like x 1 x 2 ). n An expression E is a DAG y E = with and shared R Value function, Val: R where Val(E) may be undefined

30
Oct 18, 2001Talk @ MIT30 Fundamental Problem of EGC n Constant Zero Problem y CZP : given E , is Val(E)=0? n Constant Sign Problem y CSP : given E , compute the sign of Val(E). n CSP is reducible to CZP n Potential exponential gap: y sum of square roots y CZP is polynomial time [Bloemer-Yap]

31
Oct 18, 2001Talk @ MIT31 Complexity of CSP n Hierarchy: y 0 , y 1 0 y 2 1 y 3 2 Root(P,i) : P(x) Z[x] y 4 0 Sin(x), n Theorem: CSP( 3 ) is decidable. n Theorem: CSP( 1 ) is alternating polynomial time. n Is CSP( 4 ) is decidable?

32
Oct 18, 2001Talk @ MIT32 Root Bound A root bound for an expression E is a value such that n E.g., the Cauchy’s bound says that because is a root of the polynomial x 4 0 x 2 1. n Root bit-bound is defined as log(b) b > 0 b =

33
Oct 18, 2001Talk @ MIT33 How to use root bounds n Let b be a root bound for n Compute a numerical approximation for. n If then sign sign ( ) Else sign ( E ) = 0. n N.B. root bound is not reached unless sign is really zero! E E. E b/2 E E ( ) = E E

34
Oct 18, 2001Talk @ MIT34 Nominally Exact Inputs n EGC Inputs are exact and consistent n Why care about exactness if the input is inexact? Because EGC is the easiest method to ensure consistency.

35
Oct 18, 2001Talk @ MIT35 Core Library

36
Oct 18, 2001Talk @ MIT36 EGC Libraries n GOAL: any programmer may routinely construct robust programs * n Current Libraries: Real/Expr [Yap-Dube’94] LEDA real [Burnikel et al’99] Core Library [Karamcheti et al’99]

37
Oct 18, 2001Talk @ MIT37 Core Library n An EGC Library y C++, compact (200 KB) y Focus on “Numerical Core” of EGC y precision sensitive mechanism y automatically incorporates state of art techniques n Key Design Goal: ease of use y “Regular C++ Program” with preamble: #include “CORE.h” y easy to convert existing programs

38
Oct 18, 2001Talk @ MIT38 Core Accuracy API n Four Levels (I) Machine Accuracy (IEEE standard) (II) Arbitrary Accuracy (e.g. Maple ) (III) Guaranteed Accuracy (e.g. Real/Expr ) (IV) Mixed Accuracy (for fine control)

39
Oct 18, 2001Talk @ MIT39 Delivery System n No change of programmer behavior y At the flip of a switch! y Benefits: code logic verification, fast debugging #define Level N // N=1,2,3,4 #include “CORE.h” /* ***************************** * any C/C++ Program Here * ***************************** */

40
Oct 18, 2001Talk @ MIT40 What is in CORE levels? n Numerical types: y int, long, float, double BigInt, BigFloat, Expr n Promotions (+Demotions): Level II: long BigInt, double BigFloat Level III: long, double Expr

41
Oct 18, 2001Talk @ MIT41 What is in Level III? n Fundamental gap between Levels II and III n Need for iteration: consider a = b + c; n Precision sensitive evaluation

42
Oct 18, 2001Talk @ MIT42 Relative and Absolute Precision Let real X be an approximation of X. n Composite precision bound [r, a] n If r , then get absolute precision a. n If a , then get relative precision r. Interesting case: [r, a] = [1, ] means we obtain the correct sign of X.

43
Oct 18, 2001Talk @ MIT43 Precision-Driven Eval of Expressions n Expr’s are DAGs n Each node stores: an approximate BigFloat value; a precision; a root bound n Down-Up Algorithm: y precision p is propagated down y error e propagated upwards y At each node, check e p y Check passes automatically at leaves y Iterate if check fails; use root bounds to terminate

44
Oct 18, 2001Talk @ MIT44 Example n Line intersection (2-D): y generate 2500 pairs of lines y compute their intersections y check if intersection lies on one line y 40% failure rate at Level I n In 3-D: y classify pairs of lines as skew, parallel, intersecting, or identical. y At Level I, some pairs are parallel and intersecting, etc.

45
Oct 18, 2001Talk @ MIT45 Example: Theorem Proving Application n Kahan’s example (4/26/00) y “To show that you need theorem proving, or why significance arithmetic is doomed” y F(z): if (z=0) return 1; else (exp(z)-1)/z; y Q(y): |y-sqrt(y**2 +1)| - 1/(y-sqrt(y**2+1)); y G(x): F(Q(x)**2). y Compute G(x) for x=15 to 9999. n Theorem proving with Core Library [Tulone-Yap-Li’00] y Generalized Schwartz Lemma for radical expressions

46
Oct 18, 2001Talk @ MIT46 Constructive Root Bounds

47
Oct 18, 2001Talk @ MIT47 Problem of Constructive Root Bounds n Classical root bounds (e.g. Cauchy’s) are not constructive n Wanted: recursive rules for a family of expressions to maintain parameters p 1, p 2, etc, for any expression E so that B(p 1, p 2,...) is a root bound for E. n We will survey various bounds

48
Oct 18, 2001Talk @ MIT48 Illustration n is root of A(X) = i=0 a i X i of degree n n Height of A(X) is A n Degree-height [Yap-Dube 95] y Cauchy’s bound: y maintain bound on heights y but this requires the maintenance of bounds on degrees n Degree-length [Yap-Dube 95] y Landau’s bound:

49
Oct 18, 2001Talk @ MIT49 Degree-Measure Bounds n [Mignotte 82, Burnikel et al 00] where m( is the measure of . n It turns out that we also need to maintain the degree bound

50
Oct 18, 2001Talk @ MIT50 BFMS Bound n [Burnikel-Fleischer-Mehlhorn-Schirra’99] y For radical expressions y Tight for division-free expressions y For those with divisions: where E is transformed to U(E)/L(E) y Improvement [‘01]

51
Oct 18, 2001Talk @ MIT51 New Constructive Bound n Applies to general - expressions. n The bounding function is y : an upper bound on the absolute value of conjugates of y : an upper bound on the leading coefficient of y : an upper bound on the degree of

52
Oct 18, 2001Talk @ MIT52 Inductive Rules

53
Oct 18, 2001Talk @ MIT53 Comparative Study n Major open question: is there a root bit- bound that depends linearly on degree? n No single constructive root bound is always better than the others. y BFMS, degree-measure and our bound y Compare their behavior on interesting classes of expressions: F sum of square roots, F continued fraction, etc. y In Core Library, we compute all three bounds and choose the best one.

54
Oct 18, 2001Talk @ MIT54 Experimental Results n A critical predicate in Fortune’s sweepline algorithm for Voronoi diagrams is. n Input coordinates are L-bit long, a’s, b’s and d’s are 3L-, 6L- and 2L-bit integers, respectively. y The BFMS bound: (79 L + 30) bits y The degree-measure bound: (64 L + 12) bits y Our new bound: (19 L + 9) bits y Best possible [Sellen-Yap]: (15 L + O(1)) bits

55
Oct 18, 2001Talk @ MIT55 Timing on Synthetic Input Timings for Fortune’s predicate on degenerate inputs (in seconds) Tested on a Sun UltraSparc (440MHz, 512 MB) 84.5410.991.620.220.03D-M 79.4311.691.630.240.03BFMS 3.900.690.120.030.01NEW 200100502010L

56
Oct 18, 2001Talk @ MIT56 Timing for Degenerate input Timings on Fortune’s algorithm on degenerate inputs on a uniform (32 x 32) grid with L-bit coordinates (in seconds) > 2 hrs1874.41681.6418.5D-M 5892.21218.11014.186.1BFMS 112.347.541.735.2NEW 50302010L

57
Oct 18, 2001Talk @ MIT57 Moore’s Law and Non-robustness Trends

58
Oct 18, 2001Talk @ MIT58 Part III: OVERVIEW n New Directions n Robustness as Resource F (or, how to exploit Moore’s Law) n Certification Paradigm F (or, how to use incorrect algorithms)

59
Oct 18, 2001Talk @ MIT59 Moore’s Law and Robustness n Computers are becoming faster (Moore’s Law, 1965) n Software are becoming less robust y crashes more often y must solves larger/harder problems (e.g. Meshes, CAD) y expectation is increasing n Inverse correlation y is this inevitable?

60
Oct 18, 2001Talk @ MIT60 Reversing the Trend n Robustness: all-or-nothing ? n Computational Paradigm y robustness as computational resource y exchange some speed for robustness n Goal: a positive correlation between Moore’s Law and robustness

61
Oct 18, 2001Talk @ MIT61 Robustness Trade-off Curves n Each program P, for given input, defines a family of speed- robustness trade-off curves, one curve for each CPU speed What is 100% robustness?

62
Oct 18, 2001Talk @ MIT62 Computing on the Curve n P only needs to be recompiled to operate at any chosen point on a curve. n With each new hardware upgrade, we can automatically recompile program to achieve the “sweetspot” on the new curve

63
Oct 18, 2001Talk @ MIT63 Architecture n Automatically generated Makefiles y a registry of programs that wants to join y sample inputs (various sizes) for each program y robustness targets/parameters y optimization function (e.g., min acceptable speed)

64
Oct 18, 2001Talk @ MIT64 Hardware Change/Upgrade n For given hardware configuration, for each program: y compile different robust versions of the program y run each on the test inputs to determine trade-off curve y optimize the parameters n Layer above the usual compiler n Application: libraries, CPU upgrades n Can be automatic and transparent (like the effects of Moore’s law)

65
Oct 18, 2001Talk @ MIT65 Certification Paradigm

66
Oct 18, 2001Talk @ MIT66 Another Paradigm Shift n Motivation: programs based on machine arithmetic are fast, but not always correct. n Floating point filter phenomenon n Need new framework for working with ``useful but incorrect algorithms’’

67
Oct 18, 2001Talk @ MIT67 Verification vs. Checking n Program verification movement (1970s) n Another reason why it failed: y Algorithm: “always correct” y H-algorithm: “always fast, often correct” n Checking paradigm [Blum,Kannan] y use H-algorithms y only check specific input/output pairs, not programs.

68
Oct 18, 2001Talk @ MIT68 Checking vs. Certifying n Checker: given an input-output pair, always accept or reject correctly n Certifier (or Filter): given an input- output pair, either accept or “unsure” n Why certify? y Certifiers are easier to design y Nontrivial checkers may not be known (e.g. sign of determinant)

69
Oct 18, 2001Talk @ MIT69 Filtered Algorithms n How to use Certifiers? Ingredients: F Algorithm A F H-algorithm H F Filter or Certifier F n Basic Architecture y run H, filter with F, run A if necessary

70
Oct 18, 2001Talk @ MIT70 Some Floating Point Filters n FvW Filter, BFS Filter n Static, Semi-static and dynamic filters n Lemma: y given expression E with k operations and floating point inputs, can compute an upper bound on E with 3k flops n Static case [FwW]: about 10 flops per arithmetic operations

71
Oct 18, 2001Talk @ MIT71 Model for Filtering n Case: 2D Delaunay Triangulation y Base line y Top line y sigma = top line/base line = 60 y phi = filtering performance = 20 n efficacy = sigma/phi = 3 n Synthetic vs. Realistic algorithms n beta factor y = filterable fraction of work at top line n estimating beta [Mehlhorn et al]

72
Oct 18, 2001Talk @ MIT72 Extensions n Different levels of granularity y Checking Geometric structures [Mehlhorn, et al] y Determinant filter [Pan] n Filter compiler [Schirra] n Cascaded bank of filter [Funke et al] y skip A if necessary

73
Oct 18, 2001Talk @ MIT73 Conclusion

74
Oct 18, 2001Talk @ MIT74 REVIEW n Part I: NonRobustness Survey n Part II: Exact Geometric Computation F Core Library F Constructive Root Bounds n Part III: New Directions F NonRobustness as Resource (or, how to exploit Moore’s Law) F Certification Paradigm (or, how to use incorrect algorithms)

75
Oct 18, 2001Talk @ MIT75 Summary n Non-robustness has major economic/productivity impact n Scientifically sound and systematic solution based on EGC is feasible n Main open problem: y Is EGC for possible for non-algebraic problems? (CSP) n Program filtering goes beyond program checking n Robustness as resource paradigm can be exploited (with Moore’s Law)

76
Oct 18, 2001Talk @ MIT76 Download Software n Core Library Version 1.4 n small and easy-to-use n Project Homepage: http://cs.nyu.edu/exact/

77
Oct 18, 2001Talk @ MIT77 Last Slide

78
Oct 18, 2001Talk @ MIT78 Extras

79
Oct 18, 2001Talk @ MIT79 Algebraic Degree Bound n The expression where is the radical or root node in the expression. n The degree bound, where is either the index of radical nodes or the degree in polynomial root nodes.

80
Oct 18, 2001Talk @ MIT80 Leading Coefficients and Conjugates Bound n Basic tool: resultant calculus n Case: given two algebraic numbers and with minimal polynomials and and a defining polynomial for is y Represented in the Sylvester matrix form y Leading coefficient: y Constant term: y Degree:

81
Oct 18, 2001Talk @ MIT81 (cont.) n Due to the admission of divisions, we also need to bound: y Tail coefficients y Lower bounds on conjugates n Measures are involved in bounding tail coefficients.

82
Oct 18, 2001Talk @ MIT82 End of Extra Slides

Similar presentations

OK

Algebra Seeing Structure in Expressions Arithmetic with Polynomials and Rational Expressions Creating Equations Reasoning with Equations and Inequalities.

Algebra Seeing Structure in Expressions Arithmetic with Polynomials and Rational Expressions Creating Equations Reasoning with Equations and Inequalities.

© 2018 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google