Gabriel Triangulations and Angle-Monotone Graphs: Local Routing and Recognition

Gabriel Triangulations and Angle-Monotone Graphs: Local Routing and Recognition

Nicolas Bonichon LaBRI, Univ. Bordeaux, France. bonichon@labri.fr    Prosenjit Bose School of Computer Science, Carleton University, Ottawa, Canada. jit@scs.carleton.ca    Paz Carmi Department of Computer Science, Ben-Gurion University of the Negev, Israel. carmip@cs.bgu.ac.il   
Irina Kostitsyna
Université Libre de Bruxelles. irina.kostitsyna@ulb.ac.be
   Anna Lubiw David R. Cheriton School of Computer Science, University of Waterloo, Canada. alubiw@uwaterloo.ca    Sander Verdonschot School of Electrical Engineering and Computer Science, University of Ottawa, Ottawa, Canada. sander@cg.scs.carleton.ca
 
Abstract

A geometric graph is angle-monotone if every pair of vertices has a path between them that—after some rotation—is - and -monotone. Angle-monotone graphs are -spanners and they are increasing\hypchord graphs. Dehkordi, Frati, and Gudmundsson introduced angle-monotone graphs in 2014 and proved that Gabriel triangulations are angle\hypmonotone graphs. We give a polynomial time algorithm to recognize angle-monotone geometric graphs. We prove that every point set has a plane geometric graph that is generalized angle-monotone—specifically, we prove that the half--graph is generalized angle-monotone. We give a local routing algorithm for Gabriel triangulations that finds a path from any vertex to any vertex whose length is within times the Euclidean distance from to . Finally, we prove some lower bounds and limits on local routing algorithms on Gabriel triangulations.

\usetkzobj

all

1 Introduction

A geometric graph has vertices that are points in the plane, and edges that are drawn as straight-line segments, with the weight of an edge being its Euclidean length. A geometric graph need not be planar. Geometric graphs that have relatively short paths are relevant in many applications for routing and network design, and have been a subject of intense research. A main scenario is that we are given a point set and must construct a sparse geometric graph on that point set with good shortest path properties.

If the shortest path between every pair of points has length at most times the Euclidean distance between the points, then the geometric graph is called a -spanner, and the minimum such is called the spanning ratio. Since their introduction by Paul Chew in 1986 [10], spanners have been heavily studied [18].

Besides the existence of short paths, another issue is routing—how to find short paths in a geometric graph. One goal is to find paths using local routing where the path is found one vertex at a time using only local information about the neighbours of the current vertex plus the coordinates of the destination. A main example of such a method is greedy routing: from the current vertex take any edge to a vertex that is closer (in Euclidean distance) to the destination than is. The geometric graphs for which greedy routing succeeds in finding a path are called greedy drawings. These have received considerable attention because of their potential ability to replace routing tables for network routing, and because of the noted conjecture of Papadimitriou and Ratajczak [19] (proved in [16, 5]) that every 3-connected planar graph has a greedy drawing. One drawback is that a path found by greedy routing may be very long compared to the Euclidean distance between the endpoints. Of course this is inevitable if the geometric graph has large spanning ratio.

When a geometric graph is a -spanner, we can ideally hope for a local routing algorithm that finds a path whose length is at most times the Euclidean distance between the endpoints, for some , where, of necessity, . The maximum ratio, , of path length to Euclidean distance is called the routing ratio. For example, the Delaunay triangulation, which is a -spanner for  [21], permits local routing with routing ratio  [7]. It is an open question whether the spanning ratio and routing ratio are equal, though there is a provable gap for -Delaunay triangulations [7] and TD-Delaunay triangulations [9].

Other “good” paths. Recently, a number of other notions of “good” paths in geometric graphs have been investigated. Alamdari et al. [2] introduced self-approaching graphs, where any two vertices and are joined by a self-approaching path—a path such that a point moving continuously along the path from to any intermediate destination on the path always gets closer to in Euclidean distance. In an increasing-chord graph, this property also holds for the reverse path from to . The self-approaching path property is stronger than the greedy path property in two ways: it applies to every intermediate destination , and it requires that continuous motion (not just the vertices) along the path to always gets closer to . The significance of the stronger property is that self-approaching and increasing-chord graphs have bounded spanning ratios of 5.333 [15] and 2.094 [20], respectively. An important characterization is that a path is self-approaching if and only if at each point on the path, there is a wedge that contains the rest of the path [15].

Angelini et al. [4] introduced monotone drawings, where any two vertices and are joined by a path that is monotone in some direction. This is a natural desirable property, but not enough to guarantee a bounded spanning ratio.

Angle-monotone paths. In this paper we explore properties of another class of geometric graphs with good path properties. These are the angle-monotone graphs which were first introduced by Dehkordi, Frati, and Gudmundsson [12] as a tool to investigate increasing-chord graphs. (We note that Dehkordi et al. [12] did not give a name to their graph class.)

A polygonal path with vertices is -monotone for some angle if the vector of every edge lies in the closed wedge between and . (In the terminology of Dehkordi et al. [12] this is a -path.) In particular, an --monotone path (where and coordinates are both non-decreasing along the path) is a -monotone path for (measured from the positive -axis). A path is angle-monotone if there is some angle for which it is -monotone. To visualize this, note that a path is angle-monotone if and only if it can be rotated to be --monotone. An angle-monotone path is a special case of a self-approaching path where the wedges containing the rest of the path all have the same orientation. See Figure 1. This implies that an angle-monotone path is also angle-monotone when traversed in the other direction, and thus, has the increasing-chord property. Observe that angle-monotone paths have spanning ratio —this is because --monotone paths do.

Figure 1: The difference between a self-approaching path (left) with wedges each containing the rest of the path, and an angle-monotone path (right) where the wedges all have the same orientation .

A geometric graph is angle-monotone if for every pair of vertices , , there is an angle-monotone path from to . Note that the angle may be different for different pairs . Dehkhori et al. [12] introduced angle-monotone graphs, and proved that they include the class of Gabriel triangulations (triangulations with no obtuse angle). Their main goal was to prove that any set of points in the plane has a planar increasing-chord graph with Steiner points and edges. Given their result that Gabriel graphs are increasing chord, this follows from a result of Bern et al. [6] that any point set can be augmented with points to a point set whose Delaunay triangulation is Gabriel.

The notion of angle-monotone graphs can be generalized to wedges of angle different from . (A precise definition is given below.) We call these angle-monotone graphs with width , or generalized angle-monotone graphs. For , they still have bounded spanning ratios.

Results. The main themes we explore are: Which geometric graphs are angle-monotone? Can we create a sparse (generalized) angle-monotone graph on any given point set? Do angle-monotone graphs permit local routing?

Our first main result is a polynomial time algorithm to test if a geometric graph is angle-monotone. This is significant because it is not known whether increasing chord graphs can be recognized in polynomial time (or whether the problem is NP-hard). Our algorithm extends to generalized angle-monotone graphs for any width .

Our next result is that for any point set in the plane, there is a plane geometric graph on that point set that is angle-monotone with width . In particular, we prove that the half--graph has this property. Width cannot always be achieved because it would imply spanning ratio which is known to be impossible for some point sets, as discussed below under Further Background.

The rest of the paper is about local routing algorithms, where we concentrate on a subclass of angle-monotone graphs, namely the Gabriel triangulations. We give a local routing algorithm for Gabriel triangulations that achieves routing ratio . This is better than the best known routing ratio for Delaunay triangulations of 5.90 [7]. Also, our algorithm is simpler. The algorithm succeeds, i.e. finds a path to the destination, for any triangulation, and we prove that the algorithm has a bounded routing ratio for triangulations with maximum angle less than . For Delaunay triangulations, we prove a lower bound on the routing ratio of 5.07, but leave as an open question whether the algorithm ever does worse. Finally, we give some lower bounds on the routing ratio of local routing algorithms on Gabriel triangulations, and we prove that no local routing algorithm on Gabriel triangulations can find self-approaching paths.

As is clear from this outline, we leave many interesting open questions, some of which are listed in the Conclusions section.

Further Background. The standard Delaunay triangulation is not self\hypapproaching in general [2], and therefore not angle-monotone.

The Gabriel graph of point set is a graph in which for every edge the circle with diameter contains no points of . A Gabriel graph that is a triangulation is called a Gabriel triangulation. Any Gabriel triangulation is a Delaunay triangulation. Observe that a triangulation is Gabriel if and only if it has no obtuse angles. Not every point set has a Gabriel triangulation, e.g. three points forming an obtuse triangle.

There are several results on constructing self-approaching/increasing-chord graphs on a given set of points. Alamdari et al. [2] constructed an increasing chord network of linear size using Steiner points, and Dehkordi et al. [12] improved this to a plane network. It is an open question whether every point set admits a plane increasing-chord graph without adding Steiner points. However, for the more restrictive case of angle-monotone graphs, the answer is no: any angle-monotone graph has spanning ratio but there is a point set (specifically, the vertices of a regular 23-gon) for which any planar geometric graph has spanning ratio at least 1.4308 [13]. An earlier example was given by Mulzer [17].

Preliminaries and Definitions. A polygonal path with vertices is -monotone with width for some angles and with if the vector of every edge lies in the closed wedge of angle between and . When we have no need to specify , we say that the path is angle-monotone with width , or “generalized angle-monotone”. A path that is generalized angle-monotone is a generalized self-approaching path [1] and thus has bounded spanning ratio depending on  [1]. But in fact, we can do better:

Observation 1

[proof in Appendix A] The spanning ratio of an angle-monotone path with width is at most .

A geometric graph is angle-monotone with width if for every pair of vertices , , there is an angle-monotone path with width from to . When we have no need to specify , we say that the graph is “generalized angle-monotone”.

Note that in an angle-monotone path (with width ) the distances from to later vertices form an increasing sequence. Furthermore, any -monotone path from to lies in a rectangle with and at opposite corners and with two sides at angles , and the union of such rectangles over all forms the disc with diameter . (See Figure 5 in Appendix.) This implies:

Lemma 1

Any angle-monotone path from to lies inside the disc with diameter .

2 Recognizing Angle-monotone Graphs

In this section we give an time algorithm to test if a geometric graph with vertices and edges is angle-monotone. The idea is to look for angle-monotone paths from a node to all other nodes, and then repeat over all choices of . For a given source vertex , the algorithm explores nodes in non-decreasing order of their distance from . At each vertex we store information to capture all the possible angles for which there is a -monotone path from to . We show how to propagate this information along an edge from to .

We begin with some notation. We will measure angles counterclockwise from the positive -axis, modulo . To any ordered pair of vertices (points) of our geometric graph we associate the vector and we denote its angle by . If is a set of angles that lie within a wedge of angle less than , then we define the minimum of to be the most clockwise angle, and the maximum of to be the most counter-clockwise angle. More formally, is the minimum of if for any other , , and similarly for maximum.

Although there may be exponentially many angle-monotone paths from to , each such path has two extreme edges. More precisely, if is an angle-monotone path from to , then the angles, , lie in a wedge, and so this set has a minimum and maximum that differ by at most . We will store a list of all such min-max pairs with vertex . Each pair defines a wedge of at most . Since each pair is defined by two edges, there are at most such pairs (though we will show below that we only need to store of them).

The algorithm starts off by looking at every edge and adding the pair to ’s list. Then the algorithm explores vertices in non-decreasing order of their distance from . To explore vertex , consider each edge and each pair stored with , and update the list of pairs for vertex as follows. If is within of and within of then add to ’s list the pair .

If ever the algorithm tries to explore a vertex that has no pairs stored with it, then halt—the graph is not angle-monotone. To justify correctness we prove:

Lemma 2

When the algorithm has explored all the vertices closer to than , then there exists an angle-monotone path from to with extreme edges and if and only if the pair is in ’s list.

Proof

The proof is by induction on the distance from to .

For the “only if” direction, let be an angle-monotone path from to with extreme edges and , and let be the penultimate vertex of . The subpath of from to is an angle-monotone path. Suppose its extreme edges are and where or or both. Now, is closer to so by induction the pair is in ’s list. Because is angle-monotone, is within of and . Thus the update step applies. During the update step we add the angle to the pair , which gives the pair . Thus we add the pair to ’s list.

For the “if” direction, suppose that the pair is in ’s list. This pair was added to ’s list because of an update from some vertex closer to applied to some pair in ’s list. By induction, there exists an angle-monotone path from to with extreme edges and , and because the update is only performed when is within degrees of and therefore the edge can be added to to produce an angle-monotone path with extreme edges and . ∎

To improve the efficiency of the algorithm we observe that it is redundant to store at a vertex a pair whose wedge contains the wedge of another pair. Therefore, we only need to store pairs at each vertex, at most one pair whose first element is for each edge . We can simply keep with each vertex a vector indexed by edges , in which we store the minimal pair (if any) associated with so far. Finally, observe that during the course of the algorithm, each edge is handled once in an update step. With the refinement just mentioned, handling an edge costs . Therefore the algorithm runs in time for a single choice of , and in time overall.

The algorithm can be generalized to recognize angle-monotone graphs of width for fixed . It is no longer legitimate to explore vertices in order of distance from , since a generalized angle-monotone path will not necessarily respect this ordering. However, we can run the algorithm in phases, where phase captures all the angle-monotone paths of width that start at and have at most edges. Since no angle-monotone path can repeat a vertex, there are at most edges in any angle-monotone path. Thus we need phases. In each phase, for each directed edge we update each pair stored at as follows. If is within of and within of then add to ’s list the pair . In this way, each of the phases takes time , so the total run-time of the algorithm over all choices of becomes .

3 A Class of Generalized Angle-Monotone Graphs

In this section we show that every point set in the plane has a plane geometric graph that is angle-monotone with width . In particular, we will prove that the half--graph has this property. As noted in the Introduction, there are point sets for which no plane graph is angle-monotone with width . It is an open question to narrow this gap and find the minimum angle for which every point set has a plane graph that is angle-monotone with width (and thus spanning ratio ).

We first define the half--graph. For each point , partition the plane into cones with apex , with each cone defined by two rays at consecutive multiples of from the positive -axis. Label the cones , , , , , and in clockwise order around , starting from the cone containing the positive -axis. See Figure 2(a).

For two vertices and the canonical triangle is the triangle bounded by: the cone of that contains ; and the line through perpendicular to the bisector of that cone. See Figure 2(b). Notice that if is in an even cone of , then is in an odd cone of . We build the half--graph as follows. For each vertex and each even , add the edge provided that is in the cone of and is empty. We call the -neighbour of . For simplicity, we assume that no two points lie on a line parallel to a cone boundary, guaranteeing that each vertex connects to exactly one vertex in each even cone. Hence the graph has at most edges in total. The half--graph is a type of Delaunay triangulation where the empty region is an equilateral triangle in a fixed orientation as opposed to a disk [8]. It can be computed in time [18].

Figure 2: (a) 6 cones originating from point , (b) Canonical triangle , (c) path (solid) with its empty canonical triangles shaded, path (dashed) and their common vertex .

To prove angle-monotonicity properties of the half--graph, we use an idea like the one used by Angelini [3]. His goal was to show that every abstract triangulation has an embedding that is monotone, i.e. angle-monotone with width . (The same result was obtained in [14] with a different proof.) Angelini did this by showing that the Schnyder drawing of any triangulation is monotone, and in fact, upon careful reading, his proof shows that any Schnyder drawing is angle-monotone with the smaller width . Schnyder drawings are a special case of half--graphs [8] so it is not surprising that Angelini’s proof idea extends to the half--graph in general.

Theorem 3.1

The half--graph is angle-monotone with width .

Proof

We must prove that for any points and , there is an angle-monotone path from to of width . Assume without loss of generality that is in the cone of . See Figure 2(b).

Our path from to will be the union of two paths, each of which is angle-monotone of width . We begin by constructing a path from in which each vertex is joined to its neighbour. This is a -monotone path of width for . If the path contains we are done, so assume otherwise. Let be the last vertex of the path that lies in . Note that cannot lie in the cone of . Let be the subpath of from to , together with the cone of . Then separates into two parts. Suppose that lies in the right-hand part (the other case is symmetric). See Figure 2(c).

Next, construct a path from in which each vertex is joined to its neighbour. This is a -monotone path of width for .

We now claim that and have a common vertex . Then as our final path from to we take the portion of from to followed by the portion of backwards from to . Since the reverse of is -monotone with width for , the final path is -monotone with width for .

It remains to prove that exists. Let be the last vertex of that lies strictly to the right of . Let be the last vertex of that lies below . We claim that is the neighbour of , and thus that provides our vertex . Let be the empty canonical triangle from to its -neighbour (or the empty cone of in case has no -neighbour). First note that is in the cone of —otherwise would be in . Next note that is empty—otherwise would have a -neighbour that is in or is to the right of . ∎

Theorem 3.1 implies that the spanning ratio of the half--graph is 2, which was already known [11]. The best routing ratio achievable for the half--graph is  [9]. (This was the first proved separation between spanning ratio and routing ratio.) Since angle-monotone paths of width have spanning ratio , this implies that no local routing algorithm can compute angle-monotone paths with width on the half--graph.

4 Local Routing in Gabriel Triangulations

In this section we give a simple local “angle” routing algorithm that finds a path from to in any triangulation. Like previous algorithms, the path walks only along edges of triangles that intersect the line segment . The novelty is that the next edge of the path is chosen based on angles relative to the vector .

The details of the algorithm are in Section 4.1. In Section 4.2 we prove that the algorithm has routing ratio on Gabriel graphs, and discuss its behaviour on Delaunay triangulations. In Section 4.3 we give lower bounds on the routing and competitive ratios of local routing algorithms on Gabriel graphs.

4.1 Local Angle Routing

Our algorithm is simple to describe: Suppose we want a route from to in a triangulation. Orient horizontally, to the right. Suppose we have reached vertex . Consider the last (rightmost) triangle that is incident to and intersects the line segment . The triangle has two edges incident to . Of these two edges, take the one that has the minimum angle to the horizontal ray from to the right. See Figure 3. Pseudo-code can be found below in Algorithm 1. Note that in the pseudo-code, the angle test is equivalently replaced by two tests, identifying steps of type A and B for easier case analysis. For an example of a path computed by the algorithm, see Figure 4. Observe that the algorithm always succeeds in finding a route from to because it always advances rightward in the sequence of triangles that intersect line segment .

Figure 3: Local routing from to . At vertex , with being the rightmost triangle incident to that intersects line segment , we route from to because the (unsigned) angle is less than angle . A step of type is shown on the left and a step of type on the right.
1
2 while  do
3      Let be the rightmost triangle containing that intersects segment , with and on the same side of line .
4      if  is closer to line than  then /* step of type */
5          
6           else  /* step of type */
7                if  then
8                    
9                     else
10                         
11                         
12                         
Algorithm 1 Local angle routing
\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzDrawPoint
Figure 4: Example of route computed by Algorithm 1 (heavy blue path). In dotted red, a longer route obtained by replacing each segment of the route by the most extreme angle. Both routes are within of .

4.2 Analysis of the Algorithm

In this section we will prove that the above algorithm has routing ratio exactly on Gabriel triangulations, which have maximum angle at most . In the last part of the section we generalize the analysis to triangulations with a larger maximum angle, and we show that the routing ratio is at least 5.07 on Delaunay triangulations.

The intuition for bounding the routing ratio on Gabriel triangulations is to replace each segment of the route by the most extreme segment possible. See Figure 4. Any step of type B is replaced by a segment plus a horizontal segment. Any step of type A is replaced by a vertical segment plus a horizontal segment. Vertical segments are the bad ones, but each vertical must be preceded by segments, which means that instead of travelling 1 unit horizontally (the optimum route) we have travelled along a segment plus 1 vertically, giving us the ratio. We now give a more formal proof.

For each edge of the path, let and . Let (resp. ) be the set of edges of the path where the algorithm makes a step of type (resp. type ). (Context will distinguish edge sets from steps.) Let and .

Lemma 3

On any Gabriel triangulation the path computed by Algorithm 1 is -increasing.

Proof

Let us show that each step is -increasing. Consider a step from , with and as defined in Algorithm 1. Assume without loss of generality that and are above line and is below. Since is the last triangle incident to that intersects , the clockwise ordering of is . Refer to Figure 3.

If the algorithm takes a step of type then is above (in coordinate) and is below . Since , thus and are greater than . If the algorithm takes a step of type then since is below and is above and , thus is greater than . ∎

Theorem 4.1

On any Gabriel triangulation, Algorithm 1 has a routing ratio of and this bound is tight.

Proof

We first bound . Observe that each edge in forms an angle with the horizontal line through that is at most . Thus and .

We next bound . Observe that edges in move us closer to the line , and must be balanced by previous steps (of type ) that moved us farther from the line . This implies that (where the last step comes from the first observation). Since , thus .

Putting these together, the length of the path is bounded by . Finally, by Lemma 3, , so this proves that the routing ratio is at most .

An example to show that this analysis is tight is given in Appendix B. ∎

We conclude this section with two results on the behaviour of the routing algorithm on other triangulations. Proofs are deferred to Appendix B.

Theorem 4.2

In a triangulation with maximum angle Algorithm 1 has a routing ratio of and this bound is tight.

Theorem 4.3

The routing ratio of Algorithm 1 on Delaunay triangulation is greater than .

We believe that the routing ratio of Algorithm 1 on Delaunay triangulations is close to , but leave that as an open question. We remark that Algorithm 1 is different from the generalization of Chew’s Routing Algorithm for Delaunay triangulations [10] (cf. the algorithm described in [7]).

4.3 Limits of Local Routing Algorithms on Gabriel Triangulations

In this section we prove some limits on local routing on Gabriel triangulations. Proofs are deferred to Appendix B.

A routing algorithm on a geometric graph has a competitive ratio of if the length of the path produced by the algorithm from any vertex to any vertex is at most times the length of the shortest path from to in , and is the minimum such value. (Recall that the routing ratio compares the length of the path produced by the algorithm to the Euclidean distance between the endpoints. Thus the competitive ratio is less than or equal to the routing ratio.)

A routing algorithm is -local (for some integer constant ) if it makes forwarding decisions based on: (1) the -neighborhood in of the current position of the message; and (2) limited information stored in the message header.

Theorem 4.4

Any -local routing algorithm on Gabriel triangulations has routing ratio at least 1.4966 and competitive ratio at least 1.2687.

Although Gabriel triangulations are angle-monotone [12], Theorem 4.4 shows that no local routing algorithm can compute angle-monotone paths since that would give routing ratio . The following theorem tells us that even less constrained paths cannot be computed locally:

Theorem 4.5

There is no -local routing algorithm on Gabriel triangulations that always finds self-approaching paths.

5 Conclusions

We conclude this paper with some open questions.

  1. What is the minimum angle for which every point set has a plane geometric graph that is angle-monotone with width (and thus has spanning ratio )? We proved , and it is known that .

  2. Is there a local routing algorithm with bounded routing ratio for any angle-monotone graph? Any increasing-chord graph?

  3. We bounded the routing ratio of our local routing algorithm on triangulations based on the maximum angle in the triangulation, but how does this relate to the property of being generalized angle-monotone? If a triangulation has bounded maximum angle, is it generalized angle-monotone? The only thing known is that maximum angle implies angle-monotone with width  [12].

  4. Is the standard Delaunay triangulation generalized angle-monotone? In particular, proving that the Delaunay triangulation is angle-monotone with width strictly less than would provide a different proof that the Delaunay triangulation has spanning ratio less than 2 [21]. It is known that the Delaunay triangulation is not angle-monotone with width (see Section 1).

  5. How does our local routing algorithm behave on standard Delaunay triangulations? We proved a lower bound of 5.07 on the routing ratio. We believe the routing ratio is close to this value, but have no upper bound.

Acknowledgements

This work was begun at the CMO-BIRS Workshop on Searching and Routing in Discrete and Continuous Domains, October 11–16, 2015. We thank the other participants of the workshop for many good ideas and stimulating discussions. We thank an anonymous referee for helpful comments.

Funding acknowledgements: A.L. thanks NSERC (Natural Sciences and Engineering Council of Canada). S.V. thanks NSERC and the Ontario Ministry of Research and Innovation. N.B. thanks French National Research Agency (ANR) in the frame of the “Investments for the future” Programme IdEx Bordeaux - CPU (ANR-10-IDEX-03-02). I.K. was supported in part by the NWO under project no. 612.001.106, and by F.R.S.-FNRS.

References

  • [1] Aichholzer, O., Aurenhammer, F., Icking, C., Klein, R., Langetepe, E., Rote, G.: Generalized self-approaching curves. Discrete Applied Mathematics 109(1–2), 3–24 (2001)
  • [2] Alamdari, S., Chan, T.M., Grant, E., Lubiw, A., Pathak, V.: Self-approaching graphs. In: Didimo, W., Patrignani, M. (eds.) Proc. Graph Drawing (GD), LNCS, vol. 7704, pp. 260–271. Springer (2013)
  • [3] Angelini, P.: Monotone drawings of graphs with few directions. In: 6th Int. Conf. Information, Intelligence, Systems and Applications (IISA). pp. 1–6. IEEE (2015)
  • [4] Angelini, P., Colasante, E., Battista, G.D., Frati, F., Patrignani, M.: Monotone drawings of graphs. J. Graph Algorithms Appl. 16(1), 5–35 (2012)
  • [5] Angelini, P., Frati, F., Grilli, L.: An algorithm to construct greedy drawings of triangulations. J. Graph Algorithms Appl. 14(1), 19–51 (2010)
  • [6] Bern, M., Eppstein, D., Gilbert, J.: Provably good mesh generation. In: Proc. 31st Symp. on Foundations of Computer Science (FOCS). pp. 231–241. IEEE (1990)
  • [7] Bonichon, N., Bose, P., De Carufel, J.L., Perković, L., Van Renssen, A.: Upper and lower bounds for online routing on Delaunay triangulations. In: Bansal, N., Finocchi, I. (eds.) Proc. 23rd European Symp. on Algorithms (ESA). LNCS, vol. 9294, pp. 203–214. Springer (2015)
  • [8] Bonichon, N., Gavoille, C., Hanusse, N., Ilcinkas, D.: Connections between theta-graphs, Delaunay triangulations, and orthogonal surfaces. In: Thilikos, D.M. (ed.) Proc. 36th Int. Workshop Graph Theoretic Concepts in Computer Science (WG). LNCS, vol. 6410, pp. 266–278 (2010)
  • [9] Bose, P., Fagerberg, R., van Renssen, A., Verdonschot, S.: Optimal local routing on Delaunay triangulations defined by empty equilateral triangles. SIAM J. Comput. 44(6), 1626–1649 (2015)
  • [10] Chew, L.P.: There is a planar graph almost as good as the complete graph. In: Proc. 2nd Annual Symp. Computational Geometry (SoCG). pp. 169–177 (1986)
  • [11] Chew, L.P.: There are planar graphs almost as good as the complete graph. J. Computer and System Sciences 39(2), 205–219 (1989)
  • [12] Dehkordi, H.R., Frati, F., Gudmundsson, J.: Increasing-chord graphs on point sets. J. Graph Algorithms Appl. 19(2), 761–778 (2015)
  • [13] Dumitrescu, A., Ghosh, A.: Lower bounds on the dilation of plane spanners (2015), http://arxiv.org/pdf/1509.07181v3.pdf
  • [14] He, X., He, D.: Monotone drawings of 3-connected plane graphs. In: Bansal, N., Finocchi, I. (eds.) Proc. 23rd European Symp. on Algorithms (ESA). LNCS, vol. 9294, pp. 729–741. Springer (2015)
  • [15] Icking, C., Klein, R., Langetepe, E.: Self-approaching curves. Math. Proc. Cambridge Philosophical Society 125, 441–453 (1995)
  • [16] Leighton, T., Moitra, A.: Some results on greedy embeddings in metric spaces. Discrete Comput. Geom. 44, 686–705 (2010)
  • [17] Mulzer, W.: Minimum Dilation Triangulations for the Regular n-Gon. Master’s thesis, Freie Universität Berlin (2004)
  • [18] Narasimhan, G., Smid, M.: Geometric Spanner Networks. Cambridge University Press (2007)
  • [19] Papadimitriou, C.H., Ratajczak, D.: On a conjecture related to geometric routing. Theor. Comput. Sci. 344, 3–14 (2005)
  • [20] Rote, G.: Curves with increasing chords. Math. Proc. Cambridge Philosophical Society 115, 1–12 (1994)
  • [21] Xia, G.: The stretch factor of the Delaunay triangulation is less than 1.998. SIAM J. Comput. 42(4), 1620–1659 (2013)

Appendix A Omitted Proofs for Section 1

Proof (Proof of Observation 1)

In the worst case we travel the two equal sides of an isoceles triangle with base length 1 and two angles of . If is the side length, the ratio is , and we have . Thus the ratio is . ∎

Figure 5: Illustration of Lemma 1. A -monotone path (in blue) inside the rectangle with both sides at angles . This rectangle lies inside the disc of diameter .

Appendix B Omitted Proofs for Section 4

Proof (Proof of Theorem 4.1)

To complete the proof, we show an example for which our algorithm gives a routing ratio of . Consider the configuration shown in Figure 6. It is a Gabriel triangulation and the route computed by the algorithm is as shown. Observe that the size of the leftmost circle can be made arbitrarily small compared to . Hence, when and , the route can be arbitrarily close to the polyline . Thus we can build a point set such that the length of the computed route is as close to as we want. ∎

\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDrawSegment\tkzDrawPolygon\tkzDrawPolygon\tkzDrawSegment\tkzDrawPolygon\tkzDrawSegment\tkzDrawPolygon\tkzDrawSegment\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzDrawPoint
Figure 6: Example that gives a lower bound on the routing ratio of our routing algorithm on Gabriel triangulations. The route found by the algorithm is drawn as a heavy blue path.
Proof (Proof sketch for Theorem 4.2)

Following the intuitive justification for the routing ratio of Algorithm 1 on Gabriel triangulations, lengthen the route by replacing each segment of the route by the most extreme segment possible. Any step of type B is replaced by a segment at angle plus a horizontal segment. Any step of type A is replaced by a segment at angle plus a horizontal segment. In all cases angles are measured from the forward horizontal. See Figure 7. Segments of type A are the bad ones, but each such segment must be preceded by angle segments, which means that instead of travelling 1 unit horizontally (the optimum route) we have travelled on a segment of angle and then on a segment of angle (both angles measured w.r.t the forward horizontal). Let these segments have lengths and respectively. In the triangle formed by these three segments, the segment is opposite angle , the segment is opposite angle and the unit horizontal is opposite angle . We need , i.e. . By the sine law, and . Thus the distance travelled is .

To show that the bound is tight, we generalize the example of Figure 6. The resulting example is shown in Figure 8. ∎

\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawSegments\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzDrawPoint
Figure 7: Intuition for general routing.
\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDrawSegment\tkzMarkAngles\tkzLabelAngle\tkzDrawPolygon\tkzDrawPolygon\tkzDrawSegment\tkzDrawPolygon\tkzDrawSegment\tkzDrawPolygon\tkzDrawSegment\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzDrawPoint
Figure 8: The worst case situation for general routing.
Proof (Proof of Theorem 4.3)

Let us explain the example of Figure 9. This Delaunay triangulation is defined in the following way: The first triangle is such that the slope of line is slightly smaller than the slope of , so we route to . Let be a point on the empty circle containing , and that is slightly below the -axis. Let be the circle that goes through and such that the tangent of at is horizontal. Let be a point on such that the slope of is slightly smaller than the slope of . We place point at the rightmost intersection of and the -axis, and we place vertices densely on the arc of between and . The route in the example of Figure 9 has length about . Moving closer and closer to leads to as a lower bound on the routing ratio of Algorithm 1 on Delaunay triangulations. ∎

\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzCircumCenter\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDrawCircle\tkzDrawCircle\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzCircumCenter\tkzGetPoint\tkzDrawPolygon\tkzDrawSegment\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzDrawPoint
Figure 9: Example that gives a 5.0 lower bound on the routing ratio of Algorithm 1 on Delaunay triangulations.
Proof (Proof of Theorem 4.4)
\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPoint\tkzDefPointBy\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzGetPoint\tkzDrawSegment\tkzDrawCircle\tkzDrawCircle\tkzDrawCircle\tkzMarkAngles\tkzLabelAngle\tkzDrawPolygon\tkzDrawPolygon\tkzDrawPolygon\tkzDrawPolygon\tkzDrawSegment\tkzDrawSegment\tkzDrawSegment\tkzDrawSegment\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzDrawPoint\tkzDrawPoint\tkzDrawPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint
Figure 10: Example for lower bounds on the routing ratio and competitive ratio of any -local routing algorithm on Gabriel triangulations.

Let us consider the triangulation of Figure 10. This triangulation is defined as follows: all the triangles intersecting the segment are right triangles. The first one is isosceles and symmetric with respect to the -axis. Then we have a fan of triangles each having a horizontal side and pointing alternately upward and downward. Let and be respectively the upper rightmost and lower rightmost points of this set of triangles. The next triangle is such that the angle . The point is on the intersection of the line and the -axis. We complete the triangulation with two triangles, and having common hypotenuse . Finally we make the fan of of triangles arbitrarily thin and we assume that .

Now let us consider any deterministic -local routing algorithm. We consider two triangulations: The first is the one described above (and shown in Fig. 10) and the second one is obtained from the first by reflecting over the -axis the part of the triangulation that lies to the right of . No deterministic -local routing algorithm computing a path from to can distinguish between the two point sets until a vertex less than hops away from or is reached. Let be the vertex hops away from or that is reached by the algorithm on either triangulation.

Since the fan is arbitrarily thin, can be assumed to be arbitrarily close to or to .

Each case, or , leads to a non-optimal path for one of the point sets; we only consider the first case as the second will follow by symmetry. If is arbitrarily close to then, for the point set shown in Fig. 10, the shortest paths from to go through or and are of length . Moreover and . Hence the length of the complete path computed by the algorithm is at least , which proves the routing ratio lower bound. The shortest route from to goes through and is of length . Thus a lower bound on the competitive ratio is . ∎

\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefPoint\tkzDefMidPoint\tkzGetPoint\tkzDefPointBy\tkzDefLine\tkzGetPoint\tkzDefLine\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzInterLL\tkzGetPoint\tkzDrawSegment\tkzDrawSegment\tkzMarkRightAngle\tkzMarkRightAngle\tkzDrawSegment\tkzDrawCircle\tkzDrawCircle\tkzDrawPolygon\tkzDrawSegment\tkzDrawPolygon\tkzDrawPolygon\tkzDrawPolygon\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint\tkzDrawPoint\tkzLabelPoint
Figure 11: Example of Gabriel triangulation used to show that no -local routing algorithm can compute self-approaching paths.
Proof (Proof sketch for Theorem 4.5)

We apply reasoning as in the previous proof, but this time on the triangulation of Figure 11, where the fat segment represents a fan of thin triangles. As before we assume that the algorithm is routing through (if not we consider the symmetric triangulation with respect to the -axis). Moving from to the distance toward is not decreasing. Hence a self approaching path that goes through the edge cannot go through the vertex . Hence once at vertex the only possibility is to use the edge . But moving along the edge the distance toward is not decreasing. Hence, there is no self approaching path from to that goes through .

So for any deterministic -local routing algorithm, there exists a triangulation on which the algorithm will not find a self-approaching path. ∎

Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
70093
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description