1 Introduction
Given an undirected edgeweighted graph and a real number , a subgraph is a (multiplicative) –spanner of if the lengths of shortest paths in are preserved in up to a multiplicative factor of ; that is, for all , where is the length of the shortest path from to in . We refer to as the stretch factor of . Peleg et al. [12] show that determining if there exists a –spanner of with or fewer edges is NP–complete. Further, it is NP–hard to approximate the (unweighted) –spanner problem to within a factor of , even when restricted to bipartite graphs [15].
In the pairwise spanner problem [11], distances only need to be preserved for a subset of pairs of vertices. Thus, the classical –spanner problem is a special case of the pairwise spanner problem where . The subsetwise spanner problem is a special case of the pairwise spanner problem where for some ; that is, distances need only be preserved between vertices in [11]. The case is known as the pairwise distance preserver or sourcewise distance preserver problem, respectively[10]. The subsetwise spanner problem where is arbitrarily large is known as the Steiner tree problem on graphs.
1.1 Multilevel 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, multilevel, multitier, 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 multilevel graph spanner (MLGS) problem:
Definition 1
[Multilevel graph spanner (MLGS) problem] Given a graph with positive edge weights , a nested sequence of terminals, , and a real number , compute a minimumcost sequence of spanners , where is a subsetwise –spanner for with stretch factor for . The cost of a solution is defined as the sum of the edge weights on each graph , i.e., .
We refer to and as the terminals and the graph on level . 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 for each level.
An equivalent formulation of the MLGS problem which we use interchangeably involves grades of service: given with edge weights, and required grades of service , compute a single subgraph with varying grades of service on the edges, with the property that for all , if and each have required a grade of service greater than or equal to , then there exists a path in from to using edges with a grade of service greater than or equal to , and whose length is at most . Thus, , , and so on. If denotes the grade of edge (or the number of levels appears in), then the cost of a solution is equivalently , 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 is arbitrarily large, the MLGS problem reduces to the multilevel 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 may be an arbitrarily poor spanner; a cycle on vertices with one edge removed is a possible Steiner tree of , but is only a spanner of . 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 –spanner given a graph and a real number . The greedy algorithm sorts edges in by nondecreasing weight, then for each , computes the shortest path from to in the current spanner, and adds the edge to the spanner if the weight of is greater than . The resulting subgraph is a –spanner for . The main result of [2] is that, given a weighted graph and , there is a greedy –spanner containing at most edges, and whose weight is at most where denotes the weight of a minimum spanning tree of .
Sigurd and Zachariasen [17] present an ILP formulation for the minimumweight pairwise spanner problem (see Section 3), and show that the greedy algorithm [2] performs well on sparse graphs of up to 64 vertices. ÁlvarezMiranda and Sinnl [3] present a mixed ILP formulation for the tree –spanner problem, which asks for a spanning tree of a graph with the smallest stretch factor .
Dinitz et al. [13] provide a flowbased 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 –approximation algorithm for the directed –spanner problem for , which is the first sublinear approximation algorithm for arbitrary edge lengths. Bhattacharyya et al. [6] provide a slightly different formulation to approximate –spanners as well as other variations of this problem. They provide a polynomial time –approximation algorithm for the directed –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 where the approximation ratio of the algorithm provided by Dinitz et al. [13] was . They have also improved the approximation ratio for the important special case of directed 3–spanners with unit edge lengths.
2 Approximation algorithms for MLGS
Here, we assume an oracle subroutine that computes an optimal –spanner, given a graph , subset , and . The intent is to determine if approximating MLGS is significantly harder than the subsetwise spanner problem. We formulate simple bottomup and topdown approaches for the MLGS problem.
2.1 Oracle bottomup approach
The approach is as follows: compute a minimum subsetwise –spanner of with stretch factor . 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 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 times the cost of the optimal solution. Let OPT denote the cost of the optimal MLGS for a graph . Let denote the cost of a minimum subsetwise –spanner for level with stretch , and let BOT denote the cost computed by the bottomup approach. If no pruning is done, then .
Theorem 2.1
The oracle bottomup algorithm described above yields a solution that satisfies .
Proof
We know , since the lowestlevel graph is a –spanner whose cost is at least . Further, we have if no pruning is done. Then , so .
The ratio of is asymptotically tight; an example can be constructed by letting be a cycle containing vertices and all edges of cost 1. Let two adjacent vertices in appear in , while all vertices appear in , as shown in Figure 3. As , the ratio approaches . Note that in this example, no edges can be pruned without violating the –spanner requirement.
We give a simple heuristic that attempts to “prune” unneeded edges without violating the –spanner requirement. Note that any pruning strategy may not prune any edges, as a worst case example (Figure 3) cannot be pruned. Let be the –spanner computed by the bottomup approach. To compute a –spanner using the edges from , we can compute a distance preserver of over terminals in . 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 wellknown result of distant preservers is due to the following theorem:
Theorem 2.2 ([10])
Given with , and , there exists a subgraph with edges such that for all we have .
The above theorem hints at a sparse construction of simply by letting . Given , let be a distance preserver of over the terminals , for all . An example is to let be the union of all shortest paths (in ) over vertices . The result is clearly a feasible solution to the MLGS problem, as the shortest paths are preserved exactly from , so each is a –spanner of with stretch factor .
2.2 Oracle topdown approach
A simple topdown heuristic that computes a solution is as follows: let be the minimumcost –spanner over terminals with stretch factor , and cost . Then compute a minimum cost –spanner over , and let be the union of this spanner and . Continue this process, where is the union of the minimum cost –spanner and . 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 times the optimal. Define and OPT as before. Define to be the cost of edges on level but not level in the optimal MLGS solution, so that . Define analogously.
Theorem 2.3
The oracle topdown algorithm described above yields an approximation that satisfies the following:
Proof
Inequality (i) is true by definition, as we compute an optimal –spanner whose cost is , while is the cost of some spanner. For (ii), note that , with equality when the minimumcost –spanner and are disjoint. The spanner of cost is a feasible –spanner, so , which shows (ii).
To show (iii), note that (i) and (ii) imply
TOP  
as by definition .
The ratio is tight as illustrated in Figure 3, left.
2.3 Combining topdown and bottomup
Again, assume we have access to an oracle that computes a minimum weight –spanner of an input graph with given stretch factor . A simple combined method, similar to [1], is to run the topdown and bottomup 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 is not worse than 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 , stretch factor , and subset , there exists a –spanner for with stretch factor and edges.
Proof
The spanner may be constructed as follows:

Construct the terminal complete graph whose vertices are , such that the weight of each edge in is the length of the shortest path connecting them in , i.e., .

Construct a greedy spanner of . According to [2], this graph has edges. Let .

Apply Theorem 2.2 to obtain a subgraph of such that for all we have . Therefore, for arbitrary we get .

Finally, let shortestpath be the collection of edges in the shortest path from to in , and
According to Theorem 2.2, the number of edges in the constructed spanner is .
Hence, we may replace the oracle in the topdown and bottomup approaches (Sections 2.12.2) with the above heuristic; we call the resulting algorithms heuristic topdown and heuristic bottomup. We analyze the performance of all algorithms on several types of graphs.
Incorporating the heuristic subsetwise spanner in our topdown 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., . Second, since the greedy spanner algorithm used in the above subsetwise spanner can produce spanners that are 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 be the set of vertex pairs; recall that the –spanner problem is a special case where . Here we will use unordered pairs of distinct vertices, so in the –spanner problem we have instead of . This ILP formulation uses paths as decision variables. Given , denote by the set of paths from to of cost no more than , and denote by the union of all such paths, i.e., . Given a path and edge , let if is on path , and otherwise. Let if is an edge in the pairwise spanner , and otherwise. Given , let if path is in the spanner, and zero otherwise. An ILP formulation for the pairwise spanner problem is given below.
(1)  
(2)  
(3)  
(4)  
(5) 
Constraint (3) ensures that for each pair , at least one –spanner path is selected, and constraint (2) enforces that on the selected  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 of paths, with the starting condition that for each , at least one –spanner path in is in . The authors leave as an open question whether this problem admits a useful polynomialsize ILP.
We introduce a 01 ILP formulation for the pairwise –spanner problem based on multicommodity flow, which uses variables and constraints, where . Define , , , , and as before. Note that can be computed in advance, using any allpairs shortest path (APSP) method.
Direct the graph by replacing each edge with two edges and of weight . Let be the set of all directed edges, i.e., . Given , and an unordered pair of vertices , let if edge is included in the selected  path in the spanner , and 0 otherwise. This definition of path variables is similar to that by ÁlvarezMiranda and Sinnl [3] for the tree –spanner problem. We select a total order of all vertices so that the path constraints (8)–(9) are welldefined. This induces binary variables, or variables in the standard –spanner problem. Note that if and are connected by multiple paths in of length , we need only set for edges along some path. Given , let and denote the set of incoming and outgoing edges for in . In (7)–(11) we assume in the total order, so spanner paths are from to . An ILP formulation for the pairwise spanner problem is as follows.
(6)  
(7)  
(8)  
(9)  
(10)  
(11) 
Constraint (7) requires that for all , the sum of the weights of the selected edges corresponding to the pair is not more than . Constraints (8)–(9) require that the selected edges corresponding to form a simple path beginning at and ending at . Constraint (10) enforces that, if edge or is selected on some  path, then its corresponding undirected edge is selected in the spanner; further, and cannot both be selected for some pair . Finally, (11) enforces that all variables are binary.
The number of variables is and the number of constraints is , where . Note that the variables can be relaxed to be continuous in .
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 . Again, we use unordered pairs, i.e., .
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 . Instead of 0–1 indicators , let denote the grade of edge in the multilevel spanner; that is, if appears on level but not level , and if is absent. The only difference is that for the MLGS problem, we assign grades of service to all  paths by assigning grades to edges along each  path. That is, for all with , the selected path from to has grade , which we denote by . Note that we only need to require the existence of a path for terminals , where . An ILP formulation for the MLGS problem is as follows.
(12)  
(13)  
(14)  
(15)  
(16)  
(17)  
(18) 
Constraints (16)–(17) enforce that for each pair such that , the edges along the selected  path (not necessarily every  path) have a grade of service greater than or equal to the minimum grade of service needed to connect and , that is, . If multiple pairs , , …, use the same edge (possibly in opposite directions), then the grade of edge should be . It is implied by (16)–(17) that in an optimal solution.
Theorem 3.1
Theorem 3.2
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 , for some edge , then we can remove from the graph, as no minweight spanner of uses edge . If is a mincost pairwise spanner that uses edge , then we can replace with a shorter  path without violating the –spanner requirement. In particular, if some  path uses both edge as well as some edge(s) along , then this path can be rerouted to use only edges in with smaller cost.
We reduce the number of variables needed in the singlelevel ILP formulation ((6)–(11)) with the following test: given with and some directed edge , if , then cannot possibly be included in the selected  path, so set . If or cannot be selected on any  path, we can safely remove from .
Conversely, given some directed edge , let be the directed graph obtained by removing from (so that has edges). For each with , if , then edge must be in any  spanner path, so set . For its corresponding undirected edge , .
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,
, and probability
, the model assigns an edge to any given pair of vertices with probability . An instance of with is connected with high probability for [14]). For our experiments we use , and .In the WattsStrogatz model, , initially we create a ring lattice of constant degree , and then rewire each edge with probability while avoiding selfloops and duplicate edges. The WattsStrogatz model generates smallworld graphs with high clustering coefficients [18]. For our experiments we use , , and .
An instance of the MLGS problem is characterized by four parameters: graph generator, number of vertices , number of levels , and stretch factor . As there is randomness involved, we generated 3 instances for every choice of parameters (e.g., ER, , , ).
We generated MLGS instances with 1, 2, or 3 levels (), where terminals are selected on each level by randomly sampling vertices on level so that the size of the terminal sets decreases linearly. As the terminal sets are nested, can be selected by sampling from (or from if ). We used four different stretch factors in our experiments, . Edge weights are randomly selected from .
4.1.1 Algorithms and outputs
We implemented the bottomup (BU) and topdown (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 highperformance 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 bottomup (BU), the topdown (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 (singlelevel) 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 (singlelevel) spanners to optimality significantly improves the overall quality of the solution.
We show the performance ratio for each heuristic in the axis (defined as the heuristic cost divided by OPT), and how the ratio depends on the input parameters (number of vertices , number of levels , and stretch factors ). 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 topdown, bottomup, and combined approaches. We show the impact of different parameters (number of vertices , number of levels , and stretch factors ) using line plots for three heuristics separately in Figures 46. Figure 7 shows the performance of the three heuristics together in box plots. In Figure 4 we can see that the bottomup heuristic performs slightly worse for increasing , while the topdown heuristic performs slightly better. In Figure 5 we see that the heuristics perform worse when 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 . In general, the performance becomes worse as 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 , number of levels , and stretch factors . 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 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 bottomup, topdown 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 , number of levels , and stretch factors ) 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 . We evaluated more levels () with stretch factors . We show the performance of heuristic bottomup and topdown in Appendix 0.E. Here, the ratio is determined by dividing the BU or TD cost by (as computing the optimal MLGS would be too timeconsuming). 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 . It would be worthwhile to consider whether even better ILP formulations can be found for computing graph spanners and their multilevel 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 that is the same for all levels in the multilevel spanner, as well as a fairly specific definition of cost. It would be interesting to investigate more general multilevel or gradeofservice 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.
References
 [1] Ahmed, A.R., Angelini, P., Sahneh, F.D., Efrat, A., Glickenstein, D., Gronemann, M., Heinsohn, N., Kobourov, S., Spence, R., Watkins, J., Wolff, A.: Multilevel Steiner trees. In: 17th International Symposium on Experimental Algorithms, (SEA). pp. 15:1–15:14 (2018). https://doi.org/10.4230/LIPIcs.SEA.2018.15, https://doi.org/10.4230/LIPIcs.SEA.2018.15
 [2] Althöfer, I., Das, G., Dobkin, D., Joseph, D.: Generating sparse spanners for weighted graphs. In: Gilbert, J.R., Karlsson, R. (eds.) SWAT 90. pp. 26–37. Springer Berlin Heidelberg, Berlin, Heidelberg (1990)
 [3] ÁlvarezMiranda, E., Sinnl, M.: Mixedinteger programming approaches for the tree t*spanner problem. Optimization Letters (Oct 2018). https://doi.org/10.1007/s1159001813400, https://doi.org/10.1007/s1159001813400
 [4] Balakrishnan, A., Magnanti, T.L., Mirchandani, P.: Modeling and heuristic worstcase performance analysis of the twolevel network design problem. Management Sci. 40(7), 846–867 (1994). https://doi.org/10.1287/mnsc.40.7.846
 [5] Berman, P., Bhattacharyya, A., Makarychev, K., Raskhodnikova, S., Yaroslavtsev, G.: Approximation algorithms for spanner problems and directed steiner forest. Information and Computation 222, 93 – 107 (2013). https://doi.org/https://doi.org/10.1016/j.ic.2012.10.007, http://www.sciencedirect.com/science/article/pii/S0890540112001484, 38th International Colloquium on Automata, Languages and Programming (ICALP 2011)
 [6] Bhattacharyya, A., Grigorescu, E., Jung, K., Raskhodnikova, S., Woodruff, D.P.: Transitiveclosure spanners. SIAM Journal on Computing 41(6), 1380–1425 (2012). https://doi.org/10.1137/110826655, https://doi.org/10.1137/110826655
 [7] Bodwin, G.: Linear size distance preservers. In: Proceedings of the TwentyEighth Annual ACMSIAM Symposium on Discrete Algorithms. pp. 600–615. Society for Industrial and Applied Mathematics (2017)
 [8] Charikar, M., Naor, J.S., Schieber, B.: Resource optimization in QoS multicast routing of realtime multimedia. IEEE/ACM Trans. Networking 12(2), 340–348 (2004). https://doi.org/10.1109/TNET.2004.826288
 [9] Chuzhoy, J., Gupta, A., Naor, J.S., Sinha, A.: On the approximability of some network design problems. ACM Trans. Algorithms 4(2), 23:1–23:17 (2008). https://doi.org/10.1145/1361192.1361200
 [10] Coppersmith, D., Elkin, M.: Sparse sourcewise and pairwise distance preservers. SIAM Journal on Discrete Mathematics 20(2), 463–501 (2006)
 [11] Cygan, M., Grandoni, F., Kavitha, T.: On pairwise spanners. In: Portier, N., Wilke, T. (eds.) 30th International Symposium on Theoretical Aspects of Computer Science (STACS 2013). Leibniz International Proceedings in Informatics (LIPIcs), vol. 20, pp. 209–220. Schloss Dagstuhl–LeibnizZentrum fuer Informatik, Dagstuhl, Germany (2013). https://doi.org/10.4230/LIPIcs.STACS.2013.209, http://drops.dagstuhl.de/opus/volltexte/2013/3935
 [12] David, P., A., S.A.: Graph spanners. Journal of Graph Theory 13(1), 99–116. https://doi.org/10.1002/jgt.3190130114, https://onlinelibrary.wiley.com/doi/abs/10.1002/jgt.3190130114

[13]
Dinitz, M., Krauthgamer, R.: Directed spanners via flowbased linear programs. In: Proceedings of the Fortythird Annual ACM Symposium on Theory of Computing. pp. 323–332. STOC ’11, ACM, New York, NY, USA (2011).
https://doi.org/10.1145/1993636.1993680, http://doi.acm.org/10.1145/1993636.1993680  [14] Erdős, P., Rényi, A.: On random graphs, i. Publicationes Mathematicae (Debrecen) 6, 290–297 (1959)
 [15] Kortsarz, G.: On the hardness of approximating spanners. Algorithmica 30(3), 432–450 (Jan 2001). https://doi.org/10.1007/s004530010021y, https://doi.org/10.1007/s004530010021y
 [16] Mirchandani, P.: The multitier tree problem. INFORMS J. Comput. 8(3), 202–218 (1996)
 [17] Sigurd, M., Zachariasen, M.: Construction of minimumweight spanners. In: Albers, S., Radzik, T. (eds.) Algorithms – ESA 2004. pp. 797–808. Springer Berlin Heidelberg, Berlin, Heidelberg (2004)
 [18] Watts, D.J., Strogatz, S.H.: Collective dynamics of ‘smallworld’networks. Nature 393(6684), 440 (1998)
Appendix 0.A Proof of Theorem 2.4
Proof
We use the simple algebraic fact that for all and . Here, we can also use the fact that , as the RHS equals the cost of , which is some subsetwise spanner. Combining, we have
Since we are comparing to for some approximation ratio , we can compare coefficients and find the smallest such that the system of inequalities
has a solution . Adding the first inequality to times the last inequality yields , or . Also, it can be shown algebraically that simultaneously satisfies the above inequalities. This implies that .
Appendix 0.B Proof of Theorem 3.1
Proof
Let denote an optimal pairwise spanner of with stretch factor , and let OPT denote the cost of . Let denote the minimum cost of the objective in the ILP (6). First, given a minimum cost –spanner , a solution to the ILP can be constructed as follows: for each edge , set . Then for each unordered pair with , compute a shortest path from to in , and set for each edge along this path, and if is not on .
As each shortest path necessarily has cost , constraint (7) is satisfied. Constraints (8)–(9) are satisfied as is a simple  path. Constraint (10) also holds, as should not traverse the same edge twice in opposite directions. In particular, every edge in appears on some shortest path; otherwise, removing such an edge yields a pairwise spanner of lower cost. Hence .
Conversely, an optimal solution to the ILP induces a feasible –spanner . Consider an unordered pair with , and the set of decision variables satisfying . By (8) and (9), these chosen edges form a simple path from to . The sum of the weights of these edges is at most by (7). Then by constraint (10), the chosen edges corresponding to appear in the spanner, which is induced by the set of edges with . Hence .
Combining the above observations, we see that .
Appendix 0.C Proof of Theorem 3.2
Proof
Given an optimal solution to the ILP with cost , construct an MLGS by letting where . This clearly gives a nested sequence of subgraphs. Let and be terminals in (not necessarily of required grade ), with , and consider the set of all variables of the form equal to 1. By (13)–(15), these selected edges form a path from to of length at most , while constraints (16)–(17) imply that these selected edges have grade at least , so the selected path is contained in . Hence is a subsetwise –spanner for with stretch factor , 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 with , set . Compute a shortest path in from to , and set for all edges along this path. Then for each , consider all pairs that use either or , and set . In particular, is not larger than the grade of in the MLGS, otherwise this would imply is on some  path at grade greater than its grade of service in the actual solution.
Appendix 0.D Experimental results on graphs generated using WattsStrogatz
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ősRényi
Figure 24 shows a rough measure of performance for the bottomup and topdown heuristics on large graphs using the ErdősRé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 is large.
Comments
There are no comments yet.