Approximation algorithms and an integer program for multi-level graph spanners

TL;DR

This paper introduces a multi-level graph spanner problem, generalizes subsetwise spanners, and provides an ILP formulation and heuristics for efficient approximation, with applications in network design and visualization.

Contribution

It generalizes the subsetwise spanner problem to multi-level graphs and formulates a polynomial-size ILP for the pairwise spanner problem, addressing an open question.

Findings

ILP formulation of size O(|E||V|^2) for pairwise spanner problem

Heuristics and ILP tested on graphs with up to 100 vertices

Applications demonstrated in network building and visualization

Abstract

Given a weighted graph $G(V,E)$ and $t \ge 1$, a subgraph $H$ is a \emph{$t$--spanner} of $G$ if the lengths of shortest paths in $G$ are preserved in $H$ up to a multiplicative factor of $t$. The \emph{subsetwise spanner} problem aims to preserve distances in $G$ for only a subset of the vertices. We generalize the minimum-cost subsetwise spanner problem to one where vertices appear on multiple levels, which we call the \emph{multi-level graph spanner} (MLGS) problem, and describe two simple heuristics. Applications of this problem include road/network building and multi-level graph visualization, especially where vertices may require different grades of service. We formulate a 0--1 integer linear program (ILP) of size $O(|E||V|^2)$ for the more general minimum \emph{pairwise spanner problem}, which resolves an open question by Sigurd and Zachariasen on whether this problem admits a useful polynomial-size ILP. We extend this ILP formulation to the MLGS problem, and evaluate the heuristic and ILP performance on random graphs of up to 100 vertices and 500 edges.

Figures

Equations

$$=\ell {\text{TOP}}_{\ell }+(\ell -1){\text{TOP}}_{\ell -1}+\dots +{\text{TOP}}_1$$

$$\le \ell {\text{OPT}}_{\ell }+(\ell -1)({\text{OPT}}_{\ell -1}+{\text{OPT}}_{\ell })+\dots +({\text{OPT}}_1+{\text{OPT}}_2+\dots +{\text{OPT}}_{\ell })$$

$$=\frac{\ell (\ell +1)}{2}{\text{OPT}}_{\ell }+\frac{(\ell -1)\ell }{2}{\text{OPT}}_{\ell -1}+\dots +\frac{1\cdot 2}{2}{\text{OPT}}_1$$

$$\le \frac{\ell +1}{2}\text{OPT},$$

$$E=\bigcup _{(u,v)\in P}\{e\in E|e\in \text{shortest-path}(u,v).\}$$

$$\text{allowdisplaybreaks}\text{Minimize}\sum _{e\in E}{c}_e{x}_e\text{ subject to}$$

$$\sum _{p\in P_{uv}}{y}_p{\delta }_p^e$$

$$\sum _{p\in P_{uv}}{y}_p$$

$$x_e$$

$$y_p$$

$$\text{allowdisplaybreaks}\text{Minimize}\sum _{e\in E}{c}_e{x}_e\text{ subject to}$$

$$\sum _{(i,j)\in E^{\prime }}{x}_{(i,j)}^{uv}{c}_e$$

$$\sum _{(i,j)\in Out(i)}{x}_{(i,j)}^{uv}-\sum _{(j,i)\in In(i)}{x}_{(j,i)}^{uv}$$

$$\sum _{(i,j)\in Out(i)}{x}_{(i,j)}^{uv}$$

$$x_{(i,j)}^{uv}+x_{(j,i)}^{uv}$$

$$x_e,x_{(i,j)}^{uv}$$

$$\text{allowdisplaybreaks}\text{Minimize}\sum _{e\in E}{c}_e{y}_e\text{ subject to}$$

$$\sum _{(i,j)\in E^{\prime }}{x}_{(i,j)}^{uv}{c}_e$$

$$\sum _{(i,j)\in Out(i)}{x}_{(i,j)}^{uv}-\sum _{(j,i)\in In(i)}{x}_{(j,i)}^{uv}$$

$$\sum _{(i,j)\in Out(i)}{x}_{(i,j)}^{uv}$$

$$y_e$$

$$x_{(i,j)}^{uv}$$

$$\min (\text{TOP},\text{BOT})$$

$$=\sum _{i=1}^{\ell }\left[\left(\frac{i(i+1)}{2}-\ell \right)\alpha +\ell \right]\rho {\text{OPT}}_i$$

$$\left(\frac{\ell (\ell +1)}{2}-\ell \right)\alpha +\ell \rho$$

$$\left(\frac{(\ell -1)\ell }{2}-\ell \right)\alpha +\ell \rho$$

$$⋮$$

$$\left(\frac{2\cdot 1}{2}-\ell \right)\alpha +\ell \rho$$

Full text

We formulate a 0–1 integer linear program (ILP) of size $O(|E||V|^{2})$ for the more general minimum pairwise spanner problem, which resolves an open question by Sigurd and Zachariasen on whether this problem admits a useful polynomial-size ILP. We extend this ILP formulation to the MLGS problem, and evaluate the heuristic and ILP performance on random graphs of up to 100 vertices and 500 edges.

1 Introduction

Given an undirected edge-weighted graph $G(V,E)$ and a real number $t\geq 1$, a subgraph $H(V,E^{\prime})$ is a (multiplicative) $t$–spanner of $G$ if the lengths of shortest paths in $G$ are preserved in $H$ up to a multiplicative factor of $t$; that is, $d_{H}(u,v)\leq t\cdot d_{G}(u,v)$ for all $(u,v)\in V\times V$, where $d_{G}(u,v)$ is the length of the shortest path from $u$ to $v$ in $G$. We refer to $t$ as the stretch factor of $H$. Peleg et al. [12] show that determining if there exists a $t$–spanner of $G$ with $m$ or fewer edges is NP–complete. Further, it is NP–hard to approximate the (unweighted) $t$–spanner problem to within a factor of $O(\log|V|)$, even when restricted to bipartite graphs [15].

In the pairwise spanner problem [11], distances only need to be preserved for a subset $\mathcal{P}\subseteq V\times V$ of pairs of vertices. Thus, the classical $t$–spanner problem is a special case of the pairwise spanner problem where $\mathcal{P}=V\times V$. The subsetwise spanner problem is a special case of the pairwise spanner problem where $\mathcal{P}=S\times S$ for some $S\subset V$; that is, distances need only be preserved between vertices in $S$ [11]. The case $t=1$ is known as the pairwise distance preserver or sourcewise distance preserver problem, respectively[10]. The subsetwise spanner problem where $t$ is arbitrarily large is known as the Steiner tree problem on graphs.

1.1 Multi-level graph spanners

In many network design problems, vertices or edges come with a natural notion of priority, grade of service, or level; see Fig. 1. For example, consider the case of rebuilding a transportation infrastructure network after a natural disaster. Following such an event, the rebuilding process may wish to prioritize connections between important buildings such as hospitals or distribution centers, making these higher level terminals, while ensuring that no person must travel an excessive distance to reach their destination. Such problems have been referred to by names such as hierarchical network design, grade of service problems, multi-level, multi-tier, and have applications in network routing and visualization.

Similar to other graph problems which generalize to multiple levels or grades of service [8], we extend the subsetwise spanner problem to the multi-level graph spanner (MLGS) problem:

Definition 1

[Multi-level graph spanner (MLGS) problem] Given a graph $G(V,E)$ with positive edge weights $c:E\to\mathbb{R}_{+}$, a nested sequence of terminals, $T_{\ell}\subseteq T_{\ell-1}\subseteq\ldots\subseteq T_{1}\subseteq V$, and a real number $t\geq 1$, compute a minimum-cost sequence of spanners $G_{\ell}\subseteq G_{\ell-1}\subseteq\ldots\subseteq G_{1}$, where $G_{i}$ is a subsetwise $(T_{i}\times T_{i})$–spanner for $G$ with stretch factor $t$ for $i=1,\dots,\ell$. The cost of a solution is defined as the sum of the edge weights on each graph $G_{i}$, i.e., $\sum_{i=1}^{\ell}\sum_{e\in E(G_{i})}c_{e}$.

We refer to $T_{i}$ and $G_{i}$ as the terminals and the graph on level $i$. A more general version of the MLGS problem can involve different stretch factors on each level or a more general definition of cost, but for now we use the same stretch factor $t$ for each level.

An equivalent formulation of the MLGS problem which we use interchangeably involves grades of service: given $G=(V,E)$ with edge weights, and required grades of service $R:V\to\{0,1,\ldots,\ell\}$, compute a single subgraph $H\subseteq G$ with varying grades of service on the edges, with the property that for all $u,v\in V$, if $u$ and $v$ each have required a grade of service greater than or equal to $i$, then there exists a path in $H$ from $u$ to $v$ using edges with a grade of service greater than or equal to $i$, and whose length is at most $t\cdot d_{G}(u,v)$. Thus, $T_{\ell}=\{v\in V\mid R(v)=\ell\}$, $T_{\ell-1}=\{v\in V\mid R(v)\geq\ell-1\}$, and so on. If $y_{e}$ denotes the grade of edge $e$ (or the number of levels $e$ appears in), then the cost of a solution is equivalently $\sum_{e\in H}c_{e}y_{e}$, that is, edges with a higher grade of service incur a greater cost. This interpretation makes it clear that more important vertices (e.g., hubs) are connected with higher quality edges; see example instance and solution in Fig. 2.

If $t$ is arbitrarily large, the MLGS problem reduces to the multi-level Steiner tree (MLST) problem[1]. However it is worth noting that the problem of computing or approximating spanners is significantly harder than that of computing Steiner trees, and that a Steiner tree of $G$ may be an arbitrarily poor spanner; a cycle on $|V|$ vertices with one edge removed is a possible Steiner tree of $G$, but is only a $(|V|-1)$-spanner of $G$. The techniques used here have similarities to those used in the MLST problem, but more sophisticated methods are needed as well, including the use of approximate distance preservers and a new ILP formulation for the pairwise spanner problem.

1.2 Related work

Spanners and variants thereof have been studied for at least three decades, so we focus on results relating to pairwise or subsetwise spanners. Althöfer et al. [2] provide a simple greedy algorithm that constructs a multiplicative $r$–spanner given a graph $G$ and a real number $r>0$. The greedy algorithm sorts edges in $E$ by nondecreasing weight, then for each $e=\{u,v\}\in E$, computes the shortest path $P(u,v)$ from $u$ to $v$ in the current spanner, and adds the edge to the spanner if the weight of $P(u,v)$ is greater than $r\cdot c_{e}$. The resulting subgraph $H$ is a $r$–spanner for $G$. The main result of [2] is that, given a weighted graph $G$ and $t\geq 1$, there is a greedy $(2t+1)$–spanner $H$ containing at most $n\lceil n^{1/t}\rceil$ edges, and whose weight is at most $w(MST(G))(1+\frac{n}{2t})$ where $w(MST(G))$ denotes the weight of a minimum spanning tree of $G$.

Sigurd and Zachariasen [17] present an ILP formulation for the minimum-weight pairwise spanner problem (see Section 3), and show that the greedy algorithm [2] performs well on sparse graphs of up to 64 vertices. Álvarez-Miranda and Sinnl [3] present a mixed ILP formulation for the tree $t^{*}$–spanner problem, which asks for a spanning tree of a graph $G$ with the smallest stretch factor $t^{*}$.

Dinitz et al. [13] provide a flow-based linear programming (LP) relaxation to approximate the directed spanner problem. Their LP formulation is similar to that in [17]; however, they provide an approximation algorithm which relaxes their ILP, whereas the previous formulation was used to compute spanners to optimality. Additionally, the LP formulation applies to graphs of unit edge cost; they later take care of it in their rounding algorithm by solving a shortest path arborescence problem. They provide a $\tilde{O}(n^{\frac{2}{3}})$–approximation algorithm for the directed $k$–spanner problem for $k\geq 1$, which is the first sublinear approximation algorithm for arbitrary edge lengths. Bhattacharyya et al. [6] provide a slightly different formulation to approximate $t$–spanners as well as other variations of this problem. They provide a polynomial time $O((n\log n)^{1-\frac{1}{k}})$–approximation algorithm for the directed $k$–spanner problem. Berman et al. [5] provide an alternative randomized LP rounding schemes that lead to better approximation ratios. They improved the approximation ratio to $O(\sqrt{n}\log n)$ where the approximation ratio of the algorithm provided by Dinitz et al. [13] was $O(n^{\frac{2}{3}})$. They have also improved the approximation ratio for the important special case of directed 3–spanners with unit edge lengths.

There are several results on multi-level or grade-of-service Steiner trees, e.g., [1, 4, 8, 9, 16], while multi-level spanner problems have not been studied yet.

2 Approximation algorithms for MLGS

Here, we assume an oracle subroutine that computes an optimal $(S\times S)$–spanner, given a graph $G$, subset $S\subseteq V$, and $t$. The intent is to determine if approximating MLGS is significantly harder than the subsetwise spanner problem. We formulate simple bottom-up and top-down approaches for the MLGS problem.

2.1 Oracle bottom-up approach

The approach is as follows: compute a minimum subsetwise $(T_{1}\times T_{1})$–spanner of $G$ with stretch factor $t$. This immediately induces a feasible solution to the MLGS problem, as one can simply copy each edge from the spanner to every level (or, in terms of grades of service, assign grade $\ell$ to each spanner edge). We then prune edges that are not needed on higher levels. It is easy to show that the solution returned has cost no worse than $\ell$ times the cost of the optimal solution. Let OPT denote the cost of the optimal MLGS $G_{\ell}^{*}\subseteq G_{\ell-1}^{*}\subseteq\ldots\subseteq G_{1}^{*}$ for a graph $G$. Let $\text{MIN}_{i}$ denote the cost of a minimum subsetwise $(T_{i}\times T_{i})$–spanner for level $i$ with stretch $t$, and let BOT denote the cost computed by the bottom-up approach. If no pruning is done, then $\text{BOT}=\ell\text{MIN}_{1}$.

Theorem 2.1

The oracle bottom-up algorithm described above yields a solution that satisfies $\text{BOT}\leq\ell\cdot\text{OPT}$.

Proof

We know $\text{MIN}_{1}\leq\text{OPT}$, since the lowest-level graph $G_{1}^{*}$ is a $(T_{1}\times T_{1})$–spanner whose cost is at least $\text{MIN}_{1}$. Further, we have $\text{BOT}=\ell\text{MIN}_{1}$ if no pruning is done. Then $\text{MIN}_{1}\leq\text{OPT}\leq\text{BOT}=\ell\cdot\text{MIN}_{1}$, so $\text{BOT}\leq\ell\cdot\text{OPT}$. $\square$

The ratio of $\ell$ is asymptotically tight; an example can be constructed by letting $G$ be a cycle containing $t$ vertices and all edges of cost 1. Let two adjacent vertices in $G$ appear in $T_{\ell}$, while all vertices appear in $T_{1}$, as shown in Figure 3. As $t\to\infty$, the ratio $\frac{\text{BOT}}{\text{OPT}}$ approaches $\ell$. Note that in this example, no edges can be pruned without violating the $t$–spanner requirement.

We give a simple heuristic that attempts to “prune” unneeded edges without violating the $t$–spanner requirement. Note that any pruning strategy may not prune any edges, as a worst case example (Figure 3) cannot be pruned. Let $G_{1}$ be the $(T_{1}\times T_{1})$–spanner computed by the bottom-up approach. To compute a $(T_{2}\times T_{2})$–spanner $G_{2}$ using the edges from $G_{1}$, we can compute a distance preserver of $G_{1}$ over terminals in $T_{2}$. One simple strategy is to use shortest paths as explained below.

Even more efficient pruning is possible through the distant preserver literature [10, 7]. A well-known result of distant preservers is due to the following theorem:

Theorem 2.2 ([10])

Given $G=(V,E)$ with $|V|=n$, and $P\subset{V\choose 2}$, there exists a subgraph $G^{\prime}$ with $O(n+\sqrt{n}|P|)$ edges such that for all $(u,v)\in P$ we have $d_{G^{\prime}}(u,v)=d_{G}(u,v)$.

The above theorem hints at a sparse construction of $G_{2}$ simply by letting $P=T_{2}\times T_{2}$. Given $G_{1}$, let $G_{i}$ be a distance preserver of $G_{i-1}$ over the terminals $T_{i}$, for all $i=2,\ldots,\ell$. An example is to let $G_{2}$ be the union of all shortest paths (in $G_{1}$) over vertices $v,w\in G_{2}$. The result is clearly a feasible solution to the MLGS problem, as the shortest paths are preserved exactly from $G_{1}$, so each $G_{i}$ is a $(T_{i}\times T_{i})$–spanner of $G$ with stretch factor $t$.

2.2 Oracle top-down approach

A simple top-down heuristic that computes a solution is as follows: let $G_{\ell}$ be the minimum-cost $(T_{\ell}\times T_{\ell})$–spanner over terminals $T_{\ell}$ with stretch factor $t$, and cost $\text{MIN}_{\ell}$. Then compute a minimum cost $(T_{\ell-1}\times T_{\ell-1})$–spanner over $T_{\ell-1}$, and let $G_{\ell-1}$ be the union of this spanner and $G_{\ell}$. Continue this process, where $G_{i}$ is the union of the minimum cost $(T_{i}\times T_{i})$–spanner and $G_{i+1}$. Clearly, this produces a feasible solution to the MLGS problem.

The solution returned by this approach, with cost denoted by TOP, is not worse than $\frac{\ell+1}{2}$ times the optimal. Define $\text{MIN}_{i}$ and OPT as before. Define $\text{OPT}_{i}$ to be the cost of edges on level $i$ but not level $i+1$ in the optimal MLGS solution, so that $\text{OPT}=\ell\text{OPT}_{\ell}+(\ell-1)\text{OPT}_{\ell-1}+\ldots+\text{OPT}_{1}$. Define $\text{TOP}_{i}$ analogously.

Theorem 2.3

The oracle top-down algorithm described above yields an approximation that satisfies the following:

1. (i)

$\text{TOP}_{\ell}\leq\text{OPT}_{\ell},$** 2. (ii)

$\text{TOP}_{i}\leq\text{OPT}_{i}+\text{OPT}_{i+1}+\ldots+\text{OPT}_{\ell},\quad i=1,\dots,\ell-1,$** 3. (iii)

$\text{TOP}\leq\frac{\ell+1}{2}\text{OPT}.$**

Proof

Inequality (i) is true by definition, as we compute an optimal $(T_{\ell}\times T_{\ell})$–spanner whose cost is $\text{TOP}_{\ell}$, while $\text{OPT}_{\ell}$ is the cost of some $(T_{\ell}\times T_{\ell})$-spanner. For (ii), note that $\text{TOP}_{i}\leq\text{MIN}_{i}$, with equality when the minimum-cost $(T_{i}\times T_{i})$–spanner and $G_{i+1}$ are disjoint. The spanner of cost $\text{OPT}_{i}+\text{OPT}_{i+1}+\ldots+\text{OPT}_{\ell}$ is a feasible $(T_{i}\times T_{i})$–spanner, so $\text{MIN}_{i}\leq\text{OPT}_{i}+\ldots+\text{OPT}_{\ell}$, which shows (ii).

To show (iii), note that (i) and (ii) imply

[TABLE]

as by definition $\text{OPT}=\ell\text{OPT}_{\ell}+(\ell-1)\text{OPT}_{\ell-1}+\ldots+\text{OPT}_{1}$. $\square$

The ratio $\frac{\ell+1}{2}$ is tight as illustrated in Figure 3, left.

2.3 Combining top-down and bottom-up

Again, assume we have access to an oracle that computes a minimum weight $(S\times S)$–spanner of an input graph $G$ with given stretch factor $t$. A simple combined method, similar to [1], is to run the top-down and bottom-up approaches for the MLGS problem, and take the solution with minimum cost. This has a slightly better approximation ratio than either of the two approaches.

Theorem 2.4

The solution whose cost is $\min(\text{TOP},\text{BOT})$ is not worse than $\dfrac{\ell+2}{3}$ times the cost OPT of the optimal MLGS.

The proof is given in Appendix 0.A.

2.4 Heuristic subsetwise spanners

So far, we have assumed that we have access to an optimal subsetwise spanner given by an oracle. Here we propose a heuristic algorithm to compute subsetwise spanner. The key idea is to apply the greedy spanner to an auxiliary complete graph with terminals as its vertices and the shortest distance between terminals as edge weights. Then, we apply the distance preserver discussed in Theorem 2.2 to construct a subsetwise spanner.

Theorem 2.5

Given graph $G(V,E)$, stretch factor $t\geq 1$, and subset $T\subset V$, there exists a $(T\times T)$–spanner for $G$ with stretch factor $t$ and $O(n+\sqrt{n}|T|^{1+\frac{2}{t+1}})$ edges.

Proof

The spanner may be constructed as follows:

Construct the terminal complete graph $\bar{G}$ whose vertices are $\bar{V}:=T$, such that the weight of each edge $\{u,v\}$ in $\bar{G}$ is the length of the shortest path connecting them in $G$, i.e., $w(u,v)=d_{G}(u,v)$. 2. 2.

Construct a greedy $t-$spanner $\bar{H}(\bar{V},\bar{E}^{\prime})$ of $\bar{G}$. According to [2], this graph has $|T|^{1+\frac{2}{t+1}}$ edges. Let $P=\bar{E}^{\prime}$. 3. 3.

Apply Theorem 2.2 to obtain a subgraph $H$ of $G$ such that for all $(u,v)\in P$ we have $d_{H}(u,v)=d_{G}(u,v)$. Therefore, for arbitrary $u,v\in T$ we get $d_{H}(u,v)\leq t\,d_{G}(u,v)$. 4. 4.

Finally, let shortest-path$(u,v)$ be the collection of edges in the shortest path from $u$ to $v$ in $H$, and

[TABLE]

According to Theorem 2.2, the number of edges in the constructed spanner $H(V,E)$ is $O(n+\sqrt{n}|P|)=O\left(n+\sqrt{n}|T|^{1+\frac{2}{t+1}}\right)$. $\square$

Hence, we may replace the oracle in the top-down and bottom-up approaches (Sections 2.1-2.2) with the above heuristic; we call the resulting algorithms heuristic top-down and heuristic bottom-up. We analyze the performance of all algorithms on several types of graphs.

Incorporating the heuristic subsetwise spanner in our top-down and bottom up heuristics has two implications. First, the size of the final MLGS is dominated by the size of the spanner at the bottom level, i.e., $O(n+\sqrt{n}|P|)=O\left(n+\sqrt{n}|T_{1}|^{1+\frac{2}{t+1}}\right)$. Second, since the greedy spanner algorithm used in the above subsetwise spanner can produce spanners that are $O(n)$ more costly than the optimal solution, the same applies to the subsetwise spanner. Our experimental results, however, indicate that the heuristic approaches are very close to the optimal solutions obtained via our ILP.

3 Integer linear programming (ILP) formulations

We describe the original ILP formulation for the pairwise spanner problem [17]. Let $K=\{(u_{i},v_{i})\}\subset V\times V$ be the set of vertex pairs; recall that the $t$–spanner problem is a special case where $K=V\times V$. Here we will use unordered pairs of distinct vertices, so in the $t$–spanner problem we have $|K|=\binom{|V|}{2}$ instead of $|V|^{2}$. This ILP formulation uses paths as decision variables. Given $(u,v)\in K$, denote by $P_{uv}$ the set of paths from $u$ to $v$ of cost no more than $t\cdot d_{G}(u,v)$, and denote by $P$ the union of all such paths, i.e., $P=\bigcup_{(u,v)\in K}P_{uv}$. Given a path $p\in P$ and edge $e\in E$, let $\delta_{p}^{e}=1$ if $e$ is on path $p$, and [math] otherwise. Let $x_{e}=1$ if $e$ is an edge in the pairwise spanner $H$, and [math] otherwise. Given $p\in P$, let $y_{p}=1$ if path $p$ is in the spanner, and zero otherwise. An ILP formulation for the pairwise spanner problem is given below.

[TABLE]

Constraint (3) ensures that for each pair $(u,v)\in K$, at least one $t$–spanner path is selected, and constraint (2) enforces that on the selected $u$-$v$ path, every edge along the path appears in the spanner. The main drawback of this ILP is that the number of path variables is exponential in the size of the graph. The authors use delayed column generation by starting with a subset $P^{\prime}\subset P$ of paths, with the starting condition that for each $(u,v)\in K$, at least one $t$–spanner path in $P_{uv}$ is in $P^{\prime}$. The authors leave as an open question whether this problem admits a useful polynomial-size ILP.

We introduce a 0-1 ILP formulation for the pairwise $t$–spanner problem based on multicommodity flow, which uses $O(|E||K|)$ variables and constraints, where $|K|=O(|V|^{2})$. Define $t$, $c_{e}$, $d_{G}(u,v)$, $K$, and $x_{e}$ as before. Note that $d_{G}(u,v)$ can be computed in advance, using any all-pairs shortest path (APSP) method.

Direct the graph by replacing each edge $e=\{u,v\}$ with two edges $(u,v)$ and $(v,u)$ of weight $c_{e}$. Let $E^{\prime}$ be the set of all directed edges, i.e., $|E^{\prime}|=2|E|$. Given $(i,j)\in E^{\prime}$, and an unordered pair of vertices $(u,v)\in K$, let $x_{(i,j)}^{uv}=1$ if edge $(i,j)$ is included in the selected $u$-$v$ path in the spanner $H$, and 0 otherwise. This definition of path variables is similar to that by Álvarez-Miranda and Sinnl [3] for the tree $t^{*}$–spanner problem. We select a total order of all vertices so that the path constraints (8)–(9) are well-defined. This induces $2|E||K|$ binary variables, or $2|E|\binom{|V|}{2}=2|E||V|(|V|-1)$ variables in the standard $t$–spanner problem. Note that if $u$ and $v$ are connected by multiple paths in $H$ of length $\leq t\cdot d_{G}(u,v)$, we need only set $x_{(i,j)}^{uv}=1$ for edges along some path. Given $v\in V$, let $In(v)$ and $Out(v)$ denote the set of incoming and outgoing edges for $v$ in $E^{\prime}$. In (7)–(11) we assume $u<v$ in the total order, so spanner paths are from $u$ to $v$. An ILP formulation for the pairwise spanner problem is as follows.

[TABLE]

Constraint (7) requires that for all $(u,v)\in K$, the sum of the weights of the selected edges corresponding to the pair $(u,v)$ is not more than $t\cdot d_{G}(u,v)$. Constraints (8)–(9) require that the selected edges corresponding to $(u,v)\in K$ form a simple path beginning at $u$ and ending at $v$. Constraint (10) enforces that, if edge $(i,j)$ or $(j,i)$ is selected on some $u$-$v$ path, then its corresponding undirected edge $e$ is selected in the spanner; further, $(i,j)$ and $(j,i)$ cannot both be selected for some pair $(u,v)$. Finally, (11) enforces that all variables are binary.

The number of variables is $|E|+2|E||K|$ and the number of constraints is $O(|E||K|)$, where $|K|=O(|V|^{2})$. Note that the variables $x_{(i,j)}^{uv}$ can be relaxed to be continuous in $[0,1]$.

3.1 ILP formulation for the MLGS problem

Recall that the MLGS problem generalizes the subsetwise spanner problem, which is a special case of the pairwise spanner problem for $K=S\times S$. Again, we use unordered pairs, i.e., $|K|=\binom{|S|}{2}$.

We generalize the ILP formulation in (6)–(11) to the MLGS problem as follows. Recall that we can encode the levels in terms of required grades of service $R:V\to\{0,1,\ldots,\ell\}$. Instead of 0–1 indicators $x_{e}$, let $y_{e}$ denote the grade of edge $e$ in the multi-level spanner; that is, $y_{e}=i$ if $e$ appears on level $i$ but not level $i+1$, and $y_{e}=0$ if $e$ is absent. The only difference is that for the MLGS problem, we assign grades of service to all $u$-$v$ paths by assigning grades to edges along each $u$-$v$ path. That is, for all $u,v\in T_{1}$ with $u<v$, the selected path from $u$ to $v$ has grade $\min(R(u),R(v))$, which we denote by $m_{uv}$. Note that we only need to require the existence of a path for terminals $u,v\in T_{1}$, where $u<v$. An ILP formulation for the MLGS problem is as follows.

[TABLE]

Constraints (16)–(17) enforce that for each pair $u,v\in V$ such that $u<v$, the edges along the selected $u$-$v$ path (not necessarily every $u$-$v$ path) have a grade of service greater than or equal to the minimum grade of service needed to connect $u$ and $v$, that is, $m_{uv}$. If multiple pairs $(u_{1},v_{1})$, $(u_{2},v_{2})$, …, $(u_{k},v_{k})$ use the same edge $e=\{i,j\}$ (possibly in opposite directions), then the grade of edge $e$ should be $y_{e}=\max(m_{u_{1}v_{1}},m_{u_{2}v_{2}},\ldots,m_{u_{k}v_{k}})$. It is implied by (16)–(17) that $0\leq y_{e}\leq\ell$ in an optimal solution.

Theorem 3.1

An optimal solution to the ILP given in (6)–(11) yields an optimal pairwise spanner of $G$ over a set $K\subset V\times V$.

Theorem 3.2

An optimal solution to the ILP given in (12)–(18) yields an optimal solution to the MLGS problem.

We give the proofs in Appendices 0.B and 0.C.

3.2 Size reduction techniques

We can reduce the size of the ILP using the following shortest path tests, which works well in practice and also applies to the MLGS problem. Note that we are concerned with the total cost of a solution, not the number of edges.

If $d_{G}(i,j)<c(i,j)$, for some edge $\{i,j\}\in E$, then we can remove $\{i,j\}$ from the graph, as no min-weight spanner of $G$ uses edge $\{i,j\}$. If $H^{*}$ is a min-cost pairwise spanner that uses edge $\{i,j\}$, then we can replace $\{i,j\}$ with a shorter $i$-$j$ path $p_{ij}$ without violating the $t$–spanner requirement. In particular, if some $u$-$v$ path uses both edge $\{i,j\}$ as well as some edge(s) along $p_{ij}$, then this path can be rerouted to use only edges in $p_{ij}$ with smaller cost.

We reduce the number of variables needed in the single-level ILP formulation ((6)–(11)) with the following test: given $u,v\in K$ with $u<v$ and some directed edge $(i,j)\in E^{\prime}$, if $d_{G}(u,i)+c(i,j)+d_{G}(j,v)>t\cdot d_{G}(u,v)$, then $(i,j)$ cannot possibly be included in the selected $u$-$v$ path, so set $x_{(i,j)}^{uv}=0$. If $(i,j)$ or $(j,i)$ cannot be selected on any $u$-$v$ path, we can safely remove $\{i,j\}$ from $E$.

Conversely, given some directed edge $(i,j)\in E^{\prime}$, let $G^{\prime}$ be the directed graph obtained by removing $(i,j)$ from $E^{\prime}$ (so that $G^{\prime}$ has $2|E|-1$ edges). For each $u,v\in K$ with $u<v$, if $d_{G^{\prime}}(u,v)>t\cdot d_{G}(u,v)$, then edge $(i,j)$ must be in any $u$-$v$ spanner path, so set $x_{(i,j)}^{uv}=1$. For its corresponding undirected edge $e$, $x_{e}=1$.

4 Experimental results

4.1 Setup

We use the Erdős–Rényi [14] and Watts–Strogatz [18] models to generate random graphs. Given a number of vertices, $n$, and probability $p$, the model $\textsc{ER}(n,p)$ assigns an edge to any given pair of vertices with probability $p$. An instance of $\textsc{ER}(n,p)$ with $p=(1+\varepsilon)\frac{\ln n}{n}$ is connected with high probability for $\varepsilon>0$ [14]). For our experiments we use $n\in\{20,40,60,80,100\}$, and $\varepsilon=1$.

In the Watts-Strogatz model, $\textsc{WS}(n,K,\beta)$, initially we create a ring lattice of constant degree $K$, and then rewire each edge with probability $0\leq\beta\leq 1$ while avoiding self-loops and duplicate edges. The Watts-Strogatz model generates small-world graphs with high clustering coefficients [18]. For our experiments we use $n\in\{20,40,60,80,100\}$, $K=6$, and $\beta=0.2$.

An instance of the MLGS problem is characterized by four parameters: graph generator, number of vertices $|V|$, number of levels $\ell$, and stretch factor $t$. As there is randomness involved, we generated 3 instances for every choice of parameters (e.g., ER, $|V|=80$, $\ell=3$, $t=2$).

We generated MLGS instances with 1, 2, or 3 levels ($\ell\in\{1,2,3\}$), where terminals are selected on each level by randomly sampling $\lfloor{|V|\cdot(\ell-i+1)}/(\ell+1)\rfloor$ vertices on level $i$ so that the size of the terminal sets decreases linearly. As the terminal sets are nested, $T_{i}$ can be selected by sampling from $T_{i-1}$ (or from $V$ if $i=1$). We used four different stretch factors in our experiments, $t\in\{1.2,1.4,2,4\}$. Edge weights are randomly selected from $\{1,2,3,\ldots,10\}$.

4.1.1 Algorithms and outputs

We implemented the bottom-up (BU) and top-down (TD) approaches from Section 2 in Python 3.5, as well as the combined approach that selects the better of the two (Section 2.3). To evaluate the approximation algorithms and the heuristics, we implemented the ILPs described in Section 3 using CPLEX 12.6.2. We used the same high-performance computer for all experiments (Lenovo NeXtScale nx360 M5 system with 400 nodes).

For each instance of the MLGS problem, we compute the costs of the MLGS returned using the bottom-up (BU), the top-down (TD), and the combined (min(BU, TD)) approaches, as well as the minimum cost MLGS using the ILP in Section 3.1. The three heuristics involve a (single-level) subroutine; we used both the heuristic described in Section 2.4, as well as the flow formulation described in Section 3 which computes subsetwise spanners to optimality. We compare the algorithms with and without the oracle to assess whether computing (single-level) spanners to optimality significantly improves the overall quality of the solution.

We show the performance ratio for each heuristic in the $y$-axis (defined as the heuristic cost divided by OPT), and how the ratio depends on the input parameters (number of vertices $|V|$, number of levels $\ell$, and stretch factors $t$). Finally, we discuss the running time of the ILP. All box plots show the minimum, interquartile range and maximum, aggregated over all instances using the parameter being compared.

4.2 Results

We first discuss the results for Erdős–Rényi graphs. Figures 4–7 show the results of the oracle top-down, bottom-up, and combined approaches. We show the impact of different parameters (number of vertices $|V|$, number of levels $\ell$, and stretch factors $t$) using line plots for three heuristics separately in Figures 4-6. Figure 7 shows the performance of the three heuristics together in box plots. In Figure 4 we can see that the bottom-up heuristic performs slightly worse for increasing $|V|$, while the top-down heuristic performs slightly better. In Figure 5 we see that the heuristics perform worse when $\ell$ increases, consistent with the ratios discussed in Section 2. In Figure 6 we show the performance of the heuristics with respect to the stretch factor $t$. In general, the performance becomes worse as $t$ increases.

The most time consuming part of the experiment is the execution time of the ILP for solving MLGS instances optimally. The running time of the heuristics is significantly smaller compared to that of the ILP. Hence, we first show the running times of the exact solution of the MLGS instances in Figure 8. We show the running time with respect to the number of vertices $|V|$, number of levels $\ell$, and stretch factors $t$. For all parameters, the running time tends to increase as the size of the parameter increases. In particular, the running time with stretch factor 4 (Fig. 8, right) was much worse, as there are many more $t$-spanner paths to consider, and the size reduction techniques in Section 3.2 are less effective at reducing instance size. We show the running times of for computing oracle bottom-up, top-down and combined solutions in Figure 9.

The ILP is too computationally expensive for larger input sizes and this is where the heurstic can be particularly useful. We now consider a similar experiment using the heuristic to compute subsetwise spanners, as described in Section 2.4. We show the impact of different parameters (number of vertices $|V|$, number of levels $\ell$, and stretch factors $t$) using scatter plots for three heuristics separately in Figures 10–12. Figure 13 shows the performance of the three heuristics together in box plots. We can see that the heuristics perform very well in practice. Notably when the heuristic is used in place of the ILP (Fig 24), the running times decrease for larger stretch factors.

We also analyzed graphs generated from the Watts–Strogatz model and the results are shown in Appendix 0.D.

Our final experiments test the heuristic performance on a set of larger graphs. We generated the graphs using the Erdős–Rényi model, with $|V|\in\{100,200,300,400\}$. We evaluated more levels ($\ell\in\{2,4,6,8,10\}$) with stretch factors $t\in\{1.2,1.4,2,4\}$. We show the performance of heuristic bottom-up and top-down in Appendix 0.E. Here, the ratio is determined by dividing the BU or TD cost by $\min(BU,TD)$ (as computing the optimal MLGS would be too time-consuming). The results indicate that while running times increase with larger input graphs, the number of levels and the stretch factors seem to have little impact on performance.

5 Discussion and conclusion

We introduced a generalization of the subsetwise spanner problem to multiple levels or grades of service. Our proposed ILP formulation requires only a polynomial size of variables and constraints, which is an improvement over the previous formulation given by Sigurd and Zachariasen [17]. We also proposed improved formulations which work well for small values of the stretch factor $t$. It would be worthwhile to consider whether even better ILP formulations can be found for computing graph spanners and their multi-level variants. We showed that both the approximation algorithms and the heuristics work well in practice on several different types of graphs, with different number of levels and different stretch factors.

We only considered a stretch factor $t$ that is the same for all levels in the multi-level spanner, as well as a fairly specific definition of cost. It would be interesting to investigate more general multi-level or grade-of-service spanner problems, including ones with varying stretch factors (e.g., in which more important terminals require a smaller or larger stretch factors), different definitions of cost, and spanners with other requirements, such as bounded diameters or degrees.

Appendix 0.A Proof of Theorem 2.4

Proof

We use the simple algebraic fact that $\min\{x,y\}\leq\alpha x+(1-\alpha)y$ for all $x,y\in\mathbb{R}$ and $\alpha\in[0,1]$. Here, we can also use the fact that $\text{MIN}_{1}\leq\text{OPT}_{1}+\text{OPT}_{2}+\ldots+\text{OPT}_{\ell}$, as the RHS equals the cost of $G_{1}^{*}$, which is some subsetwise $(T_{1}\times T_{1})$-spanner. Combining, we have

[TABLE]

Since we are comparing $\min\{\text{TOP},\text{BOT}\}$ to $r\cdot\text{OPT}$ for some approximation ratio $r>1$, we can compare coefficients and find the smallest $r\geq 1$ such that the system of inequalities

[TABLE]

has a solution $\alpha\in[0,1]$. Adding the first inequality to $\ell/2$ times the last inequality yields $\frac{\ell^{2}+2\ell}{2}\leq\frac{3\ell r}{2}$, or $r\geq\frac{\ell+2}{3}$. Also, it can be shown algebraically that $(r,\alpha)=(\frac{\ell+2}{3},\frac{2}{3})$ simultaneously satisfies the above inequalities. This implies that $\min\{\text{TOP},\text{BOT}\}\leq\frac{\ell+2}{3}\rho\cdot\text{OPT}$. $\square$

Appendix 0.B Proof of Theorem 3.1

Proof

Let $H^{*}$ denote an optimal pairwise spanner of $G$ with stretch factor $t$, and let OPT denote the cost of $H^{*}$. Let $\text{OPT}_{ILP}$ denote the minimum cost of the objective in the ILP (6). First, given a minimum cost $t$–spanner $H^{*}(V,E^{*})$, a solution to the ILP can be constructed as follows: for each edge $e\in E^{*}$, set $x_{e}=1$. Then for each unordered pair $(u,v)\in K$ with $u<v$, compute a shortest path $p_{uv}$ from $u$ to $v$ in $H^{*}$, and set $x_{(i,j)}^{uv}=1$ for each edge along this path, and $x_{(i,j)}^{uv}=0$ if $(i,j)$ is not on $p_{uv}$.

As each shortest path $p_{uv}$ necessarily has cost $\leq t\cdot d_{G}(u,v)$, constraint (7) is satisfied. Constraints (8)–(9) are satisfied as $p_{uv}$ is a simple $u$-$v$ path. Constraint (10) also holds, as $p_{uv}$ should not traverse the same edge twice in opposite directions. In particular, every edge in $H^{*}$ appears on some shortest path; otherwise, removing such an edge yields a pairwise spanner of lower cost. Hence $\text{OPT}_{ILP}\leq\text{OPT}$.

Conversely, an optimal solution to the ILP induces a feasible $t$–spanner $H$. Consider an unordered pair $(u,v)\in K$ with $u<v$, and the set of decision variables satisfying $x_{(i,j)}^{uv}=1$. By (8) and (9), these chosen edges form a simple path from $u$ to $v$. The sum of the weights of these edges is at most $t\cdot d_{G}(u,v)$ by (7). Then by constraint (10), the chosen edges corresponding to $(u,v)$ appear in the spanner, which is induced by the set of edges $e$ with $x_{e}=1$. Hence $\text{OPT}\leq\text{OPT}_{ILP}$.

Combining the above observations, we see that $\text{OPT}=\text{OPT}_{ILP}$. $\square$

Appendix 0.C Proof of Theorem 3.2

Proof

Given an optimal solution to the ILP with cost $\text{OPT}_{ILP}$, construct an MLGS by letting $G_{i}=(V,E_{i})$ where $E_{i}=\{e\in E\mid y_{e}\geq i\}$. This clearly gives a nested sequence of subgraphs. Let $u$ and $v$ be terminals in $T_{i}$ (not necessarily of required grade $R(\cdot)=i$), with $u<v$, and consider the set of all variables of the form $x_{(i,j)}^{uv}$ equal to 1. By (13)–(15), these selected edges form a path from $u$ to $v$ of length at most $t\cdot d_{G}(u,v)$, while constraints (16)–(17) imply that these selected edges have grade at least $m_{uv}\geq i$, so the selected path is contained in $E_{i}$. Hence $G_{i}$ is a subsetwise $(T_{i}\times T_{i})$–spanner for $G$ with stretch factor $t$, and the optimal ILP solution gives a feasible MLGS.

Given an optimal MLGS with cost OPT, we can construct a feasible ILP solution with the same cost in a way similar to the proof of Theorem 3.1. For each $u,v\in T_{1}$ with $u<v$, set $m_{uv}=\min(R(u),R(v))$. Compute a shortest path in $G_{m_{uv}}$ from $u$ to $v$, and set $x_{(i,j)}^{uv}=1$ for all edges along this path. Then for each $e\in E$, consider all pairs $(u_{1},v_{1}),\ldots,(u_{k},v_{k})$ that use either $(i,j)$ or $(j,i)$, and set $y_{e}=\max(m_{u_{1}v_{1}},m_{u_{2}v_{2}},\ldots,m_{u_{k}v_{k}})$. In particular, $y_{e}$ is not larger than the grade of $e$ in the MLGS, otherwise this would imply $e$ is on some $u$-$v$ path at grade greater than its grade of service in the actual solution. $\square$

Appendix 0.D Experimental results on graphs generated using Watts-Strogatz

The results for graphs generated from the Watts–Strogatz model are shown in Figures 15–23, which are organized in the same way as for Erdős–Rényi.

Appendix 0.E Experimental results on large graphs using Erdős-Rényi

Figure 24 shows a rough measure of performance for the bottom-up and top-down heuristics on large graphs using the Erdős-Rényi model, where the ratio is defined as the BU or TD cost divided by min(BU, TD). Figure 25 shows the aggregated running times per instance, which significantly worsen as $|V|$ is large.