Effective Edge-Fault-Tolerant Single-Source Spanners via Best (or Good) Swap Edges
Davide Bilò Feliciano Colella Luciano Gualà Stefano Leucci Guido Proietti
cs.DS




Edge-Fault-Tolerant Single-Source Spanners via Best (or Good) Swap Edges
Davide Bilò et al.


Dipartimento di Scienze Umanistiche e Sociali, University of Sassari, Italy davide.bilo@uniss.itGran Sasso Science Institute, L'Aquila,  Italy. feliciano.colella@gssi.itDipartimento di Ingegneria dell'Impresa, University of Rome “Tor Vergata”,  Italy. guala@mat.uniroma2.itDepartment of Computer Science, ETH Zürich, Switzerland. stefano.leucci@inf.ethz.chDipartimento di Ingegneria e Scienze dell'Informazione e Matematica, University of L'Aquila, Italy. guido.proietti@univaq.itIstituto di Analisi dei Sistemi ed Informatica, CNR, Rome, Italy.

Effective Edge-Fault-Tolerant Single-Source Spanners via Best (or Good) Swap Edges
    Davide Bilò1 Feliciano Colella2 Luciano Gualà3 Stefano Leucci4 Guido Proietti5,6
    December 30, 2023
====================================================================================




Computing all best swap edges (ABSE) of a spanning tree T of a given n-vertex and m-edge undirected and weighted graph G means to select, for each edge e of T, a corresponding non-tree edge f, in such a way that the tree obtained by replacing e with f enjoys some optimality criterion (which is naturally defined according to some objective function originally addressed by T).
Solving efficiently an ABSE problem is by now a classic algorithmic issue, since it conveys a very successful way of coping with a (transient) edge failure in tree-based communication networks: just replace the failing edge with its respective swap edge, so as that the connectivity is promptly reestablished by minimizing the rerouting and set-up costs.
In this paper, we solve the ABSE problem for the case in which T is a single-source shortest-path tree of G, and our two selected swap criteria aim to minimize either the maximum or the average stretch in the swap tree of all the paths emanating from the source. Having these criteria in mind, the obtained structures can then be reviewed as edge-fault-tolerant single-source spanners. For them, we propose two efficient algorithms running in O(m n  +n^2 log n) and O(m n logα(m,n)) time, respectively, and we show that the guaranteed (either maximum or average, respectively) stretch factor is equal to 3, and this is tight. Moreover, for the maximum stretch, we also propose an almost linear O(m logα(m,n)) time algorithm computing a set of good swap edges, each of which will guarantee a relative approximation factor on the maximum stretch of 3/2 (tight) as opposed to that provided by the corresponding BSE. Surprisingly, no previous results were known for these two very natural swap problems.




§ INTRODUCTION

Nowadays there is an increasing demand for an efficient and resilient information exchange in communication networks.
This means to design on one hand a logical structure onto a given communication infrastructure, which optimizes some sought routing protocol in the absence of failures, and on the other hand, to make such a structure resistant against possible link/node malfunctioning, by suitably adding to it a set of redundant links, which will enter into operation as soon as a failure takes place.

More formally, the depicted situation can be modeled as follows: the underlying communication network is an n-vertex and m-edge undirected input graph G=(V(G),E(G),w), with positive real edge weights defined by w, the logical (or primary) structure is a (spanning) subgraph H of G, and finally the additional links is a set of edges A in E(G) ∖ E(H). Under normal circumstances, communication takes place on H, by following a certain protocol, but as soon as an edge in H fails, then one or more edges in A come into play, and the communication protocol is suitably adjusted.

In particular, if the primary structure is a (spanning) tree of G, then a very effective way of defining the set of additional edges is the following: with each tree edge, say e, we associate a so-called best swap edge, namely a non-tree edge that will replace e once it (transiently) fails, in such a way that the resulting swap tree enjoys some nice property in terms of the currently implemented communication protocol. By doing in this way, rerouting and set-up costs will be minimized, in general, and the quality of the post-failure service remains guaranteed. Then, an all best swap edges (ABSE) problem is that of finding efficiently (in term of time complexity) a best swap edge for each tree edge.

Due to their fault-tolerance application counterpart, ABSE problems received a large attention by the algorithmic community.
In such a framework, a key role has been  played by the Shortest-Path Tree (SPT) structure, which is commonly used for implementing efficiently the broadcasting communication primitive.
Indeed, it is was shown already in <cit.> that an effective post-swap broadcast protocol can be put in place just after the original SPT undergoes an edge failure. Not surprisingly then, several ABSE problems w.r.t. an SPT have been studied in the literature, for many different swap criteria.




  
Previous work on swapping in an SPT.
Since an SPT enjoys several optimality criteria when looking at distances from the source, say s, several papers have analyzed the problem in various respects. However, most of the efforts focused on the minimization w.r.t. the following two swap criterion: the maximum/average distance from s to any node which remained disconnected from s after a failure. The currently fastest solutions for these two ABSE problems run in O(m logα(m,n)) time <cit.> and O(m  α(n,n) log^2 n) time <cit.>, respectively.
Moreover, it has been shown that in the swap tree the maximum (resp., average) distance of the disconnected nodes from s is at most twice (resp., triple) that of the new optimum SPT <cit.>, and these bounds are tight.

Other interesting swap criteria which have been analyzed include the minimization of the maximum increase (before and after the failure) of the distance from s, and the minimization of the distance from s to the root of the subtree that gets disconnected after the failure <cit.>. Besides the centralized setting, all these swap problems have been studied also in a distributed framework (e.g., see <cit.>).

On the other hand, no results are known for the case in which one is willing to select a BSE with the goal of minimizing either the maximum or the average stretch from the source s of the disconnected nodes, where the stretch of a node is measured as the ratio between its distance from s in the swap tree and in a new optimum SPT.
This is very surprising, since they are (especially the former one) the universally accepted criterion leading to the design of a
spanner, i.e., a sparse subgraph preserving shortest paths (between pairs of vertices of interest) in a graph (also in the presence of failures).


In this paper, we aim to fill this gap, by providing efficient solutions exactly for these two swap criteria.



  
Our results.
Let us denote by and the ABSE problem w.r.t. the maximum and the average stretch swap criterion, respectively.
For such problems, we devise two efficient algorithms running in O(m n +n^2 log n) and O(m n logα(m,n)) time, respectively. Notice that both solutions incorporate the running time for computing all the replacement shortest paths from the source after the failure of every edge of the SPT, as provided in <cit.>, whose computation essentially dominates in an asymptotic sense the time complexity.
Our two solutions are based on independent ideas, as described in the following:



  * for the problem, we develop a centroid decomposition of the SPT, and we exploit a distance property that has to be enjoyed by a BSE w.r.t. a nested and log-depth hierarchy of centroids, which will be defined by the subtree detached from the source after the currently analyzed edge failure. A further simple filtering trick on the set of potential swap edges will allow to reduce them from O(m) to O(n), thus returning the promised O(n^2 log n) time.

  * for the problem, we instead suitably combine a set of linearly-computable (at every edge fault) information, that essentially will allow to describe in O(1) time the quality of a swap edge. This procedure is in principle not obvious, since to compute the average stretch we need to know, for each swap edge, the O(n) distances to all the nodes in the detached subtree.  Again, by filtering on the set of potential swap edges, we will get an O(n^2) running time, which will be absorbed by the all-replacement paths time complexity.


Concerning the quality of the corresponding swap trees,  we instead show that the guaranteed
(either maximum or average, respectively) stretch factor w.r.t. the paths emanating from the source (in the surviving graph) is equal to 3, and this is tight.
By using a different terminology, our structures can then be revised as edge-fault-tolerant single-source 3-spanners, and we qualified them as effective since they can be computed quickly, are very sparse, provide a very simple alternative post-failure routing, and finally have a small (either maximum or average) stretch.

Although the proposed solutions are quite efficient, their running time can become prohibitive for large and dense input graphs, since in this case they would amount to a time cubic in the number of vertices. Unfortunately, it turns out that their improvement is unlikely to be achieved,
unless one could avoid the explicit recomputation of all post-failure distances from the source.
To circumvent this problem, we then adopt a different approach, which by the way finds application for the (most relevant) max-stretch measure only: we renounce to optimality in the detection of a BSE, in return of a substantial improvement (in the order of a linear factor in n) in the runtime.
More precisely, for such a measure, we will compute in an almost linear O(m logα(m,n)) time a set of good swap edges (GSE), each of which will guarantee a relative approximation factor on the maximum stretch of 3/2 (tight) as opposed to that provided by the corresponding BSE. Moreover, a GSE will still guarantee an absolute maximum stretch factor w.r.t. the paths emanating from the source (in the surviving graph) equal to 3 (tight).

Besides that, we also point out another important feature concerned with the computation in a distributed setting of all our good swap edges. Indeed, in <cit.> it was shown that they can be computed in an asynchronous message passing system in essentially optimal ideal time,[This is the time obtained with the ideal assumption that the communication time of each message to a neighboring process takes constant time, as in the synchronous model.] space usage, and message complexity, as opposed to the recomputation of all the corresponding BSE, for which
no efficient solution is currently available.



  
Other related results.
Besides swap-based approaches, an SPT can be made edge-fault-tolerant by further enriching the set of additional edges, so that the obtained structure has almost-shortest paths emanating from the source, once an edge fails. The currently best trade off between the size of the set of additional edges and the quality of the resulting paths emanating from s is provided in <cit.>, where the authors showed that for any arbitrary constant ε>0, one can compute in polynomial time a slightly superlinear (in n, and depending on ε) number of additional edges in such a way that the resulting structure retains (1+ε)-stretched post-failure paths from the source.

For the sake of completeness, we also quickly recall the main results concerned with ABSE problems. For the minimum spanning tree (MST), a BSE is of course one minimizing the cost of the swap tree, i.e., a swap edge of minimum cost. This problem is also known as the MST sensitivity analysis problem, and can be solved in O(mlogα(m,n)) time <cit.>.
Concerning the minimum diameter spanning tree, a BSE is instead one minimizing the diameter of the swap tree <cit.>, and the best solution runs in O(m logα(m,n)) time <cit.>. Regarding the minimum routing-cost spanning tree, a BSE is clearly one minimizing the all-to-all routing cost of the swap tree <cit.>, and the fastest solutions for solving this problem has a running time of O(m 2^O(α(n,n))log^2 n) <cit.>. Finally, for a tree spanner, a BSE is one minimizing the maximum stretch w.r.t. the all pair distances, and the fastest solution to date run in O(m^2 logα(m,n)) time <cit.>.

To conclude, we point out that the general problem of designing fault-tolerant spanners for the all-to-all case has been extensively studied in the literature, and we refer the interested reader to <cit.> and the references therein.





§ PROBLEM DEFINITION

Let G = (V(G), E(G), w) be a 2-edge-connected, edge-weighted, and undirected graph with cost function w : E(G) →ℝ^+. We denote by n and m the number of vertices and edges of G, respectively. If X ⊆ V, let E(X) be the set of edges incident to at least one vertex in X.
Given an edge e ∈ E(G), we will denote by G-e the graph obtained from G by removing edge e. Similarly, given a vertex v ∈ V(G), we will denote by G-v the graph obtained from G by removing vertex v and all its incident edges. Let T be an SPT of G rooted at s ∈ V(G). Given an edge e ∈ E(T), we let C(e) be the set of all the swap edges for e, i.e., all edges in E(G) ∖{ e } whose endpoints lie in two different connected components of T-e, and let C(e,X) be the set of all the swap edge for e incident to a vertex in X ⊆ V(G). For any e ∈ E(T) and f ∈ C(e), let T_e/f denote the swap tree obtained from T by replacing e with f. Let T_v = (V(T_v), E(T_v)) be the subtree of T rooted at v ∈ V(G).
Given a pair of vertices u,v ∈ V(G), we denote by d_G(u,v) the distance between u and v in G. Moreover, for a swap edge f=(x,y), we assume that the first appearing endvertex is the one closest to the source, and we may denote by w(x,y) its weight. We define the stretch factor of y w.r.t. s,T,G as σ_G(T,y) = d_T(s,y)/d_G(s,y).

Given an SPT T of G, the problem is that of finding, for each edge e=(a,b) ∈ E(T), a swap edge f^* such that:


    f^* ∈min_f ∈ C(e){μ(f):= max_v∈ V(T_b)σ_G-e(T_e/f,v) }.


Similarly, the problem is that of finding, for each edge e=(a,b) ∈ E(T), a swap edge f^* such that:

    f^* ∈min_f ∈ C(e){λ(f):=1/|V(T_b)|∑_v∈ V(T_b)σ_G-e(T_e/f,v) }.


We will call μ(f) (resp., λ(f)) the max-(resp., avg-)stretch of f w.r.t. e.



§ AN ALGORITHM FOR 

In this section we will show an efficient algorithm to solve the problem in O(mn + n^2 log n) time.
Notice that a brute-force approach would require O(mn^2) time, given by the O(n) time which is needed to evaluate the quality of each of the O(m) swap edges, for each of the n-1 edges of T. Our algorithm will run through n-1 phases, each returning in O(m+nlog n) time a BSE for a failing edge of T, as described in the following.

Let us fix e=(a,b) as the failing edge. First, we compute in O(m+ n log n) time all the distances in G-e from s. Then, we filter the O(m) potential swap edges to O(n), i.e., at most one for each node v in T_b. Such a filtering is simply obtained by selecting, out of all edges f=(x,v) ∈ C(e, { v  }), the one minimizing the measure d_G(s,x)+w(f). Indeed, it is easy to see that the max-stretch of such selected swap edge is never worse than that of every other swap edge in C(e). This filtering phase will cost O(m) total time. As a consequence, we will henceforth assume that |C(e)| = O(n).

Then, out of the obtained O(n) swap edges for e, we further restrict our attention to a subset of O(log n) candidates as BSE, which are computed as follows. Let Λ denote a generic subtree of T_b, and assume that initially Λ=T_b.
First of all, we compute in O(|V(Λ)|) time a centroid c of Λ, namely a node whose removal from Λ splits Λ in a forest F of subtrees, each having at most |V(Λ)|/2 nodes <cit.>; then, out of all the swap edges, we select a candidate edge f minimizing the distance from s to c in T_e/f, i.e.,

    f ∈min_(x',v') ∈ C(e){d_T(s,x')+w(x',v')+d_T(v',c)};

then, we compute a critical node z for the selected swap edge f, i.e.,

    z ∈max_z' ∈ V(T_b)σ_G-e(T_e/f,z').

We now select a suitable subtree Λ' of the forest F,
and we pass to the selection of the next candidate BSE by recursing on Λ', until |V(Λ')|=1. More precisely, Λ' is the first tree of F containing the first vertex of V(Λ) that is encountered by following the path in T from z towards c (see Figure <ref>).

Due to the property of the centroid, the number of recursions will be O(log |V(T_b)|)= O(log n), as promised, each costing O(n) time. Moreover, at least one of the candidate edges will be a BSE for e, and hence it suffices to choose the edge minimizing the maximum stretch among the corresponding O(log n) candidate edges.
This step is done within the recursive procedure by comparing the current candidate edge f with the best candidate resulting from the nested recursive calls.

A more formal description of each phase is shown in Algorithm <ref>. In the following we prove the correctness of our algorithm.





Let e=(a,b) be a failing edge, and let Λ be a subtree of T_b. Given a vertex c ∈ V(Λ), let f ∈min_ (x',v') ∈ C(e){ d_T(s,v') + w(x',v') + d_T(v', c) } and let z be a critical node for f. Let F be the forest obtained by removing the edges incident to c from Λ, and let Λ' be the tree of F containing the first vertex of the path from z to c in T that is also in V(Λ). For any swap edge f' ∈ C(e,V(Λ)), if μ(f') < μ(f) then f' ∈ C(e, V(Λ')).


	Let f=(x, v) and f' = (x', v').
	We show that if v' ∈ V(Λ) ∖ V(Λ') then μ(f') ≥μ(f) (see also Figure <ref>). Indeed:
	
    μ(f')    ≥σ_G-e(T_e/f', z) =
    		 d_T_e/f'(s,z)/d_G-e(s, z)
    		=  d_T(s,x') + w(f') + d_T(v',c) + d_T(c,z) /d_G-e(s, z)
       ≥ d_T(s,x) + w(f) + d_T(v,c) + d_T(c,z) /d_G-e(s, z)≥ d_T_e/f(s,z) /d_G-e(s, z) = σ_G-e(T_e/f, z) 
        = μ(f),

where we used the equality d_T(v',z) = d_T(v',c) + d_T(c,z), which follows from the fact that the path from v' to z in T must traverse c as v' and z are in two different trees of F.





	If C(e, V(Λ)) contains a BSE for e then (e, Λ) returns a BSE for e.
	


	First of all notice that Algorithm <ref> only returns edges in C(e).

	We prove the claim by induction on |V(Λ)|.
	If |V(Λ)|=1 and C(e, V(Λ)) contains a BSE f^* for e, then let f be the edge of C(e) returned by Algorithm <ref> and let V(Λ)={c}. By choice of f, for every v ∈ V(T_b),

    d_T_e/f(s,v)≤ d_T_e/f(s,c)+d_T(c,v)=d_T_e/f^*(s,c)+d_T(c,v) = d_T_e/f^*(s,v),

from which we derive that μ(f) = μ(f^*), and the claim follows.
	
	If |V(Λ)| > 1 and C(e, V(Λ)) contains a BSE for e, we distinguish two cases depending on whether the edge f computed by Algorithm <ref> is a BSE for e or not. If that is the case, then μ(f) ≤μ(f”)  ∀ f”∈ C(e) and the algorithm correctly returns f.
	Otherwise, by Lemma <ref>, any edge f' ∈ C(e, V(Λ)) such that μ(f') < μ(f) must belong to C(e, V(Λ')).
	It follows that Λ' contains a BSE for e and since 1 ≤ |V(Λ')| < |V(Λ)| we have, by inductive hypothesis, that the edge f' returned by (G, e, Λ') is a BSE for e. Clearly μ(f') < μ(f) and hence Algorithm <ref> correctly returns f'.


Since each invocation of Algorithm <ref> requires O(n) time, Lemma <ref> together with the previous discussions allows us to state the main theorem of this section:


	There exists an algorithm that solves the problem in O(mn + n^2 log n) time.





§ AN ALGORITHM FOR 

In this section we show how the problem can be solved efficiently in O(mn logα (m,n)) time.
Our approach first of all, in a preprocessing phase, computes in O(m   n logα(m,n)) time all the replacement shortest paths from the source after the failure of every edge of T <cit.>. Then, the algorithm will run through n-1 phases, each returning in O(m) time a BSE for a failing edge of T, as described in the following. Thus, the overall time complexity will be dominated by the preprocessing step.

Let us fix e=(a,b)∈ E(T) as the failing edge of T. The idea is to show that, after a O(n) preprocessing time, we can compute the avg-stretch λ(f) of any f in constant time. This immediately implies that we can compute a BSE for e by looking at all O(m) swap edges for e.

Let U=V(T_b) and let y be a node in U, we define:

    M(y)=∑_v ∈ Ud_T(y,v)/d_G-e(s,v)
 and 
    Q = ∑_v ∈ U1/d_G-e(s,v).

Let f=(x,y) be a candidate swap edge incident in y ∈ U. The avg-stretch of f can be rewritten as:


    λ(f)=∑_v ∈ Ud_T(s,x)+w(f)+d_T(y,v)/d_G-e(s,v) = (d_T(s,x)+w(f))Q + M(y).


Hence, the avg-stretch of f can be computed in O(1) time, once Q and M(y) are available in constant time. Observe that Q does not depend on y and can be computed in O(n) time. The rest of this section is devoted to show how to compute M(y) for every y ∈ U in O(n) overall time.



  §.§.§ Computing M(y) for all y ∈ U.

Let y e y' be two nodes in U such that y is a child of y' in T. Moreover, let U_y=V(T_y), and let Q_y = ∑_v ∈ U_y1/d_G-e(s,y). Hence, we can rewrite M(y) and M(y') as follows:


    M(y) = ∑_v ∈ U_yd_T(y,v)/d_G-e(s,v) + ∑_v ∈ U-U_yw(y,y')+d_T(y',v)/d_G-e(s,v)

and

    M(y') = ∑_v ∈ U_yw(y,y')+d_T(y,v)/d_G-e(s,v) + ∑_v ∈ U-U_yd_T(y',v)/d_G-e(s,v).

Therefore, we have:

    M(y) = M(y') + w(y,y') (- Q_y + (Q - Q_y)) = M(y') + w(y,y') (Q - 2Q_y).

The above equation implies that M(y) can be computed in O(1) time, once we have computed M(y'), Q and Q_y. As a consequence, we can compute all the M(y)'s as follows. First, we compute Q_y for every y∈ D in O(n) overall time by means of a postorder visit of T_b. Notice also that Q=Q_b. Then, we compute M(b) explicitly in O(n) time. Finally, we compute all the other M(y)'s by performing a preorder visit of T_b. When we visit a node y, we compute M(y) in constant time using (<ref>). Thus, the visit will take O(n) time. We have proved the following:

There exists an algorithm that solves the problem in O(mn logα (m,n)) time.




§ AN APPROXIMATE SOLUTION FOR 

In this section we show that for the max-stretch measure we can compute in an almost linear O(m logα(m,n)) time, a set of good swap edges (GSE), each of which guarantees a relative approximation factor on the maximum stretch of 3/2 (tight), as opposed to that provided by the corresponding BSE. Moreover, as shown in the next section, each GSE still guarantees an absolute maximum stretch factor w.r.t. the paths emanating from the source (in the surviving graph) equal to 3 (tight).

 
Let e be a failing edge in T, let

    g=(x,y) ∈min_(x',v') ∈ C(e){d_T(s,x')+w(x',v')},

and, finally, let f=(x',y') be a best swap edge for e w.r.t. . Then, μ(g)/μ(f) ≤ 3/2.


Let z be the critical node for the good swap edge g, and let t (resp., t') denote the least common ancestor in T between y' and z (resp., y' and y). Let D=d_T(s,x)+w(x,y)=d_G-e(s,y). By choice of g, it holds that d_G-e(s,z) ≥ D and d_G-e(s,y' ) ≥ D. We divide the proof into the following two cases, as depicted in Figure <ref>: either (1) t is an ancestor of t' in T, or (2) t' is an ancestor of t in T. Let A,B,C denote the distance in T between y and t', t' and t, t and z, respectively.



  §.§.§ Case 1

Since t is an ancestor of t' (left side of Figure <ref>), we have that d_T_e/f(s,y) ≥ D+A and we can write:

    σ_G-e(T_e/f,y) ≥D+A/d_G-e(s,y) = D+A/D≥D+A/d_G-e(s,z),


and similarly σ_G-e(T_e/f,z) ≥D+B+C/d_G-e(s,z).
Moreover, by the definition of μ(·) we have that μ(f) ≥max{σ_G-e(T_e/f,y), σ_G-e(T_e/f,z)}. The previous inequalities together imply:

    μ(g)/μ(f)≤σ_G-e(T_e/g,z)/max{σ_G-e(T_e/f,y), σ_G-e(T_e/f,z)}≤A+B+C+D/D+max{ A, B+C }.


Now we divide the proof into two subcases, depending on whether B+C ≥ A or B+C < A. Observe that D ≥ d_G(s,y) ≥ A.
If B+C ≥ A, then (<ref>) becomes:

    μ(g)/μ(f)≤A+B+C+D/B+C+D = 1 + A/B+C+D≤ 1 + A/2A = 3/2,

otherwise, if B+C < A, then  (<ref>) becomes:

    μ(g)/μ(f)≤A+B+C+D/A+D < 2A+D/A+D = 1 + A/A+D≤ 1 + A/2A = 3/2.




  §.§.§ Case 2

Assume now that t' is an ancestor of t (right side of Figure <ref>). Since
 
    μ(f) ≥σ_G-e(T_e/f,y) ≥d_G-e(s,y')+A+B/d_G-e(s,y)=d_G-e(s,y')+A+B/D,

we have that:

    μ(g)/μ(f)   ≤A+B+C+D/d_G-e(s,z)·D/d_G-e(s,y')+A+B
       ≤A+B+C+D/d_G-e(s,z)·D/A+B+D

and since d_G-e(s,z) ≥ d_G(s,z) ≥ C, and recalling that d_G-e(s,z) ≥ D, we have:

    μ(g)/μ(f)≤A+B+C+D/A+B+D·D/max{ C,D }
    	= ( 1 + C/A+B+D) ·D/max{ C,D }.

Moreover, notice that also the following holds:

    μ(g)/μ(f)   ≤μ(g)/σ_G-e(T_e/f,z)≤A+B+C+D/d_G-e(s,z)·d_G-e(s,z)/d_G-e(s,y') + d_T(y',t)+C
       ≤A+B+C+D/C+D = 1+ A+B/C+D.

We divide the proof into the following two subcases, depending on whether D ≥ C or D < C.
In the first subcase, i.e., D ≥ C, we have that (<ref>) becomes μ(g)/μ(f)≤ 1 + C/A+B+D,
and hence, by combining this inequality with (<ref>), we obtain:

    μ(g)/μ(f)   ≤ 1+ min{C/A+B+D, A+B/C+D}
       ≤ 1+ min{C/A+B+C, A+B/2C}≤ 1+1/2=3/2.

In the second subcase, i.e., D < C, (<ref>) becomes:

    μ(g)/μ(f)≤( 1 + C/A+B+D) ·D/C≤D/C + D/A+B+D < 1 + D/A+B+D,

and hence, by combining (<ref>) and (<ref>), we have that:

    μ(g)/μ(f)   ≤ 1+ min{D/A+B+D, A+B/C+D}
       ≤ 1+ min{D/A+B+D, A+B/2D}≤ 1+1/2=3/2,

from which the claim follows.


Given the result of Lemma <ref>, we can derive an efficient algorithm to compute all the GSE for . More precisely, in <cit.> it was shown how to find them in O(m  α(m,n)) time. Essentially, the approach used in <cit.> was based on a reduction to the SPT sensitivity analysis problem <cit.>. However, in <cit.> it was proposed a faster solution to such a problem, running in O(m  logα(m,n)) time. Thus, we can provide the following



There exists a 3/2-approximation algorithm that solves the problem in O(m logα (m,n)) time.

We conclude this section with a tight example which shows that the analysis provided in Lemma <ref> is tight (see Figure <ref>).





§ QUALITY ANALYSIS

As for previous studies on swap edges, it is interesting now to see how the tree obtained from swapping
a failing edge e=(a,b) with its BSE f compares with a true SPT of G-e. According to our swap criteria, we will then analyze the lower and upper bounds of the max- and avg-stretch of f, i.e., μ(f) and λ(f), respectively.

As already observed in the introduction, it is well-known <cit.> that for the swap edge, say g, which belongs to the shortest path in G-e between s and the root of the detached subtree T_b, we have that for any v ∈ V(T_b), σ_G-e(T_e/g,v) ≤ 3. This immediately implies that μ(g),λ(g) ≤ 3, namely μ(f),λ(f) ≤ 3. These bounds happen to be tight, as shown in Figure <ref>.



Let us now analyze the lower and upper bounds of the max-stretch of a good swap edge g, i.e., μ(g), as defined in the previous section.
First of all, once again it was proven in <cit.> that for any v ∈ V(T_b), σ_G-e(T_e/g,v) ≤ 3, which implies that μ(g) ≤ 3. Moreover, the example shown in Figure <ref> can be used to verify that this bound is tight.




§ CONCLUSIONS

In this paper we have studied two natural SPT swap problems, aiming to minimize, after the failure of any edge of the given SPT, either the maximum or the average stretch factor induced by a swap edge. We have first proposed two efficient algorithms to solve both problems. Then, aiming to the design of faster algorithms, we developed for the maximum-stretch measure an almost linear algorithm guaranteeing a 3/2-approximation w.r.t. the optimum.

Concerning future research directions, the most important open problem remains that of finding a linear-size edge-fault-tolerant SPT with a (maximum) stretch factor w.r.t. the root better than 3, or to prove that this is unfeasible. Another interesting open problem is that of improving the running time of our exact solutions. Notice that both our exact algorithms pass through the computation of all the post-failure single-source distances, and if we could avoid that we would get faster solutions. At a first glance, this sounds very hard, since the stretches are heavily dependant on post-failure distances, but, at least in principle, one could exploit some monotonicity property among swap edges that could allow to skip such a bottleneck.
Besides that, it would be nice to design a fast approximation algorithm for the average-stretch measure. Apparently, in this case it is not easy to adopt an approach based on good swap edges as for the maximum-stretch case, since swap edges optimizing other reasonable swap criteria (e.g., minimizing the distance towards the root of the detached subtree, or minimizing the distance towards a detached node) are easily seen to produce an approximation ratio of 3 as opposed to a BSE. A candidate solution may be that of selecting a BSE w.r.t. the sum-of-distances criterium, which can be solved in almost linear time <cit.>, but for which we are currently unable to provide a corresponding comparative analysis.

Finally, we mention that a concrete task which will be pursued is that of conducting an extensive experimental analysis of the true performances of our algorithms, to check whether for real-world instances the obtained stretches are sensibly better or not w.r.t. the theoretical bounds.

plain

