1 Introduction
Routing is the process of sending a message through a network from a source vertex to a destination vertex. It is a fundamental problem in networks. If the routing algorithm has complete knowledge of the network, it is known how to send a message from any source vertex to any destination vertex (among others, Dijkstra’s algorithm can compute a shortest path between two vertices in a network).
However, it is not always possible for the routing algorithm to have full knowledge of the network. If the network is very large it may be too expensive to store it explicitly. And even if storage constraints are not an issue, it may be hard to keep the representation uptodate if the network changes frequently.
Thus, there is a need for routing algorithms that guarantee message delivery and use as little information of the network as possible. For example, it is challenging to successfully route when the only information available to the routing algorithm is the location of the current vertex, the neighbours of the current vertex and a constant amount of additional information, such as the original source vertex of the message and the destination vertex. A routing algorithm that can work under these constraints is often referred to as local (or local for some constant , when the neighbourhood^{2}^{2}2The neighbourhood is the set of vertices reachable in at most steps from the current vertex. is available). In our setting, we assume that the network is a graph embedded in the plane, with edges as straight line segments connecting pairs of vertices, weighted by the Euclidean distance between their endpoints. We refer to such networks as geometric networks. Algorithms routing on such networks are referred to as geometric routing algorithms (see [11] and [12] for surveys of the area).
Since local routing algorithms have little information beyond the immediate neighborhood of the current vertex, they use the structure of the network to guide their navigation. For example, intuitively speaking, the graph is a geometric network where each point connects to its nearest point in different cones, which can be thought of as directions (a formal definition is given in Section 2). Thus, to route on this graph, it has been shown [10] that it suffices to send the message to the nearest node in the direction of the desired destination. If is seven or larger, this strategy will ensure that the message always reaches its destination and its length is not much more than the Euclidean distance between the source and destination (see [1] for a survey on graphs). The argument can be extended to show that when is six, the strategy always reaches the destination, but this no longer gives a guarantee on the length of the path.
Using the structure of a graph to guide a routing strategy becomes more challenging in the presence of constraints, since constraints act as barriers and can disrupt the inherent structure that may be present in graphs built without constraints. For example a vertex in the graph may no longer have an edge in a given direction because of existing constraints. We model this more general setting in which some connections are forbidden by using a set of nonintersecting line segment constraints whose endpoints are vertices of the network. These segments act as constraints in the sense that no edge can properly intersect an edge of .
Given a set of points in the plane and a set of nonintersecting line segment constraints, we say that two vertices and can see each other (or are visible) when either the line segment does not properly intersect any constraint in or is itself a constraint in . If two vertices and can see each other, the line segment is referred to as a visibility edge. The visibility graph of with respect to a set of constraints , denoted , has as vertex set and all visibility edges as edge set.
This setting has been studied extensively in the context of motion planning amid obstacles. Clarkson [8] was one of the first to study this problem. In his work, he showed how to find an approximate shortest path between two points in the plane amid a set of obstacles. In order to find this approximate shortest path efficiently, Clarkson constructs a spanner of with a linear number of edges. A subgraph of is called a spanner of (for ) if for each pair of vertices and , the shortest path in between and has length at most times the shortest path between and in . The smallest value for which is a spanner is the spanning ratio or stretch factor of . Following Clarkson’s result, Das [9] showed how to construct a spanner of with constant spanning ratio and constant degree. Bose and Keil [4] showed that the Constrained Delaunay Triangulation is a 2.42spanner of . Recently, the constrained halfgraph (which is identical to the constrained Delaunay graph whose empty visible region is an equilateral triangle) was shown to be a plane 2spanner of [2] and all constrained graphs with at least 6 cones were shown to be spanners as well [7].
To the best of our knowledge, all deterministic routing algorithms known to date that guarantee that each message eventually reaches its intended destination in geometric networks compute some plane subgraph of the complete Euclidean graph and somehow route on the subgraph. This means that of the potentially quadratic number of edges available to the routing algorithm, only a linear number are ever considered. This artificial constraint limits the number of options available and thus can create paths that are much longer than necessary, for example when the destination vertex is visible from the source vertex. The visibility graph depicts all connections that are not blocked by the set of constraints. In other words, it has all connections that can be used (and this graph need not be plane). In this paper we present a strategy to route on the visibility graph, making it the first deterministic local routing algorithm that does not restrict its choices to a plane subgraph of .
1.1 Results and previous work
Although motion planning amid obstacles has been studied extensively [8, 9, 2, 7], there has not been much work on routing in the same setting. Bose et al. [3] showed that it is possible to route locally and 2competitively between any two visible vertices in the constrained graph (the constrained graph with 6 cones). A routing strategy is called competitive when the length of the path that the routing strategy follows is at most times the length of the shortest path between the source and destination in the graph. Additionally, an 18competitive routing algorithm between any two visible vertices in the constrained halfgraph (which is equivalent to the constrained Delaunay graph that uses an empty equilateral triangle) was provided [3], but this strategy does not work when the source and destination do not see each other. In the same paper it was shown that no deterministic local routing algorithm is competitive between all pairs of vertices of the constrained graph, regardless of the amount of memory it is allowed to use. Recently, the authors presented a noncompetitive 1local memory routing algorithm to route on the visibility graph [5] (a formal definition of such an algorithm can be found in Section 2). However, this method also restricts the edge choices to a plane subgraph of , as it locally determines the edges of the socalled constrained halfgraph and routes on it.
We present two deterministic 1local memory routing algorithms on . The first algorithm locally computes a nonplane subgraph of the visibility graph (the constrained graph) and routes on it. We then modify this algorithm to obtain a routing algorithm that routes directly on the visibility graph (i.e., any edge of may be used). Both of these algorithms reach the destination in at most steps. To the best of our knowledge, this is the first local routing algorithm that does not compute a plane subgraph of the visibility graph.
We also provide some lower bounds to the problem. Specifically, we show that no deterministic local routing algorithm can be competitive if we measure the quality of the path by the number of steps taken between every pair of vertices in the visibility graph. Our routing strategy creates paths of linear length, hence they are the best we can hope for in this regard.
Alternatively, if we measure the quality of the path with respect to the Euclidean length of the path, we show that no algorithm can be competitive. Under specific conditions we can also show that no algorithm can be competitive. This second bound only holds if the algorithm considers only the subgraph induced by the endpoints of edges crossing the line segment between the source and destination (a technique commonly used in the unconstrained setting).
2 Preliminaries
The graph plays an important role in our routing strategy. We begin by defining it. Define a cone to be the region in the plane between two rays originating from a vertex referred to as the apex of the cone. When constructing a (constrained) graph, for each vertex consider the rays originating from with the angle between consecutive rays being . Each pair of consecutive rays defines a cone. The cones are oriented such that the bisector of some cone coincides with the vertical ray emanating from that lies above . Let this cone be of and number the cones in clockwise order around (see Figure 2). The cones around the other vertices have the same orientation as the ones around . We write to indicate the th cone of a vertex , or if is clear from the context. For ease of exposition, we only consider point sets in general position: no two points lie on a line parallel to one of the rays that define the cones, no two points lie on a line perpendicular to the bisector of a cone, and no three points are collinear. The main implication of this assumption is that no point lies on a cone boundary. These assumptions can be removed via classic symbolic perturbation techniques.
Let vertex be an endpoint of a constraint (if any) and let be the other endpoint and let cone be the cone that contains . The lines through all constraints in with as an endpoint split into several subcones (see Figure 2). We use to denote the th subcone of (again, numbered in clockwise order). When a constraint splits a cone of into two subcones, we define to lie in both of these subcones. We consider a cone that is not split to be a single subcone.
We now introduce the constrained graph: for each subcone of each vertex , add an edge from to the closest vertex in that subcone that can see , where distance is measured along the bisector of the original cone (not the subcone). More formally, we add an edge between two vertices and if can see , , and for all points that can see , , where and denote the projection of and on the bisector of and denotes the length of the line segment between two points and . Note that our general position assumption implies that each vertex adds at most one edge per subcone.
We now define our routing model. Formally, a routing algorithm is a deterministic local, memory routing algorithm, if the choice of the vertex to which a message is forwarded from the current vertex is a function of , , , and , where is the destination vertex, is the set of vertices adjacent to and set of constraints incident to and is a memory of constant size, stored with the message. We consider a unit of memory to consist of a bit integer or a point in . Our model assumes that the only information stored at each vertex of the graph is .
Lemma 1.
[2] Let , , and be three arbitrary points in the plane such that and are visibility edges and is not the endpoint of a constraint intersecting the interior of triangle (see Figure 3). Then there exists a convex chain of visibility edges from to in triangle , such that the polygon defined by , and the convex chain is empty and does not contain any constraints.
If and do not see each other, the above lemma proves the existence of a convex path between them. We use this property repeatedly in our routing algorithm.
3 Routing on the Constrained Graph
Prior to describing our routing strategy for the entire visibility graph, we first provide one for the constrained graph. Note that the graph is not necessarily plane. In this section, we assume that we are given the constrained graph explicitly. In the next section, we show how to use this algorithm to route on the visibility graph.
If there are no constraints, there exists a simple local routing algorithm that works on all graphs with at least 4 cones. This routing algorithm, which we call routing, always follows the edge to the closest vertex in the cone that contains the destination. In the constrained setting, this algorithm follows the edge to the closest vertex in the subcone that contains the destination. Unfortunately, this approach does not necessarily succeed in the constrained setting due to two issues. First, a key factor of convergence in the unconstrained routing algorithm is that each step gets us closer to the destination (as long as we have at least 6 cones). Unfortunately, this property need not hold in the constrained setting (see Figure 4a).
A second, more important problem is that the cone containing the destination need not contain any visible vertices. This happens when a constraint is directly blocking visibility (see Figure 4b). In this case, the routing algorithm will get stuck, since it cannot follow any edge in that cone.
The first problem can be easily fixed: given a vertex and the destination , we define the canonical triangle of with respect to , denoted , as the triangle with apex , bounded by the cone boundaries of the cone of that contains and the line through perpendicular to the bisector of the cone (see Figure 4c). If the edge of that lies in that cone ends outside the canonical triangle, we call the edge invalid and we ignore it. By ignoring invalid edges we make sure that any edge we follow leads to a vertex that is closer to .
To solve the second problem, the routing algorithm needs to find a path even when an obstacle is blocking visibility to the destination (either blocking all visibility from in the cone of or because the edge in that cone is invalid). In this case the algorithm enters the obstacle avoidance phase, routing differently until an endpoint of a blocking constraint is reached.
Intuitively, our algorithm uses the routing algorithm until it gets stuck, at which point it switches to the obstacle avoidance phase in order to get around a constraint blocking its visibility to . After this phase ends, the algorithm switches back to the routing algorithm. This process is repeated until is reached. A more precise description follows in Section 3.2.
3.1 Obstacle Avoidance Phase
We first describe the obstacle avoidance phase. The algorithm enters this phase when routing from source to destination , and reaches a vertex that does not have any valid edges in the cone that contains . This can only happen if a constraint is blocking visibility to (if many of them exist, let be the one whose intersection with segment is closest to ). The goal of this phase is to reach the right endpoint of , which we denote as . The main difficulty with this phase is that the algorithm does not know where is, since is not incident on . In order to overcome this difficulty, the algorithm exploits several geometric properties arising from the unique symmetries present in the constrained graph, some of which are outlined in the proof of Lemma 2.
Without loss of generality, lies in . We first describe the case where has no edges in . The general case, where may have invalid edges in , will be considered afterwards. In this first case, the algorithm proceeds as follows. At a current vertex , the algorithm considers one of two candidate edges to follow (see Figure 5). The first is the edge to the closest visible vertex in the subcone of that shares a boundary with . The second edge is the edge from to the vertex in that minimizes the angle between and the right boundary of . If lies in and is not the endpoint of a constraint that intersects the interior of triangle , the algorithm follows the edge to . Otherwise, it follows the edge to . In the proof of Lemma 2, we show that at least one of or exists. If one of the two vertices or does not exist, the algorithm follows the edge that does exist. The obstacle avoidance phase ends when the algorithm reaches the endpoint of a constraint that intersects . In order to recognize this, the algorithm stores when the phase begins.
Lemma 2.
When has no edges in the cone containing the destination , the obstacle avoidance phase initiated by reaches the right endpoint of the closest constraint blocking visibility to .
Proof.
Without loss of generality, let lie in . Since has no edges in , the closest constraint must intersect both boundaries of . This implies that is either in or . We maintain the invariant that each intermediate vertex has no edges in and that the intersection of the right boundary of and is closer to than in the previous step. We first show that there always exists either a in or a in as defined in the paragraph preceding this lemma. This implies that our algorithm eventually reaches since there are a finite number of points in .
As a consequence of our invariant, must either lie in or . Since has no edges in , we have that is the closest constraint to in . Thus, any point on is visible from both and . Hence, we can apply Lemma 1 to the triangle and obtain a convex chain of visibility edges from to . In particular, this implies that can see a vertex in , and therefore it has an edge in . What remains to be shown is that the invariant is maintained after every step of the algorithm. We note that for any vertex in the intersection of the right boundary of its cone is closer to than that of . Thus, it remains to show that of this next vertex contains no edges. We consider the following two cases.
 The algorithm follows the edge to .

If the algorithm follows the edge to , recall that lies in and is not the endpoint of a constraint that intersects the interior of triangle . In particular, this means that lies outside of . Since is the closest visible vertex in the subcone of that shares a boundary with , the part of below the horizontal line through must be empty of points visible to (see Figure 6a).
By the invariant, is empty of visible points. What remains to be shown is that there are no points visible to in above the horizontal line through . If this region is not empty, we sweep the region using the right boundary of . Let be the first vertex hit by this sweep that is visible to (see Figure 6b), and consider the canonical triangle . Recall that this triangle has as apex and is bounded by the cone boundaries of the cone of that contains and the line through perpendicular to the bisector of the cone. In particular is empty of points visible to (since it is contained in the union of , which is empty), the swept part of , and a portion of that must also be empty by our choice of . This implies that there is an edge from to . This means that must exist. By construction, forms the smallest angle with the right boundary of . This means that . Furthermore, since and are visibility edges, Lemma 1 implies the existence of a vertex visible to in . This contradicts the existence of the edge . Thus, is empty of vertices visible to . Suppose that there was a vertex visible to in , then since and are visibility edges, Lemma 1 implies the existence of a vertex visible to in , which is a contradiction.
 The algorithm follows the edge to .

As in the previous case, we consider the part below the horizontal line through and the part above (solid green and dashed blue regions in Figure 6c, respectively). The former region must be empty or the edge would not be present: any point visible to in this region prevents from creating an edge to and vice versa. An argument similar to the one for , showing that the region above the horizontal boundary of is empty, also proves that the region above the horizontal line through is empty. Thus, must be empty of points visible to .
∎
We now consider the general case, where may have invalid edges in (see Figure 7a). In this case, when initiates the obstacle avoidance phase, we either reach or a vertex that has no edges in and (see Figure 7b). This latter case can only occur when lies in . Note that this implies that intersects both boundaries of . Therefore, we initiate a new obstacle avoidance phase from where plays the role of . By Lemma 2, the second invocation of the obstacle avoidance phase must reach .
Lemma 3.
When has no valid edges in the cone containing the destination , the general obstacle avoidance phase initiated by reaches the right endpoint of the closest constraint blocking visibility to .
We note that the above proof relies heavily on the fact that we have exactly 6 cones (and thus we are in the constrained graph). We have a specific example in which the routing strategy described above would fail for 14 cones (for some node, no edge will keep an invariant zone empty, see Figure 8). Thus, a different obstacle avoidance method is needed when the number of cones is not .
3.2 Global Routing Strategy
We now have all the pieces in place to describe our routing strategy. Our routing strategy alternates between three phases: while not blocked by an obstacle, we use the classic routing algorithm. If the current vertex has no valid edges in the cone containing the destination, it must be blocked by a constraint . In this case, we enter the obstacle avoidance phase to reach the right endpoint of . Once we reach this endpoint, we check which of the two endpoints of is closer to the destination.
If the closest point to destination is the other endpoint of , we enter the opposite endpoint phase, where we route to this other endpoint of . Note that the two endpoints of can see each other, so we can route between them using the strategy introduced in [3]. The general idea behind the routing strategy in [3] is to stay as close as possible to the visibility edge between the endpoints of in order to avoid becoming stuck behind constraints.
Once we have reached the endpoint of that is closest to the destination, we resume classic routing. We call this alternation between the three phases the constrained routing strategy.
3.3 Convergence
We now show that our routing algorithm always reaches the destination. First we give a proof of convergence which greatly overestimates the number of steps needed to reach the destination, but it turns out that first showing that the algorithm always reaches the destination simplifies the proof of bounding the number of steps.
Lemma 4.
The constrained routing strategy always reaches the destination within a finite number of steps.
Proof.
By construction, each edge followed during the routing phase gets closer to the destination. Hence, each routing phase can consist of at most steps. Similarly, an obstacle avoidance phase performs at most steps, since each step brings the boundary of cone closer to the endpoint we are routing to. At the end of an obstacle avoidance phase, we may need an opposite endpoint phase which visits each vertex at most once [3]. Thus, each cycle of these three phases consists of at most steps.
Thus, in order to show termination it remains to bound the number of alternations between phases. Each invocation of an obstacle avoidance phase is tied to a single constraint . Even though can trigger several obstacle avoidance phases, we claim that the total number is bounded. Let be the endpoint of that is closest to . We claim that between two obstacle avoidance phases triggered by we must perform an obstacle avoidance phase using another constraint whose endpoint that is closest to , lies further away from than .
Let be the closed disk with center and radius . We need to show that before using for another obstacle avoidance phase, we must reach an endpoint that lies outside .
In order for to trigger another obstacle avoidance phase, the routing path needs to first reach a vertex such that blocks visibility to from . This implies that and lie in different halfplanes with respect to the line through . Furthermore, cannot lie on this line, since needs to block visibility between and . Let be the open halfplane that contains and let be its complementary closed halfplane (see Figure 9).
Consider the routing step we performed at after reaching it as the endpoint of the obstacle avoidance phase of . Specifically, we look at which of the possible phases this step was executed. If the algorithm started a routing phase, the very first step must be towards the interior of (since each step of routing gets closer to and follows an edge in the subcone that contains ). The other option is that we immediately start another obstacle avoidance phase because of a new constraint. If the endpoint closest to of this new constraint lies outside we are done (since the obstacle avoidance phase will take us to the endpoint that we claimed), so assume that this endpoint lies inside . Furthermore, since this constraint blocks visibility from to , its endpoint closest to must lie in . Thus, we conclude that regardless of which strategy we used to route, after we leave we must reach an intermediate vertex that lies in before we visit .
Overall, we have that our proposed routing reaches , then , and somehow then goes to some vertex . Recall that was defined as the closest endpoint of to . In particular, the other endpoint is outside . Thus, even though may be in , in order for the routing strategy to reach any point of it must leave at some point. Since during the routing phase we cannot get further away from , the only way that this can happen is via an obstacle avoidance phase where both endpoints lie outside , proving our claim.
With this claim shown, we can now proceed to bound the number of alternations between the different phases. Let be all the constraints sorted by decreasing distance of their closest endpoint to . Let be the endpoint of closest to (i.e., for any , we have that ). Notice that cannot invoke more than one obstacle avoidance phase since there are no constraints whose closest endpoint is further from than . By a similar reasoning, we can show that can trigger two obstacle avoidance phases, four such phases, and in general cannot invoke an obstacle avoidance phase more than times. Since there are constraints, there cannot be more than invocations of an obstacle avoidance phase. As argued at the beginning of the proof, we execute at most steps between two obstacle avoidance phases, thus the total number of steps is upper bounded by . ∎
Note that the above reasoning shows that a single constraint can trigger an obstacle avoidance phase many times. Having shown that our algorithm terminates after a finite number of steps, we can refine the argument to reduce the number of triggers per constraint to exactly one.
Lemma 5.
Let be a constraint and let be the endpoint of that is closest to . Vertex can be visited as the final vertex of at most one obstacle avoidance or opposite endpoint phase.
Proof.
When we reach at the end of an obstacle avoidance or opposite endpoint phase, we execute a step in the routing strategy. Since this strategy is memoryless^{3}^{3}3An algorithm is called memoryless if it makes the same decision when presented with the same input, i.e., it does not store previous decisions., the routing strategy follows the same edge from every time we reach it. This implies that cannot be visited twice using an obstacle avoidance or opposite endpoint phase, since otherwise the path would cycle indefinitely, contradicting Lemma 4. ∎
This immediately gives a linear bound on the number of phase changes, implying a quadratic bound on the number of steps. We now use a more detailed analysis of the circumstances in which a vertex may be visited to tighten this further to . In order to do this, we first determine the number of constraints that can fully block visibility in a cone of a vertex .
Lemma 6.
For any vertex there can be at most three constraints that fully block visibility in some cone of .
Proof.
There are six cones around and each one can only be fully blocked by at most one constraint. This already implies that at most six constraints can fully block visibility in some cone of . In the following we reduce the number to three.
We first observe that if a constraint fully blocks visibility in some cone(s), the endpoints of must be in the cones adjacent to those blocked by it (say, if blocks cones and , then the endpoints of must lie in and , see Figure 10a). We use this fact to show that there cannot be two adjacent cones that are fully blocked by different constraints: assume, for the sake of contradiction, that we can have two constraints and fully blocking cones and , respectively. Let be the endpoint of that lies in and let be the endpoint of that lies in . Because both and are fully blocked, neither nor are visible from . Thus, they must both lie behind the constraint blocking visibility in their cones. However, this would imply that and cross each other (see Figure 10b), contradicting that the set of constraints is plane. Naturally, the same argument applies to any other two adjacent cones, hence we conclude that between two different constraints that fully block visibility there is at least one cone with visible vertices. Since we have 6 cones in total, the limit of three constraints follows. ∎
Lemma 7.
The constrained routing strategy always reaches the destination in steps.
Proof.
Consider any vertex and consider how we reached it.
 1) is reached during a routing phase.

Since the routing strategy in this phase is memoryless, we would make the same routing step from every time we reach it. In particular, this would imply that cannot be visited twice using a routing phase (otherwise, the path would cycle indefinitely, contradicting with Lemma 4). Hence, we conclude that is visited once during a routing phase during the whole routing algorithm.
 2) is reached during an avoidance phase of constraint .

We consider two subcases:
 2.1) is not an endpoint of .

Let be the vertex that initiated the avoidance phase and first consider the case in which completely blocks visibility of in the cone containing (see Figure 4b). In this situation, the same cone remains empty for all vertices along the path (including ). By Lemma 6, if is visited more than three times as part of an obstacle avoidance path, two of them share the same cone. Both of these times, the obstacle avoidance and opposite endpoint phases would end up at , the endpoint of closest to , contradicting Lemma 5. Thus, we conclude that can be reached this way at most three times.
It is possible that did not block the visibility in the cone completely (i.e., we initiated the obstacle avoidance phase because the edge was invalid, see Figure 4a). This situation is very similar to the case in which visibility was completely blocked. The only difference is that the choice of the edge we follow at depends on the cone that contained when we started this obstacle avoidance phase as well as on whether or not has edges in the two adjacent cones. We again conclude that if is visited more than a constant number of times in this way, the algorithm would route to the same neighbour of , eventually ending at the same endpoint of and contradicting Lemma 5.
 2.2) is an endpoint of .

As argued in Lemma 5, can only be visited once during the whole execution of the algorithm if it is the endpoint that is closest to . Similarly, if is the endpoint that is furthest away from , we know the algorithm enters the opposite endpoint phase and routes to the opposite endpoint of . Note that could be visited several times this way (see Figure 11). However, notice that can never be visited twice because of the same constraint , as this would imply that we visit the same closest endpoint twice as well, contradicting Lemma 5. Thus, during the entire execution of the algorithm, we can visit at most vertices as the endpoint of a constraint that is not closest to , since the set of constraints is plane.
 3) is reached during an opposite endpoint phase.

Every time a vertex is part of a path in the opposite endpoint phase, Lemma 3 of [3] shows that at least one of its cones is empty.
Hence, excluding case 2.2, each vertex is visited a constant number times. Since case 2.2 adds at most visited vertices during the entire execution of the algorithm, this implies that a total of steps are executed as claimed. ∎
Theorem 8.
There exists a 1local memory routing algorithm for the constrained graph that reaches the destination in steps.
Proof.
The algorithm is 1local by construction, since we consider only information about vertices the current vertex is connected to. The routing phase does not require any memory. The obstacle avoidance phase and opposite endpoint phase store a single vertex each and this information is discarded when the phase ends. Hence, the algorithm requires memory. Lemma 7 shows that the algorithm terminates in steps. ∎
4 Routing on the Visibility Graph
We now return our attention to our main goal: routing on the visibility graph. Since in the previous section we presented a routing algorithm for the constrained graph, we first show that we can use this algorithm to route on the visibility graph as well. Afterwards, we also describe how to modify the constrained routing algorithm to route on the visibility graph directly without locally determining the edges of the constrained graph.
We note that, unfortunately, the length of the paths resulting from these two approaches need not be related to the length of the shortest path in the visibility graph. Since we cannot determine locally which endpoint of a constraint is closest to , the routing algorithms may follow a path to an endpoint arbitrarily far away, preventing us from being competitive. However, we show in Section 5 that no deterministic local routing strategy can be competitive with respect to the length of the shortest path.
4.1 Using the Constrained Graph
In order to use the constrained routing algorithm from the previous section, we need to determine locally at a vertex which of its visibility edges are part of the constrained graph. Since it is easy to locally determine at a vertex if a vertex is the closest vertex in one of its subcones, we focus on the situation where this is not the case and we thus have to determine at if it is the closest vertex in one of the subcones of . Let the constrained canonical triangle of be clipped using the constraints intersecting the boundary of the canonical triangle with one endpoint at (see Figure 12). Note that we can determine the constrained canonical triangle of locally at .
Lemma 9.
Let and be two vertices such that is not the closest vertex to in any subcone of . Edge is part of the constrained graph if and only if does not have any visible vertices in the constrained canonical triangle of .
Proof.
We first note that we can consider the subcone of that contains to be the full cone: If the constraint defining the subcone ends in the constrained canonical triangle, Lemma 1 implies that it also contains a vertex visible to , correctly implying that is not an edge. If the constraint does not end in the constrained canonical triangle, the part of the constrained canonical triangle outside the subcone is not visible to and hence it does not influence the decision at .
It is easy to see that if has any visible vertices in the constrained canonical triangle of , is not an edge of the constrained graph: Consider the vertex such that the smaller angle of and is minimized. Since the angle is minimized, is not the endpoint of any constraints intersecting triangle , so we can apply Lemma 1 to . This gives us a vertex inside the constrained canonical triangle that is visible to . Hence, is not the closest visible vertex to and thus is not an edge of the constrained graph.
Next we show that if has no visible vertices in the constrained canonical triangle of , is an edge of the constrained graph. We prove this by contradiction, so assume that is not an edge of the constrained graph. This implies that there exists a vertex in the subcone of that contains that is closer to than is. Hence, lies in the constrained canonical triangle. Applying Lemma 1 to gives us a vertex inside the constrained canonical triangle that is visible to , contradicting that has no visible vertices in this region. ∎
4.2 Routing Directly on the Visibility Graph
In order to route directly on the visibility graph, instead of at each vertex computing the local neighbourhood in the constrained graph, the constrained routing algorithm needs to be modified. We do this in such a way that the vertices do not need to store any fixed cone orientations.
When a vertex wants to send a message, it picks an arbitrary cone orientation and stores it in the message it sends. We note that a vertex can pick a different orientation of the cones for each message that it sends and this only requires a constant amount of storage. Since the orientation is stored in the message, vertices do not need to agree on a fixed orientation in advance, as every vertex along the routing path can extract the orientation from the message and use that for its decisions.
Like in the constrained routing algorithm, routing directly on the visibility graph works in three phases: routing, obstacle avoidance, and opposite endpoint. During the routing phase a vertex simply sends the message to the closest vertex in the cone that contains , again limiting the edges it is allowed to follow to the edges that end in .
During the obstacle avoidance phase, we start by routing to either endpoint of the constraint blocking visibility to . Since we are routing on the visibility graph, Lemma 1 tells us that there is a convex chain of visibility edges to these endpoints. Hence, in order to reach an endpoint of the constraint, we follow one of these convex chains. In order to determine the next edge on the chain at an intermediate vertex , the message needs to store the predecessor of on the chain and whether the path should continue to the next clockwise or counterclockwise edge of . The next edge along the convex chain at is the edge that minimizes the angle with the line through and the predecessor of in the stored direction.
When we arrive at an endpoint of a constraint, we can determine the location of the other endpoint, since they are connected in the visibility graph. Using this information, we can determine if this constraint is the one that caused the obstacle avoidance phase by checking if it blocks visibility of to . If this is the case, we also determine which of the two endpoints is closer to . If we are not yet at the endpoint closest to , we start the opposite endpoint phase, which is now simplified to following the edge in the visibility graph to the other endpoint of the constraint.
Theorem 10.
There exists a 1local memory routing algorithm for the visibility graph that reaches the destination in steps.
Proof.
We first note that locality follows from the fact that we only need to consider the neighbours of the current vertex in each of the steps. The memory bound follows from the fact that we need to store only the orientation of the cones in the message, as well as the starting vertex of the obstacle avoidance phase and the previous vertex along the obstacle avoidance path.
It remains to bound the number of steps. This algorithm has properties similar to those of the constrained routing algorithm. First, the routing phase always gets closer to the destination and thus cannot repeat vertices. This implies that Lemma 4 also holds for this routing algorithm. This in turn implies that a vertex can be the closest endpoint of an obstacle avoidance or opposite endpoint phase at most once. Next, since the obstacle avoidance path is convex, this implies that this path visits a subset of the vertices visited by the obstacle avoidance phase of the constrained routing algorithm. Finally, the opposite endpoint phase consists of at most a single edge, hence this phase too is a subpath of its constrained routing counterpart. Hence, when we compare the path of this routing algorithm to the constrained routing path that uses the same cone orientation, the routing path on the visibility graph is a subpath of the constrained routing path. Hence, it takes at most steps. ∎
5 Lower Bounds
In this section we provide a number of lower bounds on the competitive ratio of any deterministic local routing algorithm on the visibility graph compared to the shortest path in that graph. We give bounds both on the total length of the path, and on the number of steps taken. Our first two lower bounds are adaptations of the lower bound given by Bose et al. [3] in Theorem 1. Their focus of interest is the constrained graph, where they showed that no deterministic 1local routing algorithm on this graph can be competitive. In this section, we modify their construction for the visibility graph instead.
We start by giving an overview of their bound. For a given , the general idea is to initially construct a plane graph with a number of vertices quadratic in . This graph is grid shaped, with the source at the bottom and sink at the top (see Figure 13). We run the routing algorithm and see which path it follows on the large graph. Note that the graph is of quadratic size, but the shortest path uses a linear number of edges. Thus, competitive algorithms cannot afford to fully explore the graph. Once we know the path of the routing strategy, we trim the graph to one of linear size in , removing the portions of the graph that the routing algorithm did not explore (and in the process we insert a shorter path, see Figure 14). The key point of the construction is that the routing algorithm has the exact same information in both the original and the trimmed graph. Since the algorithm is deterministic, it will make the same choices and follow the same path in both cases.
We start by showing a lower bound on the competitive ratio with respect to the number of steps in the path (often referred to as the hop distance) as opposed to the length of the shortest path.
Lemma 11.
No deterministic 1local routing algorithm is competitive with respect to the number of steps of the shortest path on all pairs of vertices of the visibility graph on vertices, regardless of the amount of memory it is allowed to use.
Proof.
We need to show that the large and the trimmed graphs can both be realized as a visibility graph (instead of the constrained graph). The large graph consists of vertices in the unit grid in which the vertices in every other column are shifted half a unit in the coordinate, and then we scale the instance in the coordinate by a factor of (see exact details in [3]). Since the graph is a maximal plane graph (i.e., any additional edge would create a crossing), we can realize it as a visibility graph by making every edge a constraint.
Now we explain how to also make the trimmed graph. Consider any deterministic 1local routing algorithm and the path it follows from to . Let be the path consisting of the first steps of this routing path. We note that since the initial graph has rows, the shortest path must have at least steps (by following edges on the left or right boundary you can skip one every two rows) and thus is well defined.
Next, we modify the initial graph in exactly the same way as done by Bose et al.: for every vertex visited by , we mark that vertex, and all of its neighbours. We also mark , its neighbors, and all constraints whose two endpoints are marked vertices. The trimmed graph consists of the visibility graph consisting of marked vertices and constraints only. That is, we remove any nonmarked vertex, edge, and constraint, and “update” the visibility graph (see Figure 14).
Now we analyze the performance of the routing algorithm in the trimmed graph. Consider the columns of the construction. We say that a vertex touches a column if it lies in that column or has a neighbour in that column. Observe that every vertex of (other than and ) touches a constant number of columns. Since consists of steps, there exists a column that is touched at most times.
Regardless of , we observe that there is a path from to that consists of steps: follow the edge from to the column , and go upwards in that column until you reach the top row, and follow the edge to . There are only vertices in that column (i.e., the touched vertices). Between any two consecutive vertices we need a constant number of steps. Since any deterministic 1local routing algorithm would follow a path consisting of at least steps, we get the claimed lower bound on the competitive ratio with respect to the number of steps.
In order to complete the proof, we need to argue that the trimmed graph has linear size. Since consists of steps and every vertex other than and has a constant number of neighbors, we obtain a graph with vertices. However, note that the resulting graph could have quadratically many edges (see the left side of Figure 14 for example). We can reduce the number of edges to linear by adding additional constraints. The only requirement is that these constraints do not cross the edges used in the short path in column . For example, we can add an arbitrary plane graph where every edge is a constraint. ∎
The same construction can be used to show a lower bound on the competitiveness in terms of the length of the shortest path.
Lemma 12.
No deterministic 1local routing algorithm is competitive with respect to the length of the shortest path on all pairs of vertices of the visibility graph on vertices, regardless of the amount of memory it is allowed to use.
Proof.
The construction of both the large and the trimmed graphs is the same as in Lemma 11. The main change is that now the analysis is based on Euclidean length instead of number of steps. Recall that we scaled the instance by a factor of in the coordinates. This in particular implies that any nonvertical edge of the graph has length at least . Consider the path consisting of the first steps taken by the routing algorithm. If none of these edges is vertical, we obtain a lower bound of on the length of the routing path. If at least one edge is vertical, we observe that both of these vertical sides are at distance from , thus giving the same lower bound on the length of the path.
However, in the trimmed path we can find a shorter path. Consider the columns^{4}^{4}4Since we need to consider the Euclidean distance traveled to reach these columns later, we cannot consider all columns. at distance at most from . Since consists of vertices, there exists a column that is touched at most times.
For ease of exposition, first consider the case in which is touched only by and . This would give us a path of length at most : go from to the column and follow the upward edges to . Each of the horizontal steps has length and there are two of them in total, whereas the upward edges have unit length.
In the general case, recall that is touched at most times. For each vertex that is touched, we need to make a small detour via the next column, adding an extra cost of per detour, leading to a total path length of . Hence, the ratio between the two path lengths tends to , giving the lower bound. ∎
Next, we show that this lower bound can be improved in some cases. A common strategy for routing is to use the segment as a guide to reach the destination. Thus, even though one is allowed to use all edges of the graph, routing algorithms often only consider edges of the subgraph induced by the endpoints of edges that cross . For any such algorithm we can increase the lower bound to show that no competitive algorithm exists in terms of the shortest path distance.
Lemma 13.
No deterministic 1local routing algorithm, that considers only edges of the subgraph induced by the endpoints of edges that cross , is competitive with respect to the length of the shortest path on all pairs of vertices of the visibility graph on vertices, regardless of the amount of memory it is allowed to use.
Proof.
In order to obtain this lower bound, we modify the lower bound for routing on the constrained graph, presented by the authors [5] in Lemma 4.1. The proof of this claim only needs one graph (shown in Figure 15).
The construction is as follows (see Figure 16): start with columns of vertices each, aligned on a grid^{5}^{5}5For simplicity, we assumed that is a multiple of 3. This assumption can be removed by placing the 1 or 2 remaining points far enough away from the remainder of the point set.
. We add a constraint between every horizontal pair of vertices of two consecutive columns. We also add constraints from every vertex that is in an odd row of the first two columns to the vertex in the next column that is in either the next or previous row. Next, we shift every odd row by
units to the right (for some arbitrarily small but positive ). We add a vertex below the lowest row and a vertex above the highest row, centered the first two vertices on said row. Finally, we stretch the point set by a factor in the horizontal direction, for some large constant . When we construct the visibility graph on this point set, we get the graph shown in Figure 15.The shortest path in the visibility graph goes from to the leftmost column in one step, travels vertically upwards, and goes to in one step. Ignoring the terms that depend on , the first and last step have length less than whereas the vertical steps each have unit length, giving a path whose total length is less than .
However, if we restrict ourselves to the subgraph induced by the endpoints of edges that cross the path becomes significantly longer: we must now zigzag left and right in a path of steps, each time crossing the segment (see Figure 15). Ignoring the terms that depend on , each edge of this path has length at least , giving an overall lower bound of for the length of any restricted path. Hence, the ratio between the two bounds approaches , since
Since the shortest path in the subgraph is times the length of the shortest path in the visibility graph, no routing algorithm that considers only the subgraph can be competitive with respect to the length of the shortest path in the visibility graph. ∎
6 Conclusion
We presented the first deterministic 1local memory routing algorithms for the visibility graph that does not require the computation of a planar subgraph. Unfortunately, our algorithms do not give any guarantees on the length of the routing path, only on the number of edges used. A natural improvement would be the design of a routing strategy that is competitive with respect to the length of the shortest path.
Our lower bounds show that competitiveness is not possible (and that it will be even hard to obtain competitiveness). The same lower bounds also give rise to the following questions: Can we design an competitive deterministic 1local routing strategy? Can we actually beat these lower bounds by introducing randomness into the routing algorithms?
Acknowledgements
Part of this work was performed at the Sendai Workshop on Discrete and Computational Geometry and the Shonan Meeting 106  Geometric Graphs: Theory and Applications. We thank the participants of both workshops for providing a fun and stimulating research environment.
References
 [1] Prosenjit Bose, JeanLou De Carufel, Pat Morin, André van Renssen, and Sander Verdonschot. Towards tight bounds on thetagraphs: More is not always better. Theoretical Computer Science, 616:70–93, 2016.
 [2] Prosenjit Bose, Rolf Fagerberg, André van Renssen, and Sander Verdonschot. On plane constrained boundeddegree spanners. In Proceedings of the 10th Latin American Symposium on Theoretical Informatics (LATIN 2012), volume 7256 of Lecture Notes in Computer Science, pages 85–96, 2012.
 [3] Prosenjit Bose, Rolf Fagerberg, André van Renssen, and Sander Verdonschot. Competitive local routing with constraints. Journal of Computational Geometry (JoCG), 8(1):125–152, 2017.
 [4] Prosenjit Bose and J. Mark Keil. On the stretch factor of the constrained Delaunay triangulation. In Proceedings of the 3rd International Symposium on Voronoi Diagrams in Science and Engineering (ISVD 2006), pages 25–31, 2006.
 [5] Prosenjit Bose, Matias Korman, André van Renssen, and Sander Verdonschot. Constrained routing between nonvisible vertices. In Proceedings of the 23rd Annual International Computing and Combinatorics Conference (COCOON 2017), volume 10392 of Lecture Notes in Computer Science, pages 62–74, 2017.
 [6] Prosenjit Bose, Matias Korman, André van Renssen, and Sander Verdonschot. Routing on the visibility graph. In Proceedings of the 28th International Symposium on Algorithms and Computation (ISAAC 2017), volume 92 of Leibniz International Proceedings in Informatics, pages 18:1–18:12, 2017.
 [7] Prosenjit Bose and André van Renssen. Upper bounds on the spanning ratio of constrained thetagraphs. In Proceedings of the 11th Latin American Symposium on Theoretical Informatics (LATIN 2014), volume 8392 of Lecture Notes in Computer Science, pages 108–119, 2014.

[8]
Ken Clarkson.
Approximation algorithms for shortest path motion planning.
In
Proceedings of the 19th Annual ACM Symposium on Theory of Computing (STOC 1987)
, pages 56–65, 1987.  [9] Gautam Das. The visibility graph contains a boundeddegree spanner. In Proceedings of the 9th Canadian Conference on Computational Geometry (CCCG 1997), pages 70–75, 1997.
 [10] J. Mark Keil and Carl A. Gutwin. Classes of graphs which approximate the complete Euclidean graph. Discrete & Computational Geometry, 7(1):13–28, 1992.
 [11] Sudip Misra, Subhas Chandra Misra, and Isaac Woungang. Guide to Wireless Sensor Networks. Springer, 2009.
 [12] Harald Räcke. Survey on oblivious routing strategies. In Mathematical Theory and Computational Practice, volume 5635 of Lecture Notes in Computer Science, pages 419–429, 2009.