Convexity is one of the oldest concepts in mathematics. It already appears in the works of Archimedes, around three centuries B.C. It was not until the 1950s, however, that this theme developed widely in the works of modern mathematicians. Convexity is a fundamental notion for computational geometry, at the core of many computer engineering applications, for instance in robotics, computer graphics, or optimization.

A convex set has the basic property that it contains the segment joining any two of its points. This property guarantees that a convex object has no hole or bump, is not hollow, and always contains its center of gravity. Convexity is a purely affine notion: no norm or distance is needed to express the property of being convex. Any convex set can be expressed as the convex hull of a certain point set, that is, the smallest convex set that contains those points. It can also be expressed as the intersection of a set of half-spaces. In the following chapters, we will be interested in linear convex sets. These can be defined as convex hulls of a finite number of points, or intersections of a finite number of half-spaces. Traditionally, a bounded linear convex set is called a polytope. We follow the tradition here, but we understand the word polytope as a shorthand for bounded polytope. This lets us speak of an unbounded polytope for the non-bounded intersection of a finite set of half-spaces.

Term rewriting is a branch of theoretical computer science which combines elements of logic, universal algebra, automated theorem proving and functional programming. Its foundation is equational logic. What distinguishes term rewriting from equational logic is that equations are used as directed replacement rules, i.e. the left-hand side can be replaced by the right-hand side, but not vice versa. This constitutes a Turing-complete computational model which is very close to functional programming. It has applications in algebra (e.g. Boolean algebra, group theory and ring theory), recursion theory (what is and is not computable with certain sets of rewrite rules), software engineering (reasoning about equationally defined data types such as numbers, lists, sets etc.), and programming languages (especially functional and logic programming). In general, term rewriting applies in any context where efficient methods for reasoning with equations are required.

To date, most of the term rewriting literature has been published in specialist conference proceedings (especially Rewriting Techniques and Applications and Automated Deduction in Springer's LNCS series) and journals (e.g. Journal of Symbolic Computation and Journal of Automated Reasoning). In addition, several overview articles provide introductions into the field, and references to the relevant literature [141, 74, 204]. This is the first English book devoted to the theory and applications of term rewriting. It is ambitious in that it tries to serve two masters:

• The researcher, who needs a unified theory that covers, in detail and in a single volume, material that has previously only been collected in overview articles, and whose technical details are spread over the literature.

• The teacher or student, who needs a readable textbook in an area where there is hardly any literature for the non-specialist.

The first part of this book introduces the most popular tools in computational geometry. These tools will be put to use throughout the rest of the book.

The first chapter gives a framework for the analysis of algorithms. The concept of complexity of an algorithm is reviewed. The underlying model of computation is made clear and unambiguous.

The second chapter reviews the fundamentals of data structures: lists, heaps, queues, dictionaries, and priority queues. These structures are mostly implemented as balanced trees. To serve as an example, red–black trees are fully described and their performances are evaluated.

The third chapter illustrates the main algorithmic techniques used to solve geometric problems: the incremental method, the divide-and-conquer method, the sweep method, and the decomposition method which subdivides a complex object into elementary geometric objects.

Finally, chapters 4, 5, and 6 introduce the randomization methods which have recently made a distinguished appearance on the stage of computational geometry. Only the incremental randomized method is introduced and used in this book, as opposed to the randomized divide-and-conquer method.

To compute the convex hull of a finite set of points is a classical problem in computational geometry. In two dimensions, there are several algorithms that solve this problem in an optimal way. In three dimensions, the problem is considerably more difficult. As for the general case of any dimension, it was not until 1991 that a deterministic optimal algorithm was designed. In dimensions higher than 3, the method most commonly used is the incremental method. The algorithms described in this chapter are also incremental and work in any dimension. Methods specific to two or three dimensions will be given in the next chapter.

Before presenting the algorithms, section 8.1 details the representation of polytopes as data structures. Section 8.2 shows a lower bound of Ω(n log n + n⌊d/2⌋) for computing the convex hull of n points in d dimensions. The basic operation used by an incremental algorithm is: given a polytope C and a point P, derive the representation of the polytope conv(C ∪ {P}} assuming the representation of C has already been computed. Section 8.3 studies the geometric part of this problem. Section 8.4 shows a deterministic algorithm to compute the convex hull of n points in d dimensions. This algorithm requires preliminary knowledge of all the points: it is an off-line algorithm. Its complexity is O(n log n + n⌊(d+1)/2⌋), which is optimal only in even dimensions.

Several problems, geometric or of other kinds, use the notion of a polytope in d-dimensional space more or less implicitly. The preceding chapters show how to efficiently build the incidence graph which encodes the whole facial structure of a polytope given as the convex hull of a set of points. Using duality, the same algorithms allow one to build the incidence graph of a polytope defined as the intersection of a finite number of half-spaces. It is not always necessary, however, to explicitly enumerate all the faces of the polytope that underlies a problem. This is the case in linear programming problems, which are the topic of this chapter.

Section 10.1 defines what a linear programming problem is, and sets up the terminology commonly used in optimization. Section 10.2 gives a truly simple algorithm that solves this class of problem. Finally, section 10.3 shows how linear programming may be used as an auxiliary for other geometric problems. A linear programming problem may be seen as a shortcut to avoid computing the whole facial structure of some convex hull. Paradoxically, the application we give here is an algorithm that computes the convex hull of n points in dimension d. Besides its simplicity, the interest of the algorithm is mostly that its complexity depends on the output size as well as on the input size. Here, the output size is the number f of faces of all dimensions of the convex hull, and thus ranges widely from O(1) (size of a simplex) to Θ(n⌊d/2⌋ (size of a maximal polytope).

We have seen in the previous chapter that in some cases completion generates a convergent term rewriting system for a given equational theory, and that such a system can then be used to decide the word problem for this equational theory. A very similar approach has independently been developed in the area of computer algebra, where Gröbner bases are used to decide the ideal congruence and the ideal membership problem in polynomial rings. The close connection to rewriting is given by the fact that Gröbner bases define convergent reduction relations on polynomials, and that the ideal congruence problem can be seen as a word problem. In addition, Buchberger's algorithm, which is very similar to the basic completion procedure presented above, can be used to compute Gröbner bases. In contrast to the situation for term rewriting, however, termination of the reduction relation can always be guaranteed, and Buchberger's algorithm always terminates with success. The purpose of this chapter is, on the one hand, to provide another example for the usefulness of the rewriting and completion approach introduced above. On the other hand, the basic definitions and results from the area of Gröbner bases are presented using the notations and results for abstract reduction systems introduced in Chapter 2.

The ideal membership problem

Let us first introduce the basic algorithmic problems that can be solved with the help of Gröbner bases.

In an arrangement of n lines in the plane, all the cells are convex and thus have complexity O(n). Moreover, given a point A, the cell in the arrangement that contains A can be computed in time Θ(n log n): indeed, the problem reduces to computing the intersection of n half-planes bounded by the lines and containing A (see theorem 7.1.10).

In this chapter, we study arrangements of line segments in the plane. Consider a set S of n line segments in the plane. The arrangement of S includes cells, edges, and vertices of the planar subdivision of the plane induced by S, and their incidence relationships.

Computing the arrangement of S can be achieved in time O(n log n + k) where k is the number of intersection points (see sections 3.3 and 5.3.2, and theorem 5.2.5). All the pairs of segments may intersect, so in the worst case we have k = Ω(n2).

For a few applications, only a cell in this arrangement is needed. This is notably the case in robotics, for a polygonal robot moving amidst polygonal obstacles by translation (see exercise 15.6). The reachable positions are characterized by lying in a single cell of the arrangement of those line segments that correspond to the set of positions of the robot when a vertex of the robot slides along the edge of an obstacle, or when the edge of a robot maintains contact with an obstacle at a point.

This chapter studies the problem of determining whether a TRS is confluent. After a brief look at the (undecidable) decision problem, the rest of the chapter divides neatly into two parts:

The first part deals with terminating systems, for which confluence turns out to be decidable. This is a key result in our search for decidable equational theories: if E constitutes a terminating TRS, we can decide if it is also confluent, in which case we know by Theorem 4.1.1 that ≈E is decidable.

The second part deals with those systems not covered by the first part, namely (potentially) nonterminating ones. The emphasis here is not on deciding ≈E by rewriting, which requires termination, but on the computational content of a TRS. Viewing a TRS as a program, confluence simply means that the program is deterministic. We show that for the class of so-called orthogonal systems, where no two rules interfere with each other, confluence holds irrespective of termination. This result has immediate consequences for the theory and design of functional programming languages.

The decision problem

Just as for termination and most other interesting properties (of term rewriting systems or otherwise), confluence is in general undecidable:

Theorem 6.1.1The following problem is undecidable:

Instance: A finite TRS R.

Question: Is R confluent?

Proof Given a set of identities E such that Var(l) = Var(r) and neither l nor r is a variable for all l ≈ r ∈ E, we can reduce the ground word problem for E to the confluence problem of a related TRS as follows.

Data structures are the keystone on which all algorithmic techniques rely. The definition of basic yet high-level data structures, with precise features and a well-studied implementation, allows the designer of an algorithm to concentrate on the core issues of the problem. For the programmer, it saves the tedious task of creating and administrating each pointer.

Throughout this book, we describe data structures especially designed for representing geometric objects and dealing with them. But computational geometers also make extensive use of data structures that represent subsets or sequences of objects. These structures can be used directly by the algorithms, or modified and augmented for geometric use. The first part of this chapter recalls the terminology and features of each basic data structure used in this book. It is useful to know how these structures can be implemented and what their performances are. The most delicate problem is undoubtedly the one addressed by dictionaries and priority queues, which treat finite subsets of a totally ordered set (the universe). To achieve better efficiency, these structures are usually encoded as balanced binary trees. For instance, the second part of this chapter describes red-black trees, a class of balanced trees that can be used to implement dictionaries and priority queues. Finally, when the universe is finite, dictionaries and priority queues can be even more efficiently implemented by other more sophisticated techniques, the characteristics of which are given without proof in the third part of this chapter.

The original text was written in French. The translator's task was constrained by the fact that most of the French words used in the original text were originally coined by their authors in English publications, or have a commonly accepted translation into English. The problem was thus one of reverse engineering! Fortunately, there are now many textbooks in computational geometry which helped to resolve conflicts in terminology. Whenever possible, the translation conformed to the standard terminology or, for the more specialized vocabulary, to the terminology set up in the original papers.

For graphs, however, the use of the word edge overlapped with that of 1-faces for common geometric structures. Similarly, the word vertex is also used for polytopes in a different meaning than for graphs. The situation is somewhat complicated by the fact that sometimes graphs are introduced whose nodes are edges of a polygon. We have followed the French text in systematically using the words node and arc for the set underlying a graph and the symbolic links between the elements of this set. The terminology related to graphs is recalled in subsection 2.2.1.

We have departed from the French text for the word saillant (meaning salient) to follow the usage with convex vertices/edges, as opposed to reflex. Although a vertex or an edge is always convex in the original meaning of convexity, here it means (as most people would understand it) that the internal angle around the vertex or around the edge is smaller than π.

A randomized algorithm is an algorithm that makes random choices during its execution. A randomized algorithm solves a deterministic problem and, whatever the random choices are, always runs in a finite time and outputs the correct solution to the problem. Therefore, only the path that the algorithm chooses to follow to reach the solution is random: the solution is always the same. Most randomized methods lead to conceptually simple algorithms, which often yield a better performance than their deterministic counterparts. This explains the success encountered by these methods and the important position they are granted in this book. The time and space used when running a randomized algorithm depend both on the input set and on the random choices. The performances of such an algorithm are thus analyzed on the average over all possible random choices made by the algorithm, yet in the worst case for the input. Randomization becomes interesting when this average complexity is smaller than the worst-case complexity of deterministic algorithms that solve the same problem.

The randomized algorithms described in this chapter, and more generally encountered in this book, use the randomized incremental method. The incremental resolution of a problem consists of two stages: first, the solution for a small subset of the data is computed, then the remaining input objects are inserted while the current solution is maintained. An incremental algorithm is said to be randomized if the data are inserted in a deliberately random order.