Certification of Compact Low-Stretch Routing Schemes

TL;DR

This paper introduces a certification mechanism for verifying the correctness of low-stretch routing schemes in networks, ensuring local detection of routing table modifications with minimal additional memory overhead.

Contribution

It presents a simple certification method for verifying stretch-3 routing schemes and proposes a new name-independent routing scheme with efficient local verification.

Findings

Local verification of stretch-3 routing schemes is possible with $ ilde{O}( oot{n})$ bits certificates.

A new name-independent routing scheme with stretch 3 (handshaking) and 5 (no handshaking) is introduced.

Certificates of size $ ilde{O}( oot{n})$ bits suffice for local verification.

Abstract

On the one hand, the correctness of routing protocols in networks is an issue of utmost importance for guaranteeing the delivery of messages from any source to any target. On the other hand, a large collection of routing schemes have been proposed during the last two decades, with the objective of transmitting messages along short routes, while keeping the routing tables small. Regrettably, all these schemes share the property that an adversary may modify the content of the routing tables with the objective of, e.g., blocking the delivery of messages between some pairs of nodes, without being detected by any node. In this paper, we present a simple certification mechanism which enables the nodes to locally detect any alteration of their routing tables. In particular, we show how to locally verify the stretch-3 routing scheme by Thorup and Zwick [SPAA 2001] by adding certificates of $\widetilde{O}(\sqrt{n})$ bits at each node in $n$-node networks, that is, by keeping the memory size of the same order of magnitude as the original routing tables. We also propose a new name-independent routing scheme using routing tables of size $\widetilde{O}(\sqrt{n})$ bits. This new routing scheme can be locally verified using certificates on $\widetilde{O}(\sqrt{n})$ bits. Its stretch is3 if using handshaking, and 5 otherwise.

Tables

Table 1. Table 1: Summary of our results compared to previous work. All the listed routing schemes have space complexity of O ~ ​ ( n ) ~ 𝑂 𝑛 \widetilde{O}(\sqrt{n}) bits. Our verification algorithms for these schemes use certificates on O ~ ​ ( n ) ~ 𝑂 𝑛 \widetilde{O}(\sqrt{n}) bits.

		name
scheme	stretch	independent	verifiable	comment
[23]	3	no	yes	–
[3]	5	yes	?	–
[2]	3	yes	?	–
this paper	5	yes	yes	–
this paper	3	yes	yes	handshaking

Equations

$$\delta(u,v)=\mbox{weighted distance between $u$ and $v$}.$$

$$\mbox{\sf table}(u_{i})\big{(}\mbox{\sf name}(t)\big{)}=\mbox{\sf port}_{u_{i}}(\{u_{i},u_{i+1}\})$$

$$\text{mbox}\mathsf{certificate}:V(G)\to \{0,1{\}}^{\ast }$$

$$\text{mbox}\mathsf{bunch}(v)=\{u\in V:\delta (v,u)<\delta (l_v,v)\}.$$

$$\text{mbox}\mathsf{cluster}(v)=\{u\in V:\delta (v,u)<\delta (l_u,u)\}.$$

$$u\in \text{mbox}\mathsf{cluster}(v)⟺v\in \text{mbox}\mathsf{bunch}(u).$$

$$\text{mbox}\mathsf{next}(v,t)$$

$$\text{mbox}\mathsf{name}(t)=(t,l_t,\text{mbox}\mathsf{next}(l_t,t)).$$

$$d(v,l)=\text{mbox}\mathrm{length}(\{v,u\})+d(u,l),$$

$$d(v,l)\le \text{mbox}\mathrm{length}(\{v,u\})+d(u,l),$$

$$d(v,t)=\text{mbox}\mathrm{length}(\{v,u\})+d(u,t),$$

$$d(v,t)\le \text{mbox}\mathrm{length}(\{v,u\})+d(u,t),$$

$$\text{mbox}\mathrm{length}\{(v,u)\}+d(u,t)\ge d(t,l_t).$$

$$C(v)\subseteq \text{mbox}\mathsf{cluster}(v).$$

$$\text{mbox}\mathsf{cluster}(v)=\{t\in V|\delta (v,t)<\delta (l_t,t)\}$$

$$\delta (v^{\prime \prime },t)=\text{mbox}\mathrm{length}(\{(v^{\prime \prime },v^{\prime }\})+\delta (v^{\prime },t)$$

$$\text{mbox}\mathrm{length}(\{(v^{\prime \prime },v^{\prime }\})+\delta (v^{\prime },t)<\delta (l_t,t).$$

$$\big{(}\mbox{\sf name}_{T(l_{u})}(l_{u}),\mbox{\sf name}_{T(l_{u})}(u)\big{)}.$$

$$\big{(}\mbox{\sf name}_{T(l_{u})}(l_{u}),\mbox{\sf name}_{T(l_{u})}(u)\big{)}$$

$$\big{(}\mbox{\sf name}_{T(v)}(w),x,\mbox{\sf port}_{x}(\{x,y\}),\mbox{\sf name}_{T(y)}(u)\big{)}$$

$$\big{(}\mbox{\sf name}_{T(u)}(s),x,port(x,y),\mbox{\sf name}_{T(y)}(t)\big{)},$$

$$\big{(}\mbox{\sf name}_{T(l_{t})}(l_{t}),\mbox{\sf name}_{T(l_{t})}(t)\big{)}.$$

$$\ell$$

$$l_v=\text{mbox}{\mathrm{argmin}}_{l\in L}\delta (v,l)$$

$$\text{mbox}\mathsf{next}(v,t)$$

$$\mbox{\sf Dir}_{c}=\{\big{(}v,l_{v},\mbox{\sf next}(l_{v},v)\big{)}:\mbox{\sl color}(v)=c\}$$

$$\ell =\delta (s,l_t)+\delta (l_t,t).$$

$$\ell \le \delta (s,t)+2\delta (l_t,t).$$

$$\ell \le 3\delta (s,t).$$

$$\ell$$

Full text

In this paper, we present a simple certification mechanism which enables the nodes to locally detect any alteration of their routing tables. In particular, we show how to locally verify the stretch-3 routing scheme by Thorup and Zwick [SPAA 2001] by adding certificates of $\widetilde{O}(\sqrt{n})$ bits at each node in $n$-node networks, that is, by keeping the memory size of the same order of magnitude as the original routing tables. We also propose a new name-independent routing scheme using routing tables of size $\widetilde{O}(\sqrt{n})$ bits. This new routing scheme can be locally verified using certificates on $\widetilde{O}(\sqrt{n})$ bits. Its stretch is 3 if using handshaking, and 5 otherwise.

1 Introduction

1.1 Context

A routing scheme is a mechanism enabling to deliver messages from any source to any target in a network. The latter is typically modeled as an undirected connected weighted graph $G=(V,E)$ where $V$ models the set of routers and $E$ models the set of communication links between routers. All edges incident to a degree-$d$ node are labeled from $1$ to $d$, in an arbitrary manner, and the label at a node $u$ of an incident edge $e$ is called the port number of edge $e$ at $u$. A routing scheme consists of a way of assigning a routing table to every node of the given network. These tables should contain enough information so that, for every target node $t$, each node is able to compute the port number of the incident edge through which it should forward a message of destination $t$. The routing tables must collectively guarantee that every message of any source $s$ and any target $t$ will eventually be delivered to $t$.

Two scenarios are generally considered in the literature. One scenario allows the routing scheme to assign names to the nodes, and each target is then identified by its given name. The other, called name independent, is assuming that fixed names are given a priori (typically, a name is restricted to be the identity of a node), and the scheme cannot take benefit of naming nodes for facilitating routing.

Among many criteria for evaluating the quality of routing schemes, including, e.g., the time complexity for constructing the routing tables, the two main parameters characterizing a routing scheme are the size of its routing tables, and the stretch. The stretch of a routing scheme is the maximum, taken over all pairs of source-target nodes, of the ratio between the length of the route generated by the scheme from the source to the target, and the length of a shortest path between these two nodes. During the last two decades, there has been an enormous effort to design compact routing scheme (i.e., schemes using small tables) of low stretch (i.e., with stretch upper bounded by a constant) – see, e.g., [1, 2, 3, 4, 11, 16, 20, 21, 23]. A breakthrough was achieved in [23] where almost tight tradeoffs between size and stretch were explicitly demonstrated. In particular, [23] showed how to design a routing scheme with tables of size $\widetilde{O}(\sqrt{n})$ bits and stretch 3, in any network111The notations $\widetilde{O}$ and $\widetilde{\Omega}$ ignore polylogarithmic factors..

All the aforementioned routing schemes share the property that nodes do not have the capability to realize that the routing tables have been modified (either involuntarily or by an attacker). That is, a group of nodes may be provided with routing tables which look consistent with a desired routing scheme, but which do not achieve the desired performances of that scheme (e.g., large stretch, presence of loops, etc.). Indeed, the nodes are not provided with sufficient information to detect such an issue locally, that is, by having each node inspecting only the network structure and the tables assigned to nodes in its vicinity.

1.2 Objective

The objective of this paper is, given a routing scheme, to design a mechanism enabling each node to locally detect the presence of falsified routing tables, in the following sense. If one or more tables are erroneous, then at least one node must be able to detect that error by running a verification algorithm exchanging messages only between neighboring nodes.

Our mechanism for locally verifying the correctness of routing tables is inspired from proof-labeling schemes [19]. It is indeed based on assigning to each node a certificate, together with its routing table, and designing a distributed verification algorithm that checks the consistency of these certificates and tables by having each node inspecting only its certificate and its routing table, and the certificate and routing table of each of its neighbors. The set of certificates assigned to the nodes and the verification algorithm running at all nodes in parallel must satisfy that: (1) if all tables are correctly set, then, with some appropriate certificates, all nodes accept, and (2) if one or more tables are incorrectly set, then, for every assignment of the certificates, at least one node must reject. The second condition guarantees that the verification algorithm cannot be cheated: if the tables are incorrect, there are no ways of assigning the certificates such that all nodes accept.

Rephrasing the objective of the paper, our goal is to assign certificates to nodes, of size not exceeding the size of the routing tables, enabling the nodes to collectively verify the correctness of the routing tables, by having each node interacting with its neighbors only.

1.3 Our Results

We show how to locally verify the stretch-3 size-$\widetilde{O}(\sqrt{n})$ routing scheme by Thorup and Zwick [23]. Our certification mechanism uses certificates of $\widetilde{O}(\sqrt{n})$ bits at each node, that is, these certificates have size of the same order of magnitude as the original routing tables. Hence, verifying the scheme in [23] can be done without modifying the scheme, and without increasing the memory space consumed by that scheme. We also show that the same holds for the whole hierarchy of routing schemes proposed in [23] for providing a tradeoff between size and stretch.

The situation appears to be radically different for name-independent routing schemes. The stretch-$3$ name-independent routing scheme by Abraham et al. [2] also uses tables of size $\widetilde{O}(\sqrt{n})$ bits. However, each table includes references to far away nodes, whose validity does not appear to be locally verifiable using certificates of reasonable size. On the other hand, a simplified version of the scheme in [2] can be verified locally with certificates of size $\widetilde{O}(\sqrt{n})$ bits, but its stretch becomes at least 7. Therefore, we propose a new name-independent routing scheme, with tables of size $\widetilde{O}(\sqrt{n})$ bits that can be verified using certificates on $\widetilde{O}(\sqrt{n})$ bits as well. This new routing scheme has stretch at most 5, and the stretch can even be reduced to 3 using handshaking222The handshaking mechanism is similar to DNS lookup in TCP/IP. It allows querying some node(s) for getting additional information about the route to the target.. The routing scheme of Arias et al. [3] has also stretch 5, but it does not appear to be locally verifiable with certificates of reasonable size, and using handshaking does not enable to reduce the stretch.

All our results are summarized in Table 1.

1.4 Related Work

The design of compact routing tables, and the explicit identification of tradeoffs between the table size and the routes length was initiated thirty years ago, with the seminal work in [21] and [20]. Since then, a large amount of papers were published on this topic, aiming at refining these tradeoffs, and at improving different aspects of the routing schemes, including routing in specific classes of graphs (see [15, 17]). In particular, routing schemes were designed for trees in [11, 23], with space complexity $O(\log^{2}n/\log\log n)$ bits333The space complexity can be reduced to $O(\log n)$ if the designer of the routing scheme is also allowed to assign the port numbers to the nodes.. This space complexity was shown to be optimal in [12].

It was proved [18] that, in $n$-node networks, any shortest path routing scheme requires tables of size $\widetilde{\Omega}(n)$ bits. The aforementioned routing scheme in [23] with stretch $3$ and space complexity $\widetilde{O}(\sqrt{n})$ bits was shown to be optimal in [16], in the following sense: no routing scheme with space complexity $o(n)$ bits can achieve a stretch $s<3$, and, assuming the correctness of a conjecture by Erdős regarding a tradeoff between girth and edge density in graphs, every routing scheme with stretch $s<5$ has space complexity $\Omega(\sqrt{n})$ bits. On the positive side, [23] tightens the size-stretch tradeoff of [20] by showing that, for every $k\geq 2$, there exists a routing scheme with stretch $4k-5$ and space complexity $\widetilde{O}(n^{1/k})$ bits. (The stretch can be reduced to $2k-1$ using handshaking). Recently, [7] showed that, for $k\geq 4$, a stretch $s=\alpha\,k$ with $\alpha<4$ can be achieved using routing tables of size $\widetilde{O}(n^{1/k})$.

The distinction between name-independent routing schemes, and routing schemes assigning specific names to the nodes was first made in [4]. Then, [5] presented techniques for designing name-independent routing schemes with constant stretch and space complexity $o(n)$ bits. Almost 15 years after, [3] described a name-independent routing scheme with stretch $5$ and space complexity $\widetilde{O}(\sqrt{n})$ bits. This was further improved in [2] thanks to a name-independent routing scheme with stretch $3$ and space complexity $\widetilde{O}(\sqrt{n})$ bits. A couple of years later, [1] showed that there are tradeoffs between stretch and space complexity for name-independent routing schemes as well. Specifically, [1] showed that, for any $k\geq 1$, there exists a name-independent routing scheme with space complexity $\widetilde{O}(n^{1/k})$ bits and stretch $O(k)$.

The certification mechanism used in this paper is based on the notion of proof-labeling scheme introduced in [19] in which an oracle, called prover, assigns certificates to the nodes, and a distributed algorithm, called verifier, checks that this certificates collectively form a proof that the global state of the network is legal with respect to a given boolean network predicate. Proof-labeling schemes have been widely used in literature. For example, [22] uses them to verify spanning trees in networks. This result has been extended in [10], where proof-labeling schemes are used to verify spanning trees in evolving networks that are evolving with time. Variants of proof-labeling schemes have been considered in, e.g., [6, 13], and [14]. More generally, see [9] for a survey of distributed decision.

1.5 Structure of the Paper

In Section 2, we recall the main concepts related to the design of routing schemes, and those related to distributed verification. Section 3 is dedicated to routing schemes assigning names to nodes: we briefly recall the main features of the scheme in [23], and then show how to locally verify that scheme using small certificates. In Section 4, we show that the name-independent routing scheme in [2] is unlikely to be locally verifiable with small certificates. Therefore, Section 5 presents a new name-independent routing scheme, that is shown to be locally verifiable with small certificates. This new scheme has space-complexity $\widetilde{O}(\sqrt{n})$ bits, but stretch 5. Section 6 shows that the stretch-5 scheme in [3] is, like the one in [2], unlikely to be locally verifiable with small certificates. Finally, Section 8 concludes the paper with pointers to research directions worth to be investigated.

2 Definitions

2.1 Routing Schemes

Let $\cal{F}$ be a family of edge-weighted graphs with edges labeled at each node by distinct port numbers from 1 to the degree of the node. The weights are all positive, and the weight of edge $e$ represents its length. It is thus denoted by $\mbox{\rm length}(e)$. The nodes are given distinct identities stored on $O(\log n)$ bits. For the sake of simplifying notations, we do not make a distinction between a node $v$ and its identity, also denoted by $v$. Given two nodes $u,v$, we denote by

[TABLE]

Given an edge $e$ of extremity $u$, the port number of $e$ at $u$ is denoted by $\mbox{\sf port}_{u}(e)$.

A routing scheme for $\cal{F}$ is a mechanism assigning a name, $\mbox{\sf name}(u)$, and a routing table, $\mbox{\sf table}(u)$, to every node $u$ of every graph $G\in\cal{F}$ such that, for any pair $(s,t)$ of nodes of any $G\in\cal{F}$, there exists a path $u_{0},u_{1},\dots,u_{k}$ from $s$ to $t$ in $G$ with $u_{0}=s$, $u_{k}=t$, and

[TABLE]

for every $i=0,\dots,k-1$. That is, every intermediate node $u_{i}$, $0\leq i<k$, can determine on which of its ports the message has to be forwarded, based solely on its routing table, and on the name of the target. In Eq. 1, each table is viewed as a function taking names as arguments, and returning port numbers. The path $u_{0},u_{1},\dots,u_{k}$ is then called the route generated by the scheme from $s$ to $t$. It is worth pointing out the following observations.

$\bullet$ Name-independent routing schemes are restricted to use names that are fixed a priori, that is, the name of a node is its identity, i.e., $\mbox{\sf name}(v)=v$ for every node $v$. Instead, name-dependent routing schemes allow names to be set for facilitating routing, and names are typically just bounded to be storable on a polylogarithmic number of bits.

$\bullet$ The header of a message is the part of that message containing all information enabling its routing throughout the network. The header of a message with destination $t$ is typically $\mbox{\sf name}(t)$. However, some routing schemes ask for message headers that can be modified. This holds for both name-dependent schemes (like, e.g., [23]) and name-independent schemes (like, e.g., [2]). The typical scenario requiring modifiable headers is when a message is routed from source $s$ to target $t$ as follows. From $\mbox{\sf name}(t)$ and $\mbox{\sf table}(s)$, node $s$ can derive the existence of some node $v$ containing additional information about how to reach $t$. Then the message is first routed from $s$ to $v$, and then from $v$ to $t$. Distinguishing these two distinct parts of the routes from $s$ to $t$ often requires to use different headers. In case of modifiable headers, Eq. (1) should be tuned accordingly as the argument of routing is not necessarily just a name, but a header.

$\bullet$ Some routing schemes may use a mechanism called handshaking, which is an abstraction of mechanisms such as Domain Name System (DNS) enabling to recover an IP address from its domain name. Let us consider the aforementioned scenario where a routing scheme routes a message from $s$ to $t$ via an intermediate node $v$ identified by $s$ from $\mbox{\sf name}(t)$ and $\mbox{\sf table}(s)$. One can then enhance the routing scheme by a handshaking mechanism, enabling $s$ to query $v$ directly, and to recover the information stored at $v$ about $t$ at no cost. Then $s$ can route the message directly from $s$ to $t$, avoiding the detour to $v$. Handshaking is used in [23] to reduce the stretch of routing schemes with space complexity $\widetilde{O}(n^{1/k})$ bits from $4k-5$ to $2k-1$, for every $k>2$.

The size of a routing scheme is the maximum, taken over all nodes $u$ of all graphs in $\cal{F}$, of the memory space required to encode the function $\mbox{\sf table}(u)$ at node $u$.

The stretch of a routing scheme is the maximum, taken over all pairs $(s,t)$ of nodes in all graphs $G\in\cal{F}$, of the ratio of the length of the route from $s$ to $t$ (i.e., the sum of the edge weights along that route) with the weighted distance between $s$ and $t$ in $G$.

2.2 Distributed Verification

Given a graph $G$, a certificate function for $G$ is a function

[TABLE]

assigning a certificate, $\mbox{\sf certificate}(u)$, to every node $u\in V(G)$. A verification algorithm is a distributed algorithm running concurrently at all nodes in parallel. At every node $u\in V(G)$ of every graph $G\in\cal{F}$, the algorithm takes as input $\mbox{\sf certificate}(u)$ and $\mbox{\sf table}(u)$ assigned to node $u$, as well as the collection of pairs $(\mbox{\sf table}(v),\mbox{\sf certificate}(v))$ assigned to all neighbors $v$ of $u$, and outputs accept or reject.

Definition 1

A routing scheme for $\cal{F}$ is verifiable if there exists a verification algorithm verif such that, for every $G\in\cal{F}$,

• •

if the tables given to all nodes of $G$ are the ones specified by the routing scheme, then there exists a certificate function for $G$ such that the verification algorithm verif outputs accept at all nodes;

• •

if some tables given to some nodes of $G$ differ from the ones specified by the routing scheme, then, for every certificate function for $G$, the verification algorithm verif outputs reject in at least one node.

The second bullet guarantees that if an adversary modifies some routing tables, or even just a single bit of a single table, then there are no ways it can also modify some, or even all certificates so that to force all nodes to accept: at least one node will detect the change. Of course, this node does not need to be the same for different modifications of the routing tables, or for different certificates.

Remark.

The above definition is the classical definition of proof-labeling scheme applied to verifying routing schemes. In particular, it may well be the case that a correct labeling scheme be rejected if the certificates have not been set appropriately, just like a spanning tree $T$ will be rejected by a proof-labeling scheme for spanning trees if the certificates have been set for another spanning tree $T^{\prime}\neq T$.

3 Name-dependent routing scheme

In this section, we show how to verify the stretch-$3$ routing scheme by Thorup and Zwick in [23]. This scheme uses tables of $\widetilde{O}(\sqrt{n})$ bits of memory at each node. We show the following:

Theorem 2

The stretch-$3$ routing scheme by Thorup and Zwick in [23] can be locally verified using certificates of size $\widetilde{O}(\sqrt{n})$ bits.

Before proving the theorem, we first recall the general structure of the routing scheme in [23].

3.1 The routing scheme

The routing scheme assigns names and tables to the nodes of every $G=(V,E)$ as follows.

3.1.1 Landmarks, Bunch and Clusters

The routing scheme in [23] uses the notion of landmarks (a.k.a. centers in the “older” terminology of [23]). These landmarks form a subset $L\subseteq V$ of nodes. For $v\in V$, let $l_{v}$ denote the landmark closest to $v$ in $G$. For every $v\in V$, the bunch of $v$ with respect to the set $L$ is defined as follows.

[TABLE]

The routing scheme in [23] also uses the notion of cluster. For every node $v\in V$,

[TABLE]

As a consequence, for every $u,v\in V$, we have

[TABLE]

Note that since, for every $v\in V$, and every $l\in L$, we have $l\notin\mbox{\sf bunch}(v)$, it follows that $\mbox{\sf cluster}(l)=\emptyset$ for every $l\in L$. By construction of the bunches and the clusters, it also holds that, for every $v\in V$, $\mbox{\sf cluster}(v)\cap L=\emptyset$. Also, clusters satisfy the following property.

Lemma 3** ([23])**

If $u\in\mbox{\sf cluster}(v)$ then, for every node $w$ on a shortest path between $u$ and $v$, we have $u\in\mbox{\sf cluster}(w)$

In [23], the landmarks are chosen by an algorithm that samples them uniformly at random in $V$ until the following holds: for every node $v$, $|\mbox{\sf cluster}(v)|<4\sqrt{n}$. It is proved that this algorithm returns, w.h.p., a set of landmarks of size at most $2\log(n)\sqrt{n}$.

3.1.2 Names and tables

For every two nodes $v$ and $t$, let

[TABLE]

be the port number of an edge incident to $v$ on a shortest path between $v$ and $t$. Each node $t\in V$ is assigned a $3\lceil\log(n)\rceil$-bit name as follows:

[TABLE]

Each node $v\in V$ then stores the following information in its routing table, $\mbox{\sf table}(v)$:

• •

the identities of all the landmarks $l\in L$;

• •

the identities of all nodes $t\in\mbox{\sf cluster}(v)$;

• •

the set $\{\mbox{\sf next}(v,t):t\in L\cup\mbox{\sf cluster}(v)\}$.

All these information can be stored using $\widetilde{O}(\sqrt{n})$ bits.

3.1.3 Routing

Note that, by Lemma 3, any message from a node $v$ to a node in $\mbox{\sf cluster}(v)$ reaches its target along a shortest path. The same holds for landmarks since every node is given information about how to reach every landmark. In general, let us assume that $v$ wants to send a message to some node $t$ with label $(t,l_{t},\mbox{\sf next}(l_{t},t))$ that is neither a landmark nor belongs to $\mbox{\sf cluster}(v)$. In this case, $v$ extracts the landmark $l_{t}$ nearest to $t$ from $t$’s name (note here the impact of allowing the scheme to assign specific names to nodes), and forwards the message through the port on a shortest path towards $l_{t}$ using the information $v$ has in its table. Upon reception of the message, $l_{t}$ forwards the message towards $t$ on a shortest path using $\mbox{\sf next}(l_{t},t)$ (this information can also be extracted from the name of $t$), to reach a node $z\in\mbox{\sf bunch}(t)$. At last, since $z\in\mbox{\sf bunch}(t)$, we have $t\in\mbox{\sf cluster}(z)$, which means that $z$ can route to $t$ via a shortest path using the information available in its table. By Lemma 3, this also holds for every node along a shortest path between $z$ and $t$. Using symmetry, and triangle inequality, [23] shows that this routing scheme guarantees stretch 3.

3.2 Proof of Theorem 2

In order to enable local verification of the stretch-3 routing scheme in [23], a certificate of size $\widetilde{O}(\sqrt{n})$ bits is given to each node. Let $G=(V,E)$ be an undirected graph with positive weights assigned to its edges, and a correct assignment of the routing tables to the nodes according to the specifications of [23] as summarized in Section 3.1. Then each node $v\in V$ is assigned a certificate composed of:

• •

the distance between $v$ and every landmark in $L$;

• •

the distance between $v$ and every node in $\mbox{\sf cluster}(v)$;

• •

the set $\{\delta(t,l_{t}):t\in\mbox{\sf cluster}(v)\}$.

As claimed, all these information can be stored using $\widetilde{O}(\sqrt{n})$ bits of memory.

We assume, without loss of generality, that all nodes know $n$ (verifying the value of $n$ is easy using a proof-labeling scheme with $O(\log n)$-bit certificates [19]). The verification of the routing scheme then proceeds as follows. We describe the verification algorithm verif running at node $v\in V$. This verification goes in a sequence of steps. At each step, either $v$ outputs reject and stops, or it goes to the next step.

We denote by $L(v)$, $C(v)$, and $\{N(v,t):t\in L(v)\cup C(v)\}$ the content of the routing table of $v$. These entries are supposed to be the set of landmarks, the cluster of $v$, and the set of next-pointers given to $v$, respectively. We also denote by $d$ the distance given in the certificates. That is, node $v$ is given a set $\{d(v,t):t\in L(v)\cup C(v)\}$ and a set $\{d(t,l_{t}):t\in C(v)\}$ where $l_{t}$ is supposed to be the node in $L(v)$ closest to $t\in C(v)$. Of course, if a node does not have a table and a certificate of these forms, then it outputs reject. So, we assume that all tables and certificates have the above formats. The algorithm proceeds as follows at every node $v$. Node $v$ checks that

the information in its table satisfy $|C(v)|\leq 4\sqrt{n}$ and $|L(v)|\leq 2\log n\sqrt{n}$ bits; 2. 2.

it has the same set of landmarks as its neighbors; 3. 3.

for every $l\in L(v)$, there exists a neighbor $u$ of $v$ satisfying

[TABLE]

and all other neighbors satisfy

[TABLE]

with $N(v,l)$ pointing to a neighbor $u$ satisfying $d(v,l)=\mbox{\rm length}(\{v,u\})+d(u,l)$; 4. 4.

if $v\in L(v)$ then $C(v)=\emptyset$; 5. 5.

$v\in C(v)$ and, for every node $t\in C(v)$, there exists a neighbor $u$ of $v$ satisfying $t\in C(u)$ with

[TABLE]

and every neighbor $u$ of $v$ with $t\in C(u)$ satisfies

[TABLE]

with $N(v,t)$ pointing to a neighbor $u$ satisfying $t\in C(u)$ and $d(v,t)=\mbox{\rm length}(\{v,u\})+d(u,t)$; 6. 6.

for every node $t\in C(v)$, for every neighbor $u$ of $v$ satisfying $t\in C(u)$, the distance $d(t,l_{t})$ in the certificate of $u$ is equal to the distance $d(t,l_{t})$ in the certificate of $v$; 7. 7.

for every $t\in C(v)$, it holds that $d(v,t)<d(t,l_{t})$; 8. 8.

for every neighbor $u$, and every $t\in\mbox{\sf cluster}(u)\setminus\mbox{\sf cluster}(v)$, it holds that

[TABLE]

If $v$ passes all the above tests, then $v$ outputs accept, else it outputs reject.

We now establish the correctness of this local verification algorithm, that is, we show that it satisfies the specification stated in Section 2.2. First, by construction, if all tables are set according to [23], that is, if, for every node $v$, $L(v)=L$, $C(v)=\mbox{\sf cluster}(v)$ and $N(v,t)=\mbox{\sf next}(v,t)$ for all $t\in L\cup\mbox{\sf cluster}(v)$, then every node running the verification algorithm with the appropriate certificate $\{\delta(v,t):t\in L\cup\mbox{\sf cluster}(v)\}\cup\{\delta(t,l_{t}):t\in\mbox{\sf cluster}(v)\}$ where $l_{t}$ is the node in $L$ closest to $t\in\mbox{\sf cluster}(v)$, will face no inconsistencies with its neighbors, i.e., all the above tests are passed, leading every node to accept, as desired.

So, it remains to show that if some tables are not what they should be according to [23], then, no matter the certificates assigned to the nodes, at least one node will fail one of the tests.

If all nodes output accept, then, by Step 1, all routing tables are of the appropriate size. Also, by Step 2, the set $L$ of landmarks given to the nodes is the same for all nodes, as otherwise there will be two neighbors that would have different sets. Moreover, by Step 3, we get that, at every node $v$, the distances of this node to the landmarks, as stored in its certificate, are correct, from which we infer that $N(v,l)$ is appropriately set in the table of $v$, that is $N(v,l)=\mbox{\sf next}(v,l)$ for every $l\in L$. Hence, if all the tests in Steps 1-3 are passed, all the data referring to $L$ in both the tables and the certificates are consistent. In particular, every node $v$ knows the landmark $l_{v}$ which is closest to it, and its distance $\delta(v,l_{v})$.

We now show that if all these tests as well as the remaining tests are passed, then the clusters in the tables are correct, w.r.t. $L$, as well as the next-pointers. We first show that, if all tests are passed, then, for every node $v\in V$,

[TABLE]

By Step 4, this latter equality holds for every landmark $v$. By Step 5, we get that, at every node $v$, the distance of this node to every node $t\in C(u)$, as stored in its certificate, are correct, from which we infer that $N(v,t)$ is appropriately set in the table of $v$, that is $N(v,t)=\mbox{\sf next}(v,t)$ for every $t\in C(v)$. By Step 6, we get that, for every $t\in C(v)$, we do have $d(l_{t},t)=\delta(l_{t},t)$. Indeed, this equality will be checked by all nodes on a shortest path between $v$ and $t$ (whose existence is guaranteed by Step 5), and $t$ has the right distance $\delta(t,l_{t})$ in its certificate by Step 3. Recall that

[TABLE]

where $l_{t}$ is the landmark closest to $t$. Step 7 precisely checks that inequality.

It remains to show that there are no nodes in $\mbox{\sf cluster}(v)$ that are not in $C(v)$. Assume that there exists $t\in\mbox{\sf cluster}(v)\setminus C(v)$, and let $P$ be a shortest path between $v$ and $t$. Let $v^{\prime}$ be the closest node to $v$ on $P$ such that $t\in C(v^{\prime})\subseteq\mbox{\sf cluster}(v^{\prime})$. Note that such a node $v^{\prime}$ exists as $t\in C(t)$. Let $v^{\prime\prime}$ be the node just before $v^{\prime}$ on $P$ traversed from $v$ to $t$. By Lemma 3, since $t\in\mbox{\sf cluster}(v)$, we also have $t\in\mbox{\sf cluster}(v^{\prime\prime})$. We have $t\in\mbox{\sf cluster}(v^{\prime\prime})\setminus C(v^{\prime\prime})$. Therefore $\delta(v^{\prime\prime},t)<\delta(l_{t},t)$. Now,

[TABLE]

because $P$ is a shortest path between $v^{\prime\prime}$ and $t$ passing through $v^{\prime}$. So,

[TABLE]

Step 8 guarantees that it is not the case. Therefore, there are no nodes in $\mbox{\sf cluster}(v)\setminus C(v)$. It follows that $\mbox{\sf cluster}(v)=C(v)$ for all nodes $v$. This completes the proof of Theorem 2.

4 Name-independent Routing Scheme

The purpose of this section is twofold. First, it serves as recalling basic notions that will be helpful for the design of our new name-independent routing scheme. Second, it is used to show why the known name-independent routing scheme in [2] appears to be difficult, and perhaps even impossible to verify locally.

4.1 The Routing Scheme of [2]

The stretch-3 name-independent routing scheme of [2] uses $\widetilde{O}(\sqrt{n})$ space at each node. We provide a high level description of that scheme. Recall that, in name-independent routing, a target node is referred only by its identity. That is, $\mbox{\sf name}(t)$ is the identity of $t$, i.e., $\mbox{\sf name}(t)=t$.

Let $G=(V,E)$. For every node $v\in V$, the vicinity ball of $v$, denoted by $\mbox{\sf ball}(v)$, is the set of the $4\lceil\alpha\log(n)\sqrt{n}\rceil$ closest nodes to $v$, for a large enough constant $\alpha>0$, where ties are broken using the order of node identities. By this definition, if $u\in\mbox{\sf ball}(v)$ and $w$ is on a shortest path between $v$ and $u$, then $u\in\mbox{\sf ball}(w)$.

4.1.1 Color-Sets

In [2], the nodes are partitioned into sets $C_{1},\dots C_{\sqrt{n}}$, called color-sets, and, for $i=1,\dots,\sqrt{n}$, the nodes in color-set $C_{i}$ are assigned the same color $i$. For every node $v\in V$, its vicinity ball, $\mbox{\sf ball}(v)$, contains at least one node from each color-set. To get this, the color of a given node $v$ is determined by a hash function color which, given the identity of a node, maps that identity to a color in $\{1,\dots,\sqrt{n}\}$. This mapping from identities to colors is balanced in the sense that at most $O(\log n\sqrt{n})$ nodes map to the same color. A color is chosen arbitrarily, and all nodes with that color are considered to be the landmarks. Let $L$ be the set of landmarks. It holds that $|L|=O(\log n\sqrt{n})$. Also, each node $v\in V$ has at least one landmark in its vicinity ball. We fix, for each vicinity ball $\mbox{\sf ball}(v)$, an arbitrary landmark, denoted by $l_{v}$.

4.1.2 Routing in trees

This construction in [2] makes use of routing schemes in trees. More precisely, they use the results from [11, 23], which states that there exists a shortest-path (name-dependent) routing scheme for trees using names and tables both on $O(\log^{2}(n)/\log\log(n))$ bits in $n$-node trees. For a tree $T$ containing node $v$, let $\mbox{\sf table}_{T}(v)$ and $\mbox{\sf name}_{T}(v)$ denote the routing table of node $v$ in $T$, and the name of $v$ in $T$, as assigned by the scheme in [11].

4.1.3 The routing tables

For any node $v$, let $T(v)$ be a shortest-path spanning tree rooted at $v$. Let $P(v,w,u)$ be a path between $v$ and $u$ composed of a shortest path between $v$ and $w$ and a shortest path between $w$ and $u$. Such a path is said to be good for $(v,u)$ if $v\in\mbox{\sf ball}(w)$, and there exists an edge $\{x,y\}$ along a shortest path between $w$ and $u$ with $x\in\mbox{\sf ball}(w)$ and $y\in\mbox{\sf ball}(u)$;

Every node $v\in V$ stores the following information in its routing table $\mbox{\sf table}(v)$:

• •

the hash function color that maps identities in colors;

• •

the identity of every node $u\in\mbox{\sf ball}(v)$, and the port number $\mbox{\sf next}(v,u)$;

• •

for every landmark $l\in L$, the routing table $\mbox{\sf table}_{T(l)}(v)$ for routing in $T(l)$;

• •

for every node $u\in\mbox{\sf ball}(v)$, the routing table $\mbox{\sf table}_{T(u)}(v)$ for routing in $T(u)$;

• •

the identities of all nodes with same color as $v$, and, for each such node $u$, the following additional information:

• –

if there are no good paths $P(v,w,u)$, then $v$ stores

[TABLE]

• –

if there exists a good path $P(v,w,u)$, then let us pick a good path $P$ of minimum length among all good paths; then, let us compare its length $|P|$ with the length $|Q|$ of the path $Q$ composed of a shortest path between $v$ and $l_{u}$, and a shortest path between $l_{u}$ and $u$; provide $v$ with

[TABLE]

if $|Q|\leq|P|$, and with

[TABLE]

otherwise.

Storing the hash function color requires $O(\sqrt{n})$ bits. $L$ and $\mbox{\sf ball}(v)$ are both of size $\widetilde{O}(\sqrt{n})$ bits. Moreover, the number of nodes with identical color is $\widetilde{O}(\sqrt{n})$, for every color. Finally, shortest-path routing in any tree can be achieved using tables and names of size $O(\log^{2}n/\log\log n)$ bits [11, 23]. It follows that $|\mbox{\sf table}(v)|=\widetilde{O}(\sqrt{n})$, as desired.

4.1.4 Routing

Routing from a source $s$ to a target $t$ is achieved in the following way (see [2] for more details). If $t\in\mbox{\sf ball}(s)$, or $t\in L$, or $s$ and $t$ have the same color, then $s$ routes to $t$ using the information available in its table. More specifically, if $t\in\mbox{\sf ball}(s)$ or $t\in L$, then $s$ sets the header of the message as just the identity of the target $t$. Instead, if $s$ and $t$ have the same color but $t\notin\mbox{\sf ball}(s)\cup L$, the source $s$ sets the header as one of the two possible cases presented in Eq. (2) and (3). Otherwise, that is, if $t\notin\mbox{\sf ball}(s)\cup L$ and $\mbox{\sl color}(s)\neq\mbox{\sl color}(t)$, node $s$ routes the message towards some node $w\in\mbox{\sf ball}(s)$ sharing the same color as $t$. (The color of $t$ can be obtained by hashing the identity of $t$). The header is set to $t$, and $w$ will change the header upon reception of this message, according to the rules previously specified. It is shown in [2] that this routing guarantees a stretch 3.

4.2 On the difficulty of locally verifying the scheme in [2]

We note that the routing scheme in [2], as sketched in the previous subsection, has some “global” features that makes it plausibly difficult to locally verify, by adding certificates of size $\widetilde{O}(\sqrt{n})$ bits at each node. In this subsection, we mention one of these global features, illustrated in the example depicted on Figures 1 and 2.

In both Figures 1 and 2, we are considering routing from a source $s\notin L$ to a target $t\notin L$, of different colors, with $s\notin\mbox{\sf ball}(t)$ and $t\notin\mbox{\sf ball}(s)$. Let us assume that node $s$ has color red, while node $t$ has color blue. According to the routing scheme in [2], node $s$ first routes the message towards some blue node $u\in\mbox{\sf ball}(s)$ to get information about the blue target $t$. In the example of Fig. 1, node $u$ stores

[TABLE]

in order to guarantee a stretch 3. Instead, in the example of Fig. 2, node $u$ stores

[TABLE]

to guarantee such a small stretch. Verifying locally whether there exists a good path between $s$ and $t$, which is the condition leading to distinguishing the case where the content of Eq. (2) in Section 4.1.3 must be placed in the table, from the case where the content of Eq. (3) must be placed in the table, appears to be a very difficult matter when restricted to certificates of size $\widetilde{O}(\sqrt{n})$.

We point out that ignoring the two cases, and systematically storing the content of Eq. (2) would result in a routing scheme that may be locally verifiable. However, its stretch is at least $7$. To see why, let us consider the example displayed in Figure 3 where $s\in\mbox{\sf ball}(t)$ but $t\notin\mbox{\sf ball}(s)$. The radius of $\mbox{\sf ball}(s)$ is $50$. Let $u\in\mbox{\sf ball}(s)$ be one of the farthest nodes to $s$, i.e., $\delta(s,u)=50$. The radius of $\mbox{\sf ball}(t)$ is $100$ and $\delta(t,l_{t})=100$. Although $\delta(u,t)=100$, we assume $u\notin\mbox{\sf ball}(t)$ due to lexicographical order priorities. Finally, assume that $\delta(s,t)=50$. The worst case route from $s$ to $t$ would then be $s\leadsto u\leadsto s\leadsto t\leadsto l_{t}\leadsto t.$ This path is of length

[TABLE]

which is $7\delta(s,t)$.

5 A New Name-Independent Routing Scheme

In this section, we describe and analyze a new name-independent routing scheme, denoted by $\cal R$. The section is entirely dedicated to the proof of the following theorem.

Theorem 4

The name-independent routing scheme $\cal R$ uses routing tables of size $\widetilde{O}(\sqrt{n})$ bits at each node. It guarantees stretch 5, and, using handshaking, its stretch can be reduced to 3. In both cases, $\cal R$ can be locally verified using certificates of size $\widetilde{O}(\sqrt{n})$ bits, using a 1-sided error verification algorithm which guarantees that incorrect tables are detected with high probability444Given a family of events $({\cal E}_{n})_{n\geq 1}$, event ${\cal E}_{n}$ holds with high probability if $\Pr[{\cal E}_{n}]=1-O(1/n^{c})$ for $c\geq 1$..

Our verifier used to establish Theorem 4 is actually deterministic. The certificates however store hash functions chosen at random. We assume that these hash functions are not corruptible, and that the adversary is not capable to create collisions (if not accidentally, by chance). Even though this assumption may seem strong, we point out that this is relevant to practical situations in which cryptographic hash functions designed to be collision resistant and hard to invert are used (for more details please refer to Chapter 5 of [8]).

5.1 The new routing scheme $\cal{R}$

Our new routing scheme $\cal{R}$ borrows ingredients from both [2] and [23]. In particular, the landmarks are chosen as for the (name-dependent) routing scheme in [23], i.e., in such a way that every node $v$ has a cluster $\mbox{\sf cluster}(v)$ of size at most $4\sqrt{n}$, and the landmarks form a set $L$ of size at most $2\log n\sqrt{n}$. However, we reinforce the way the nearest landmark to $v$ is selected, by picking the nearest landmark $l_{v}$ such that

[TABLE]

where ties are broken by choosing the landmark with smallest identity. Also, we slightly reinforce the definition of next: For every two nodes $v$ and $t$, we set

[TABLE]

as the smallest port number at $v$ of an edge incident to $v$ on a shortest path between $v$ and $t$. These two reinforcements of the definitions of landmarks and next guarantee the following.

Lemma 5

Let $v\in V$, and let $l_{v}$ be its landmark. Let $u$ be a node on a shortest path between $v$ and $l_{v}$. Then $l_{u}=l_{v}$.

Proof. By the choice of the landmarks, if $l_{u}\neq l_{v}$ then $\delta(u,l_{u})<\delta(u,l_{v})$. However, $\delta(v,l_{u})\leq\delta(v,u)+\delta(u,l_{u})$. So, if $l_{u}\neq l_{v}$ then $\delta(v,l_{u})<\delta(v,u)+\delta(u,l_{v})=\delta(v,l_{v})$, contradicting the choice of $l_{v}$ as the landmark closest to $v$. $\Box$

Lemma 6

Let $v\in V$, let $l_{v}$ be its landmark, and let $w$ be the neighbor of $l_{v}$ such that $\mbox{\sf next}(l_{v},v)=\mbox{\sf port}_{l_{v}}(\{l_{v},w)\}$. Let $u$ be a node on a shortest path between $v$ and $w$. We have $\mbox{\sf next}(l_{v},u)=\mbox{\sf next}(l_{v},v)$.

Proof. By Lemma 5, we have $l_{u}=l_{v}$. If $\mbox{\sf next}(l_{v},u)\neq\mbox{\sf next}(l_{v},v)$ there exists a shortest path $P$ from $l_{v}$ to $u$ that does not go to $w$ but through another neighbor $w^{\prime}$ of $l_{v}$ with $\mbox{\sf next}(l_{v},u)=\mbox{\sf port}_{l_{v}}(\{l_{v},w^{\prime})\}$. On the other hand, there is a shortest path between $l_{v}$ and $u$ going through $w$. So, $\mbox{\sf port}_{l_{v}}(\{l_{v},w^{\prime}\})<\mbox{\sf port}_{l_{v}}(\{l_{v},w\})$. But the path consisting of $P$ and the shortest path between $u$ and $v$ is also a shortest path between $l_{v}$ and $v$. Therefore, by our reinforcement of the definition of next, we get $\mbox{\sf port}_{l_{v}}(\{l_{v},w^{\prime}\})>\mbox{\sf port}_{l_{v}}(\{l_{v},w\})$, contradiction. $\Box$

As in [2], each node that is not a landmark is given a color in $\{1,\dots,\sqrt{n}\}$ determined by a hash function, color, that maps identities to colors, where at most $O(\log n\sqrt{n})$ nodes map to the same color. Also, each node $v$ has a vicinity ball, $\mbox{\sf ball}(v)$, that contains the $O(\log(n)\sqrt{n})$ nodes closest to $v$ (breaking ties using identities). This guarantees that, with high probability, for every node $v$, there is at least one node of each color in $\mbox{\sf ball}(v)$.

For each color $c$, where $1\leq c\leq\sqrt{n}$, we define a set

[TABLE]

which includes the direction to take at $l_{v}$ for reaching node $v$ along a shortest path, for $v$ of color $c$.

5.1.1 The routing tables

Every node $v\in V$ then stores the following information in $\mbox{\sf table}(v)$:

• •

the hash function color that maps identities in colors;

• •

the identity of every landmark $l\in L$, and the corresponding port $\mbox{\sf next}(v,l)$;

• •

the identity of every node $u\in\mbox{\sf cluster}(v)$, and the corresponding port $\mbox{\sf next}(v,u)$;

• •

the identity of every node $u\in\mbox{\sf ball}(v)$, and the corresponding port $\mbox{\sf next}(v,u)$;

• •

the set $\mbox{\sf Dir}_{\mbox{\rm\scriptsize color}(v)}$.

Storing the hash function color requires $O(\sqrt{n})$ bits, as we use the same function as in [2]. Since $L$, $\mbox{\sf cluster}(v)$, $\mbox{\sf ball}(v)$, and $\mbox{\sf Dir}_{\mbox{\rm\scriptsize color}(v)}$ are all of size $\widetilde{O}(\sqrt{n})$, we get that $|\mbox{\sf table}(v)|=\widetilde{O}(\sqrt{n})$ as desired.

5.1.2 Routing

Let us consider routing towards a target node $t$, and let $v$ be the current node. If $t\in\mbox{\sf cluster}(v)$, then routing to $t$ is achieved using $\mbox{\sf next}(v,t)$. Notice that, by Lemma 3, routing to $t$ will actually be achieved along a shortest path. Similarly, if $t\in\mbox{\sf ball}(v)$, then routing to $t$ is achieved using $\mbox{\sf next}(v,t)$ along a shortest path, and this also holds if $t$ is a landmark. In general, i.e., if $t$ is neither a landmark nor a node of $\mbox{\sf cluster}(v)\cup\mbox{\sf ball}(v)$, then node $v$ computes $\mbox{\sl color}(t)$ by hashing the identity of $t$.

If $\mbox{\sl color}(t)=\mbox{\sl color}(v)$, then $v$ forwards the message towards $l_{t}$ using the information in $\mbox{\sf Dir}_{\mbox{\rm\scriptsize color}(v)}$, and including $(l_{t},\mbox{\sf next}(l_{t},t))$ in the header of the message so that intermediate nodes carry on routing this message to $l_{t}$. At $l_{t}$, the message will be routed to $t$ using the information $\mbox{\sf next}(l_{t},t)$ available in the header, reaching a node $u_{t}$ such that $t\in\mbox{\sf cluster}(u_{t})$. At this point, routing proceeds to $t$ along a shortest path.

If $\mbox{\sl color}(t)\neq\mbox{\sl color}(v)$, then the message is forwarded to an arbitrary node $w\in\mbox{\sf ball}(v)$ having the same color as $t$ (we know that such a node exists), with $w$ in the header of the message. The message then reach $w$ along a shortest path. At $w$, we have $\mbox{\sl color}(t)=\mbox{\sl color}(w)$, and thus routing proceeds as in the previous case.

Handshaking. The routing with handshaking to node $t$ proceeds as follows. If $t\in L\cup\mbox{\sf cluster}(v)\cup\mbox{\sf ball}(v)$, or $\mbox{\sl color}(v)=\mbox{\sl color}(t)$, then routing proceeds as above. Otherwise, $v$ performs a handshake with a node $w\in\mbox{\sf ball}(v)$ with $\mbox{\sl color}(w)=\mbox{\sl color}(t)$ in order to get the identity of $l_{t}$ as well as $\mbox{\sf next}(l_{t},t)$. Then $v$ routes the message to $l_{t}$, where it is forwarded to a node $u_{t}$ such that $t\in\mbox{\sf cluster}(u_{t})$. At this point, routing proceeds to $t$ along a shortest path.

5.2 Stretch of the new routing scheme $\cal{R}$

Let $s,t\in V$ be two arbitrary nodes of the graph. We show that the routing scheme $\cal R$ routes messages from $s$ to $t$ along a route of length at most $5\,\delta(s,t)$ in general, and along a route of length at most $3\,\delta(s,t)$ whenever using handshaking.

As we already observed, if $t\in L\cup\mbox{\sf cluster}(v)\cup\mbox{\sf ball}(v)$, then the message is routed to $t$ along a shortest path, i.e., with stretch 1. Otherwise, we consider separately whether the color of $s$ is the same as the color of $t$, or not.

Assume first that $\mbox{\sl color}(t)=\mbox{\sl color}(s)$. Then the message is routed towards $l_{t}$ along a shortest path, then from $l_{t}$ to $t$ along a shortest path. The length $\ell$ of this route satisfies

[TABLE]

By the triangle inequality, we get that

[TABLE]

Since $t\notin\mbox{\sf cluster}(s)$, we get $\delta(s,t)\geq\delta(t,l_{t})$. Therefore

[TABLE]

We are left with the case where $\mbox{\sl color}(s)\neq\mbox{\sl color}(t)$. Observe first that, with handshaking, the route from $s$ to $t$ will be exactly as the one described in the case $\mbox{\sl color}(s)=\mbox{\sl color}(t)$, resulting in a stretch 3. This completes the proof that $\cal R$ achieves a stretch 3 with handshaking. Without handshaking, the message is forwarded along a shortest path to an arbitrary node $w\in\mbox{\sf ball}(v)$ having the same color as $t$, then from $w$ to $l_{t}$ along a shortest path, and finally from $l_{t}$ to $t$ along a shortest path. The length $\ell$ of this route satisfies

[TABLE]

as desired.

5.3 Local Verification of $\cal R$

We show how to verify $\cal R$ with a verification algorithm verif using certificates on $\widetilde{O}(\sqrt{n})$ bits. Let us define the certificates given to nodes when the routing tables are correctly set as specified by $\cal R$.

For each color $c$, $1\leq c\leq\sqrt{n}$, let $B_{c}$ be the number of bits for encoding the set $\mbox{\sf Dir}_{c}$, and let $r=\max_{1\leq c\leq\sqrt{n}}B_{c}$. We have $r=\widetilde{O}(\sqrt{n})$. Let $f_{1},\dots,f_{k}$ be $k=\Theta(\log n)$ hash functions, where each one is mapping sequences of at most $r$ bits onto a single bit. More specifically, each function $f_{i}$, $1\leq i\leq k$, is described as a sequence $f_{i,1},\dots,f_{i,r}$ of $r$ bits. Given a sequence $D=(d_{1},\dots,d_{\ell})$ of $\ell\leq r$ bits, we set

[TABLE]

Hence, if the $r$ bits describing $f_{i}$ are chosen independently uniformly at random, then, for every two $\ell$-bit sets $D$ and $D^{\prime}$, we have [25]:

[TABLE]

Therefore,

[TABLE]

That is, if $k=\beta\lceil\log_{2}n\rceil$ with $\beta>1$, applying the functions $f_{1},\dots,f_{k}$ to both sets $D$ and $D^{\prime}$ enables to detect that they are distinct, with high probability $1-1/n^{\beta}$.

Each node $v\in V$ stores the certificate composed of the following fields:

• •

the distances $\{\delta(v,l):l\in L\}$;

• •

the distances $\{\delta(v,u):u\in\mbox{\sf ball}(v)\}$;

• •

the set \big{\{}\big{(}\delta(v,u),l_{u},\delta(u,l_{u})\big{)}:u\in\mbox{\sf cluster}(v)\big{\}};

• •

the set of $k$ hash functions $f_{1},\dots,f_{k}$;

• •

the set $\{f_{i}(\mbox{\sf Dir}_{c}):1\leq i\leq k,\;1\leq c\leq\sqrt{n}\}$.

The first three entries are clearly on $\widetilde{O}(\sqrt{n})$ bits, because of the sizes of $L$, $\mbox{\sf cluster}(v)$, and $\mbox{\sf ball}(v)$. Each function $f_{i}$ is described by a sequence of $\widetilde{O}(\sqrt{n})$ random bits.

The verification algorithm verif then proceeds as follows. In a way similar to the proof of Theorem 2, we denote by $H(v)$, $L(v)$, $C(v)$, $B(v)$, $D(v)$, and $\{N(v,t):t\in L(v)\cup C(v)\cup B(v)\}$ the content of the routing table of $v$. These entries are supposed to be the hash function color, the set of landmarks, the cluster of $v$, the ball of $v$, the set $\mbox{\sf Dir}_{\mbox{\rm\scriptsize color}(v)}$, and the set of next-pointers given to $v$, respectively. We also denote by $d$ the distance given in the certificates. That is, node $v$ is given a set $\{d(v,t):t\in L(v)\cup B(v)\}$, and a set $\{(d(v,t),l_{t},d(t,l_{t})):t\in C(v)\}$ where $l_{t}$ is supposed to be the node in $L(v)$ closest to $t\in C(v)$. We also denote by $F^{v}_{1},\dots,F^{v}_{k}$ the hash functions given to $v$ in its certificate, and by

[TABLE]

the set of $O(\sqrt{n}\log n)$ hash values in the certificates. Of course, if a node does not have a table and a certificate of these forms, then it outputs reject. So, we assume that all tables and certificates have the above formats.

Clusters, balls and landmarks (including distances, ports, sizes, etc.) are checked exactly as in Section 3 for the routing scheme in [23]. So, in particular, ignoring the colors and ignoring the minimality of the landmarks’ identities, we can assume that, for every node $v$,

[TABLE]

and, for every node $u\in L\cup\mbox{\sf cluster}(v)\cup\mbox{\sf ball}(v)$, we have $d(v,u)=\delta(v,u)$, and $N(v,u)=\mbox{\sf next}(v,u)$ ignoring the minimality of that port number. To check the remaining entries in the routing tables (as well as the previously ignored colors and minimality criteria for the landmarks and the next-pointers), verif performs the following sequence of steps. At every step, if the test is not passed at some node, then verif outputs reject at this node, and stops. Otherwise, it goes to the next step. If all tests are passed at a node, that node outputs accept. Node $v$ checks that:

$l_{v}$ has the smallest identity among all landmarks closest to $v$; 2. 2.

it has the same hash function $H(v)$ as its neighbors, that it has one node of each color in $B(v)$, that $v$ appears in $D(v)$, and that all nodes appearing in $D(v)$ have the same color as $v$; 3. 3.

there exists at least one neighbor $u$ on a shortest path between $v$ and $l_{v}$ with $N(l_{v},v)=N(l_{v},u)$; for every neighbor $u$ on the shortest path between $v$ and $l_{v}$ (implying $l_{u}=l_{v}$) with $u\neq l_{v}$, $N(l_{v},v)\leq N(l_{u},u)$; and if $l_{v}$ is a neighbor of $v$ on a shortest path between $l_{v}$ and $v$, $N(l_{v},v)=\mbox{\sf port}_{l_{v}}(\{l_{v},v\})$; 4. 4.

for every $u\in L\cup B(v)\cup C(v)$, the port number $N(v,u)$ is the smallest among all the ports of edges incident to $v$ on a shortest path between $v$ and $u$; 5. 5.

it has the same hash functions $F^{v}_{1},\dots,F^{v}_{k}$, as its neighbors; 6. 6.

$F^{v}_{i}(D(v))=F^{v}_{i,H(v)}$ for every $i=1,\dots,k$; 7. 7.

the hash value $F^{v}_{i,c}$, $1\leq i\leq k$, $1\leq c\leq\sqrt{n}$, are identical to the ones of their neighbors.

If $v$ passes all the above tests, then $v$ outputs accept, else it outputs reject.

We now establish the correctness of this local verification algorithm, that is, we show that it satisfies the specification stated in Section 2.2. First, by construction, if all tables are set according to the specification of $\cal R$, then every node running the verification algorithm with the appropriate certificate will face no inconsistencies with its neighbors, i.e., all the above tests are passed, leading every node to accept, as desired. So, it remains to show that if some tables are not what they should be according to $\cal R$, then, no matter the certificates assigned to the nodes, at least one node will fail one of the tests with high probability.

If all nodes pass the test of Step 1, then we are guaranteed that not only $L(v)=L$, but also that $l_{v}$ is indeed the appropriate landmark of $v$. If all nodes pass the test of Step 2, then it must be the case that $H(v)=\mbox{\sl color}(v)$, that $B(v)=\mbox{\sf ball}(v)$ with the desired coloring property, and that

[TABLE]

By Lemma 6, we get that if all nodes pass Steps 3 and 4, then $N(v,u)=\mbox{\sf next}(v,u)$ where the minimality condition is satisfied.

Let us assume that there exists a pair of nodes $(u,v)$ with same color such that

[TABLE]

By the previous steps, we know that $(u,l_{u},\mbox{\sf next}(l_{u},u))\in D(u)$. Hence, $D(u)\neq D(v)$. On the other hand, if Step 5 is passed by all nodes, then all nodes agree on a set of $k=\Theta(\log n)$ hash function $f_{1},\dots,f_{k}$. Therefore, assuming that these functions are set at random, we get that, with high probability, there exists at least one function $f_{i}$, $1\leq i\leq k$, such that $f_{i}(D(v))\neq f_{i}(D(u))$.

If all nodes pass Step 6, then in particular $F^{v}_{i}(D(v))=F^{v}_{i,c}$, and $F^{u}_{i}(D(u))=F^{u}_{i,c}$ where $c=\mbox{\sl color}(v)=\mbox{\sl color}(u)$. We know that $F^{v}_{i,c}=f_{i}(D(v))$ and $F^{u}_{i,c}=f_{i}(D(u))$, which implies that $F^{v}_{i,c}\neq F^{u}_{i,c}$ with high probability, which will be detected at Step 7 by two neighboring nodes in the network. This completes the proof of Theorem 4.

6 Another name-independent Routing Scheme

We have seen that the stretch-3 name-independent routing scheme from [2] does not seem to be locally checkable with certificates of $\widetilde{O}(\sqrt{n})$ bits. Our new name-independent routing scheme $\cal R$ is locally checkable with certificates of $\widetilde{O}(\sqrt{n})$ bits, but it has stretch 5. In this section, we focus on the local checkability of the stretch-5 name-independent routing scheme from [3]. We show that, as for the scheme in  [2], the routing scheme in [3] do not appear to be locally checkable with certificates of $\widetilde{O}(\sqrt{n})$ bits. Moreover, handshaking, which may allow that scheme to become locally verifiable with small certificates, does not reduce its stretch.

6.1 The Routing Scheme of [3]

The scheme in [3] requires $\widetilde{O}(\sqrt{n})$ bits of memory per node. It is based on the notion of landmarks, with as set $L$ of landmarks sith size $O(\log n\sqrt{n})$. To each node $v$ is also associated a vicinity ball, $\mbox{\sf ball}(v)$, consisting of the $\sqrt{n}$ closest nodes to $v$, breaking ties using the lexicographic order of the identities. Each node has at least one landmark in its vicinity ball.

6.1.1 Block partition

Nodes are partitioned into $\sqrt{n}$ blocks, $S_{1},\dots S_{\sqrt{n}}$, each containing $\sqrt{n}$ nodes. Assuming that the identities are from [math] to $n-1$, the set $S_{i}$ consists of the nodes with identities in $[(i-1)\sqrt{n},\;i\sqrt{n})$. Set of blocks are assigned to the nodes. We denote by $A_{v}$ the set of blocks assigned to node $v$. We then denote by $R_{v}$ the set

[TABLE]

It is proved in [3] that there exists an assignment of sets of blocks to nodes such that

• •

for every $v\in V$, and for every block $S_{i}$, there exists $u\in\mbox{\sf ball}(v)$ such that $S_{i}\in A_{u}$;

• •

for every $v\in V$, $|A_{v}|=O(\log n)$.

6.1.2 The routing tables

This scheme in [3] also uses routing schemes for trees. Similarly to the previously described schemes, for a landmark $l\in L$, we denote by $T(l)$ a shortest-path tree routed at $l$ spanning all the nodes. Also, $\mbox{\sf table}_{T}(v)$ and $\mbox{\sf name}_{T}(v)$ denote the routing table and name of node $v$, respectively, for the tree $T$. Each node $v\in V$ stores the following information in $\mbox{\sf table}(v)$:

• •

the identity of every node $u\in\mbox{\sf ball}(v)$, together with $\mbox{\sf next}(v,u)$;

• •

the identity of every node $l\in L$, together with $\mbox{\sf next}(v,l)$ and $\mbox{\sf table}_{T(l)}(v)$;.

• •

for every node $u\in\mbox{\sf ball}(v)$, the set of indexes $i$ such that $S_{i}\in A_{u}$;

• •

the identity of every node $u\in R_{v}$ together with the identity of $l^{*}_{v,u}$, and $\mbox{\sf name}_{T(l^{*}_{v,u})}(u)$ where

[TABLE]

6.1.3 Routing

Routing from a node $s$ to a node $t$ is achieved in the following way. If $t\in\mbox{\sf ball}(s)\cup L\cup R_{s}$, then $s$ routes to $t$ using the information it has in its table. Otherwise, $s$ routes the message towards a node $w\in\mbox{\sf ball}(s)$ satisfying that $t\in R_{w}$. Then $w$ routes to $t$ using the information it has in its table, i.e., via the landmark $l^{*}_{w,t}$ that minimizes the sum $\delta(w,l)+\delta(l,t)$. It is proved in [3] that this routing scheme guarantees stretch $5$.

6.2 On the difficulty of locally verifying the scheme in [3]

As for the routing scheme in [2], we note that the routing scheme in [3] sketched in the previous subsection is plausibly difficult to locally verify by adding certificates of size $\widetilde{O}(\sqrt{n})$ bits at each node. Indeed, let us consider two nodes $u$ and $v$ with $u\in R_{v}$, one difficulty consists in verifying that a given landmark $l^{*}_{v,u}$ is effectively the one that, among all $l\in L$, minimizes the distance $\delta(v,l)+\delta(l,u)$.

Also, we show that, even using handshaking, the scheme in [3] still achieves stretch at least $5$. To see why, let us consider the example depicted in Fig. 4, where the node $s$ aims at routing towards the node $t$. Node $w\in Ball(s)$ is the only node that has the routing information about node $t$, i.e., $t\in R_{w}$ and, for every $u\in\mbox{\sf ball}(s)\setminus\{w\}$, we have $t\notin R_{u}$. Therefore, if the handshaking is performed to a node with information about $t$ in $\mbox{\sf ball}(s)$, then this handshaking is to be performed between $s$ and $w$. Let us fix some positive values $x$ and $\epsilon$, with $\epsilon\ll x$.

On Fig. 4, the following holds:

• •

$t\notin\mbox{\sf ball}(s)$, and $s\notin\mbox{\sf ball}(t)$;

• •

the radius of both $\mbox{\sf ball}(s)$ and $\mbox{\sf ball}(t)$ is $x$;

• •

$\delta(s,t)=x+\epsilon$;

• •

$\delta(s,w)=\delta(s,l_{s})=x$ and $\delta(w,l_{s})=2x$;

• •

$\delta(s,t)=x+\epsilon$;

• •

$\delta(w,l^{*}_{w,t})=2x-\epsilon$ and $\delta(l^{*}_{w,t},t)=2x+\epsilon$;

• •

the shortest path between $s$ and $l^{*}$ goes through $w$, i.e., $\delta(s,l^{*}_{w,t})=\delta(s,w)+\delta(w,l^{*}_{w,t})=3x-\epsilon$.

Note that $\delta(l_{s},t)=2x+\epsilon$, and thus

[TABLE]

Since l^{*}_{w,t}=\mbox{\rm argmin}_{l\in L}\big{(}\delta(w,l)+\delta(l,t)\big{)},it follows that

[TABLE]

In fact, in our example, we have

[TABLE]

Therefore, using handshaking, $s$ queries $w$ that replies with the name of $l^{*}_{w,t}$. Then $s$ sends the message to $t$ via $l^{*}_{w,t}$ and the resulting route is $s\leadsto w\leadsto l^{*}_{w,t}\leadsto t$, which has length:

[TABLE]

which is close to $5\,\delta(s,t)$ for $\epsilon\ll x$.

The case of handshaking with $t$ also leads to no improvements as far as stretch is concerned. See, e.g., Fig. 4 where $t$ has a red node $u$ in its ball, at distance $x$ from $t$, and at distance $2x-\epsilon$ from $l^{*}_{u,s}$ with $l^{*}_{u,s}$ at distance $2x+\epsilon$ from $s$. This scenario leads to the very same situation as when the handshaking is performed between $s$ and $w$.

7 Generalization to larger stretches

In this section, we show that Theorem 2 can be generalized to a whole family of routing schemes achieving a tradeoff between space complexity and stretch. More specifically, Thorup and Zwick describe in [24] an algorithm which, given any integer $k\geq 1$, returns a collection $\cal T$ of trees such that every node is contained in $O(n^{1/k}\log^{1-1/k}n)$ trees in $\cal T$, and, for each pair of nodes, there exists a tree in $\cal T$ in which these two nodes are connected by a path of length at most $2k-1$ times the length of a shortest path between them. Thorup and Zwick use this result, combined with the techniques used in their stretch-$3$ routing scheme, to produce a family of routing schemes indexed by $k\geq 2$. For any $k\geq 2$ the routing scheme in this family uses a memory of $\widetilde{O}(n^{1/k})$ bits at each node, and has stretch $4k-5$ (see [23]). The stretch can be reduced to $2k-1$ using handshaking.

Theorem 7

For any $k\geq 2$, the stretch-$(4k-5)$ routing scheme by Thorup and Zwick in [23] can be locally verified using certificates of size $\widetilde{O}(n^{1/k})$ bits. This also holds for their handshaking-based stretch-$(2k-1)$ routing scheme.

We provide below a sketch of the proof for Theorem 7. For this purpose, we recall the family of routing schemes in [23].

7.1 The Routing Scheme Family of [23]

The design of this family combines techniques described in [24] and [23].

7.1.1 A hierarchy of landmarks

The design is based on the construction of a hierarchy of landmarks

[TABLE]

where $L_{0}=V$, $L_{k}=\emptyset$, and $|L_{i}|=\widetilde{O}(n^{1-i/k})$ for $i=0,\dots,k-1$. One way of constructing such set is to place each element of $L_{i-1}$ into $L_{i}$ independently with probability $n^{-1/k}$. This way, $L_{k-1}$ is of size $O(n^{1/k}\log n)$.

For $0\leq i\leq k-1$, let $l_{i}(v)$ be the nearest landmark of node $v$ among all the landmarks in $L_{i}$. Notice that, for every node $v$, we have $l_{0}(v)=v$. Each node $v$ has a bunch associated to it, defined as follows.

[TABLE]

Note that, since $L_{k}=\emptyset$, we have $\delta(v,l_{k}(v))=+\infty$ for every $v\in V$, and thus, for every node $v$,

[TABLE]

It can be shown [24] that, for any node $v$,

[TABLE]

The aforementioned collection $\cal T$ of trees is actually composed on $n$ trees, each rooted at a different node. We denote by $T(v)$ the tree in $\cal T$ that is rooted at $v$. Moreover, $\cal T$ satisfies that, for every node $v$, and every $u\in\mbox{\sf bunch}(v)$, node $v$ belongs to $T(u)$. The same also hods for the landmarks, that is, for every node $v$, and every landmark $l_{i}(v)$, node $v$ belongs to $T(l_{i}(v))$.

Each node has also a cluster associated to it, defined as follows.

[TABLE]

It can be shown [23] that landmarks can be set in such a way that, for every $v$,

[TABLE]

7.1.2 Names and tables

Each node $v$ stores in its table, $\mbox{\sf table}(v)$, the following information:

• •

the identities of each node $u\in\mbox{\sf bunch}(v)$;

• •

for every $u\in\mbox{\sf bunch}(v)$, the routing table $\mbox{\sf table}_{T(u)}(v)$ and the name $\mbox{\sf name}_{T(u)}(v)$ of node $v$;

• •

for every $u\in\mbox{\sf cluster}(v)$, the name $\mbox{\sf name}_{T(v)}(u)$;

• •

the identity of the landmark $l_{i}(v)\in L_{i}$, $0\leq i\leq k-1$;

• •

the routing table $\mbox{\sf table}_{T(l_{i}(v))}(v)$.

All this information can be stored at $v$ using $\widetilde{O}(n^{1/k})$ bits. The $O(\log n)$-bit name of node $v$ is set as

[TABLE]

7.1.3 Routing

The routing from a source $s$ to a target $t$ proceeds as follows.

If $t\in\mbox{\sf bunch}(s)$, or $t=l_{i}(v)$ for some $i$, $0\leq i\leq k-1$, then $s$ routes to $t$ along a shortest path, using the information in its table, i.e., using $\mbox{\sf table}_{T(t)}(s)$. If $t\in\mbox{\sf cluster}(s)$, then $s$ routes to $t$ along a shortest path using the information in its table, i.e.,using $\mbox{\sf name}_{T(s)}(t)$ on the tree rooted at $s$. (Note that if $t\in\mbox{\sf cluster}(s)$, then $s\in\mbox{\sf bunch}(t)$, and, more generally, $s\in\mbox{\sf bunch}(u)$ for any $u$ on a shortest path between $s$ and $t$, from which it follows that $u$ also knows how to route to $t$ using $\mbox{\sf table}_{T(s)}(u)$).

Otherwise, node $s$ scans all identities $l_{i}(t)$ in $\mbox{\sf name}(t)$, and, among all such landmarks in $\mbox{\sf bunch}(s)$, picks the one with the smallest index $i$, i.e., picks $l_{i}(t)$ where

[TABLE]

Then $s$ routes to $t$ using $\mbox{\sf name}_{T(l_{i}(t))}(t)$ in the tree $T(l_{i}(t))$ — this information can be extracted from the name of $t$. Note that there exists at least one landmark $l_{i}(t)\in\mbox{\sf bunch}(s)$ because $L_{k-1}\in\mbox{\sf bunch}(v)$ for every node $v$.

It is proved in [23] that this routing scheme guarantees a stretch $4k-5$.

Handshaking. In order to reduce the stretch from $4k-5$ to $2k-1$, the source $s$ performs handshaking by querying node $t$, providing it with $\mbox{\sf name}(s)$. The target $t$ computes

[TABLE]

Then $t$ choses between $l_{i}(t)$ and $l_{j}(s)$ the one that has the minimum index among the two. That is, it picks

[TABLE]

and routing between $s$ and $t$ is performed along the tree $T(l^{*})$, guaranteeing stretch $2k-1$.

7.2 Sketch of the proof of Theorem 7

It is not hard to check that one can locally verify the $O(\log^{2}n/\log\log n)$-bit routing tables in [11] for routing in trees with certificates of size $O(\log^{2}n/\log\log n)$ bits at each node. As for the basic case of stretch-3 routing with tables of size $\widetilde{O}(\sqrt{n})$ bits at each node, each node has to check the correctness of its bunch, its cluster, and its set of landmarks. For this purpose, the certificate of every node $v$ stores

• •

the distance $\delta(v,u)$ for every $u\in\{l_{0}(v),\dots,l_{k-1}(v)\}$, and every $u\in\mbox{\sf cluster}(v)\cup\mbox{\sf bunch}(v)$;

• •

the distance $\delta(u,l_{u})$ for every node $u\in\mbox{\sf cluster}(v)$.

Each node $v$ then checks that:

its bunch, its cluster, and its set of the nearest landmarks are of the appropriate size; 2. 2.

the set of landmarks $L_{k-1}$ is the same for every node; 3. 3.

$l_{i}(v)$ is truly the nearest landmark of level $i$ of node $v$; 4. 4.

all nodes in $\mbox{\sf bunch}(v)$ satisfy the definition of bunch, and that there are no missing nodes; 5. 5.

the nodes in $\mbox{\sf cluster}(v)$ satisfy the definition of cluster, and that there are no missing nodes.

All these tests can be applied at each node by using the same techniques as to verify the stretch-$3$ routing scheme of [23], and the correctness follows by the same arguments as those given in Section 3.

8 Conclusion and Further Work

We have shown that it is possible to verify routing schemes based on tables of size $\widetilde{O}(\sqrt{n})$ bits using certificates with sizes of the same order of magnitude as the space consumed by the routing tables. The stretch factor is preserved, but to the cost of using handshaking mechanisms for name-independent routing. We do not know whether there exists a stretch-3 name-independent routing scheme, with tables of size $\widetilde{O}(\sqrt{n})$ bits, that can be verified using certificates on $\widetilde{O}(\sqrt{n})$ bits. Our new routing scheme, which is verifiable with certificates on $\widetilde{O}(\sqrt{n})$, has stretch 3 only if using handshaking (otherwise, it has stretch 5). Moreover, the certification of our routing scheme is probabilistic, and it would be of interest to figure out whether deterministic certification exists for some stretch-3 name-independent routing scheme, with tables and certificates on $\widetilde{O}(\sqrt{n})$ bits. It could also be of interest to figure out whether there exists a verification scheme using certificates of size $\widetilde{O}(n^{c})$ bits, with $c<\frac{1}{2}$.

Interestingly, our result for stretch-3 name-dependent routing can be extended to larger stretches. Namely, by using the same techniques as for stretch 3, we can show that the family of routing schemes in [23] using, for every $k\geq 1$, tables of size $\widetilde{O}(n^{1/k})$ with stretch at most $4k-5$ (or $2k-1$ using handshaking) are verifiable with certificates of size $\widetilde{O}(n^{1/k})$ (see [BF17] for more details). However, we do not know whether such a tradeoff between table sizes and stretches can be established for verifiable name-independent routing schemes. Specifically, are the existing families of name-independent routing schemes using, for every $k\geq 1$, tables of size $\widetilde{O}(n^{1/k})$ with stretch at most $O(k)$, verifiable with certificates of size $\widetilde{O}(n^{1/k})$? If not, is it possible to design a new family of verifiable name-independent routing schemes satisfying the same size-stretch tradeoff?

Acknowledgements: The authors are thankful to Cyril Gavoille and Laurent Viennot for discussions about the content of this paper.