A polynomial-time algorithm for spanning tree modulus
AA polynomial-time algorithm for spanning tree modulus
Nathan Albin, Kapila Kottegoda and Pietro Poggi-Corradini
Department of Mathematics, Kansas State University, Manhattan, KS
September 9, 2020
Abstract
We introduce a polynomial-time algorithm for spanning tree modulus based on Cunning-ham’s algorithm for graph vulnerability. The algorithm exploits an interesting connection be-tween spanning tree modulus and critical edge sets from the vulnerability problem. This paperdescribes the new algorithm, describes a practical means for implementing it using integer arith-metic, and presents some examples and computational time scaling tests.
A recently published work established connections between spanning tree modulus and a securebroadcast game on graphs [3]. This game was previously analyzed in [11, 12], wherein it was shownthat the game’s solution was closely connected to a concept called graph vulnerability, introducedby Cunningham in [9], and that the game could be solved using Cunningham’s algorithm forfinding graph vulnerability. It was remarked in [14] that this chain of connections implied that apolynomial-time algorithm exists for computing spanning tree modulus. The purpose of the presentwork is to expand on this brief remark, showing in detail how Cunningham’s algorithm can be usedto compute spanning tree modulus.
We begin with a brief review of spanning tree modulus (see, e.g., [2, 3, 14]). Consider the family,Γ, of all spanning trees of a connected, undirected graph G = ( V, E ). ( G need not be simple.) Anon-negative function ρ : E → R ≥ is called a density on G . Each density, ρ , gives every spanningtree γ ∈ Γ a ρ -length (or ρ -weight ) (cid:96) ρ ( γ ) defined as (cid:96) ρ ( γ ) := (cid:88) e ∈ γ ρ ( e ) . The spanning tree modulus of G is defined as the solution to the optimization problemminimize (cid:88) e ∈ E ρ ( e ) subject to (cid:96) ρ ( γ ) ≥ γ ∈ Γ ,ρ ( e ) ≥ e ∈ E. (1)The decision variables are the values of the density ρ assigned to each edge e ∈ E . The densityshould be non-negative and is required to give at least unit ρ -length to every spanning tree. The1 a r X i v : . [ m a t h . C O ] S e p inimum value in (1) is called the spanning tree modulus of G , denoted by Mod(Γ). The problemadmits a unique minimizing density, denoted by ρ ∗ , which is called the optimal density . Thus,Mod(Γ) = (cid:88) e ∈ E ρ ∗ ( e ) . At first glance, spanning tree modulus appears to be computationally challenging. The keydifficulty lies in the inequality constraints, of which there are | Γ | + | E | . Since | Γ | tends to becombinatorially large in | E | , it is not immediately apparent that a polynomial-time algorithmshould exist; indeed, we cannot even hope to identify all constraints in polynomial time.Nevertheless, there have been some indications that an efficient algorithm does exist. Forexample, the iterative approximation algorithm introduced in [5] (adapted to the spanning treesetting) performs very well in practice, producing an accurate approximation to modulus even ongraphs that have enormous numbers of spanning trees. Similarly, the Plus-1 algorithm found in [8]is able to produce rational approximations to spanning tree modulus with a known convergencerate. In fact, although the details were not worked out, we believe that the latter algorithm couldbe used to prove that the spanning tree modulus problem can be solved in polynomial time. Inthis paper, we take a different approach, building on Cunningham’s graph vulnerability algorithmto produce a polynomial-time algorithm for spanning tree modulus. Spanning tree modulus has an interesting dual interpretation in the form of the
Fairest Edge Usage(FEU) problem [2]. The FEU problem is understood through the context of random spanning trees.In this interpretation, we consider a spanning tree γ chosen at random according to a probabilitymass function (pmf) µ . (The underline in the notation γ is used to distinguish the random treefrom its possible values.) In other words, for each γ ∈ Γ, µ ( γ ) defines the probability that γ = γ or, in simpler notation, µ ( γ ) = P µ ( γ = γ ). Here we use the subscript notation P µ to specify exactlywhich pmf is being used. We will also represent the relationship between the random spanning tree γ and its pmf µ by the notation γ ∼ µ . The set of all pmfs on Γ is denoted by P (Γ).If e ∈ E , µ ∈ P (Γ) and γ ∼ µ , then there is a natural concept of edge usage probability for eachedge. Namely, what is the probability that e ∈ γ ? We indicate this quantity with the notation η ( e ) := P µ ( e ∈ γ ) = (cid:88) γ ∈ Γ e ∈ γ µ ( γ ) , where e ∈ γ := (cid:40) e ∈ γ e / ∈ γ. The FEU problem is the solution to another optimization problem, namelyminimize (cid:88) e ∈ E η ( e ) subject to µ ∈ P (Γ) η ( e ) = P µ ( e ∈ γ ) for all e ∈ E. (2)Here, the decision variable is the pmf µ and the objective is to minimize the 2-norm of the associatededge usage probabilities given by η .The optimization problem given in (2) is called the Fairest Edge Usage problem because it isequivalent to the problem of minimizing the variance of η . Roughly speaking, the goal is to assigna pmf to the spanning trees of G in such a way that the edge usage probabilities are as evenlydistributed as possible. 2he important connections between (1) and (2) in the context of the present work are summa-rized in the following theorem, collected from those presented in [1, 2, 4]. Theorem 1.1.
For a given, nontrivial, connected, undirected graph G = ( V, E ) , the following aretrue.1. Problem (1) admits a unique minimizing density ρ ∗ .2. Problem (2) admits at least one optimal pmf µ ∗ . While this pmf may not be unique, alloptimal pmfs induce the same optimal edge usage probabilities, η ∗ . In fact, a pmf is optimalfor (2) if and only if it induces this optimal η ∗ .3. The optimal ρ ∗ for (1) and the optimal η ∗ for (2) satisfy the following properties.(a) (cid:18) (cid:80) e ∈ E ρ ∗ ( e ) (cid:19) (cid:18) (cid:80) e ∈ E η ∗ ( e ) (cid:19) = 1 , and(b) η ∗ ( e ) = ρ ∗ ( e )Mod(Γ) for all e ∈ E . Finally, we review the concept of graph vulnerability introduced in [9]. We shall adopt a notationsimilar but not identical to the notations of [9] and [11].For any subset of edges J ⊆ E , define M ( J ) := min γ ∈ Γ | γ ∩ J | and θ ( J ) := (cid:40) M ( J ) | J | if J (cid:54) = ∅ , J = ∅ . (3)The quantity M ( J ) is the minimum possible overlap between the edge set J and any spanning treeof G . The value θ ( J ) is called the vulnerability of J . The vulnerability of the graph G , θ ( G ), is themaximum vulnerability of subsets of its edges. That is θ ( G ) := max J ⊆ E θ ( J ) . (4)A set J is said to be critical if θ ( J ) = θ ( G ) . (5)Since J = E is one possible choice, there is a simple lower bound for any nontrivial graph: θ ( G ) ≥ | V | − | E | > . Thus, the empty set is never critical for a nontrivial graph. There can be more than one critical set.A key result of [9] is the existence of a polynomial-time algorithm for computing θ ( G ). A methodfor additionally finding a critical set is presented in Section 4.1. The primary contribution of this work is the construction of an algorithm proving that the spanningtree modulus problem can be solved in polynomial time. The remainder of this paper is organizedas follows. In Section 2, we show that an algorithm capable of finding a critical set can be usedrecursively to find the optimal edge usage probabilities η ∗ . In Section 3, we review Cunningham’s3olynomial-time algorithm for graph vulnerability. In Section 4, we introduce some modificationsto Cunningham’s algorithm. One of these is necessary in order to compute spanning tree modulus,the other is a practical modification that allows the use of integer arithmetic in implementationsof the spanning tree modulus algorithm. Finally, in Section 5, we detail the final polynomial-timealgorithm for spanning tree modulus, provide an analysis of its run-time complexity, and presentsome computational examples. In this section, we develop in more detail the connection between graph vulnerability and spanningtree modulus. Most of the following results are consequences of the theorems presented in [2], but arenot stated exactly as we need them here. In the interest of keeping the present work self-contained,we present direct proofs of the results we need here. In what follows, µ ∗ represents any optimalpmf for spanning tree modulus and η ∗ represents the corresponding edge usage probabilities. If J ⊆ E is a subset of edges, we denote by G J = ( V, J ) the subgraph of G induced by the edges in J and we let Q ( G J ) be the number of connected components of G J .The following two subgraph decompositions play an important role in the following discussion.Suppose J ⊆ E . When the edges of J are removed from G , we are left with the graph G J , where J = E \ J is the complementary set of edges to J . This graph has a number k = Q ( G J ) of connectedcomponents, call them G (cid:48) i = ( V i , E (cid:48) i ) for i = 1 , , . . . , k . The sets { V , V , . . . , V k } form a partitionof the vertex set V and the sets { J, E (cid:48) , E (cid:48) , . . . , E (cid:48) k } form a partition of the edge set E . The set J also induces a related family of subgraphs G i = ( V i , E i ). Each G i has the same vertex set as G (cid:48) i and has edge set E i = { e ∈ E : e is incident upon two vertices in V i } . In other words, each G i is the vertex-induced subgraph that is induced by V i . Notice that E (cid:48) i ⊆ E i and that E i \ E (cid:48) i ⊆ J . The following lemma collects some well-known facts about spanning trees. Lemma 2.1.
Let J ⊆ E . Then M ( J ) = Q ( G J ) − . Moreover, if { G (cid:48) i } is the associated collection of subgraphs induced by J as described above and if γ is any spanning tree of G , then | γ ∩ J | = M ( J ) if and only if γ ∩ E (cid:48) i is a spanning tree of G (cid:48) i foreach i .Proof. One way to see this is by a counting argument. For any spanning tree γ and any subgraph G (cid:48) i = ( V i , E (cid:48) i ), γ ∩ E (cid:48) i is acyclic and, therefore, | γ ∩ E (cid:48) i | ≤ | V i | −
1, with equality holding if and onlyif γ ∩ E (cid:48) i is a spanning tree of G (cid:48) i .This implies that | γ ∩ J | = | γ | − k (cid:88) i =1 | γ ∩ E (cid:48) i | ≥ ( | V | − − ( | V | − k ) = Q ( G J ) − . This lower bound can only be attained if | γ ∩ E (cid:48) i | = | V i | − i . To see that this is possible,let γ i be a spanning tree for G (cid:48) i with i = 1 , , . . . , k . Since ∪ i γ i is an acyclic subset of E , there mustbe a spanning tree, γ of G that contains this union. But then | V | − | γ | = | γ ∩ J | + k (cid:88) i =1 | γ ∩ E (cid:48) i | = | γ ∩ J | + | V | − k, M ( J ) = | γ ∩ J | = k − . The following lemma establishes a necessary condition for optimality in (2).
Lemma 2.2. If γ ∈ supp µ ∗ , then (cid:96) η ∗ ( γ ) = min γ (cid:48) ∈ Γ (cid:96) η ∗ ( γ (cid:48) ) . That is, an optimal µ ∗ is supported only on trees with minimum η ∗ -length.Proof. Suppose, to the contrary, that there exists a spanning tree γ (cid:48) ∈ supp µ ∗ that does not haveminimum η ∗ -length and let γ (cid:48)(cid:48) be any minimum η ∗ -length spanning tree. For (cid:15) ∈ [0 , µ (cid:15) = (1 − (cid:15) ) µ ∗ + (cid:15)δ γ (cid:48)(cid:48) . The corresponding edge usage probability for this pmf is η (cid:15) ( e ) = (1 − (cid:15) ) η ∗ ( e ) + (cid:15) e ∈ γ (cid:48)(cid:48) . Define g ( (cid:15) ) := (cid:88) e ∈ E η (cid:15) ( e ) = (cid:88) e ∈ E (cid:0) (1 − (cid:15) ) η ∗ ( e ) + (cid:15) e ∈ γ (cid:48)(cid:48) (cid:1) = (1 − (cid:15) ) g (0) + 2 (cid:15) (1 − (cid:15) ) (cid:88) e ∈ γ (cid:48)(cid:48) η ∗ ( e ) + (cid:15) ( | V | − g (0) + 2 (cid:15) (cid:0) (cid:96) η ∗ ( γ (cid:48)(cid:48) ) − g (0) (cid:1) + O ( (cid:15) ) . But g (0) = (cid:88) e ∈ E η ∗ ( e ) = (cid:88) e ∈ E η ∗ ( e ) (cid:88) γ ∈ Γ e ∈ γ µ ∗ ( γ )= (cid:88) γ ∈ Γ µ ∗ ( γ ) (cid:88) e ∈ E η ∗ ( e ) e ∈ γ = (cid:88) γ ∈ Γ µ ∗ ( γ ) (cid:96) η ∗ ( γ ) > (cid:96) η ∗ ( γ (cid:48)(cid:48) ) , where the strict inequality arises from the facts that γ (cid:48) ∈ supp µ ∗ and (cid:96) η ∗ ( γ (cid:48) ) > (cid:96) η ∗ ( γ (cid:48)(cid:48) ). Thus, forsufficiently small (cid:15) > (cid:88) e ∈ E η (cid:15) ( e ) = g ( (cid:15) ) < g (0) = (cid:88) e ∈ E η ∗ ( e ) , which contradicts the optimality of η ∗ .The set of edges where η ∗ attains its maximum plays an important role in our results. To thisend, define E ∗ := { e ∈ E : η ∗ ( e ) = η ∗ max } , where η ∗ max := max e ∈ E η ∗ ( e ) . Lemma 2.3. If γ ∈ supp µ ∗ , then | γ ∩ E ∗ | = M ( E ∗ ) . roof. To see why this must be true, let γ ∈ supp µ ∗ and consider constructing another spanningtree γ (cid:48) ∈ Γ as follows. First, remove all edges of E ∗ from γ , leaving a forest γ \ E ∗ . Now, proceedas one would in Kruskal’s algorithm, successively adding back an edge with the smallest η ∗ possiblewithout creating a cycle. After some number of edge additions, a spanning tree γ (cid:48) will result. Ifany of the added edges were from E \ E ∗ , then we would have (cid:96) η ∗ ( γ (cid:48) ) < (cid:96) η ∗ ( γ ), which contradictsLemma 2.2. Thus, if we add any edge in E \ E ∗ to γ \ E ∗ we must create a cycle. This impliesthat γ \ E ∗ restricted to any connected component of G E ∗ is a spanning tree. From Lemma 2.1 itfollows that | γ ∩ E ∗ | = Q ( G E ∗ ) − M ( E ∗ ). Lemma 2.4.
The largest value η ∗ attains is η ∗ max = θ ( E ∗ ) . Proof.
This follows from the fact that | E ∗ | η ∗ max = (cid:88) e ∈ E ∗ η ∗ ( e ) = (cid:88) e ∈ E ∗ (cid:88) γ ∈ Γ e ∈ γ µ ∗ ( γ )= (cid:88) γ ∈ Γ µ ∗ ( γ ) (cid:88) e ∈ E ∗ e ∈ γ = (cid:88) γ ∈ supp µ ∗ µ ∗ ( γ ) | γ ∩ E ∗ | = M ( E ∗ ) , where the final equality follows from Lemma 2.3.Now we are ready to prove the first theorem that will allow us to use graph vulnerability tocompute spanning tree modulus. Theorem 2.5.
Let J ⊆ E be a critical set for G . Then, for all e ∈ J , η ∗ ( e ) = θ ( J ) = θ ( G ) = θ ( E ∗ ) = η ∗ max . Proof.
Note that, similar to the proof of the previous theorem, | J | η ∗ max ≥ (cid:88) e ∈ J η ∗ ( e ) = (cid:88) γ ∈ Γ µ ∗ ( γ ) | γ ∩ J | ≥ M ( J ) . Thus, by Lemma 2.4, θ ( G ) ≥ θ ( E ∗ ) = η ∗ max ≥ | J | (cid:88) e ∈ J η ∗ ( e ) ≥ θ ( J ) = θ ( G ) , and the inequalities are actually satisfied as equalities. Since the average of η ∗ over J equals to η ∗ max , it follows that η ∗ attains this maximum on all edges of J .Theorem 2.5 provides the first step in an algorithm for computing the spanning tree modulus.If we have an algorithm, such as the one provided by Cunningham, that finds both θ ( G ) and acritical set J , then we immediately know that η ∗ takes the value θ ( G ) on the edges of J . Thetheorem implies that J ⊆ E ∗ , but the inclusion could be strict. In any case, this step provides thevalue of η ∗ on at least one edge. Next, we show how this procedure can be repeated recursively tofind η ∗ on the remaining edges. To see this, we need to establish a few facts about a critical set J and about the components of G J .As described at the beginning of this section, the removal of J from G induces a set of subgraphs { G i = ( V i , E i ) } of G . By construction, E \ ( ∪ i E i ) ⊆ J . However, there is, a priori, no reason tosuppose that ( ∪ i E i ) ∩ J is empty. This is addressed in the following lemma.6 emma 2.6. Let J be a critical set for G and let G i = ( V i , E i ) for i = 1 , , . . . , k be the associated k = Q ( G J ) subgraphs constructed as above. Then (cid:32) k (cid:91) i =1 E i (cid:33) ∩ J = ∅ . Proof.
Suppose the intersection is nonempty, and let J (cid:48) = J \ (cid:32) k (cid:91) i =1 E i (cid:33) . By assumption, Q ( G J ) = Q ( G J (cid:48) ) and | J (cid:48) | < | J | . Thus, by Lemma 2.1, θ ( J (cid:48) ) = M ( J (cid:48) ) | J (cid:48) | > M ( J ) | J | = θ ( G ) , which is a contradiction.Our next step is to show that any optimal pmf µ ∗ on G induces marginal pmfs on the familiesΓ i of spanning trees on the subgraphs G i . Lemma 2.7.
Let µ ∗ be an optimal pmf for spanning tree modulus on G , let J be a critical set, andlet G i = ( V i , E i ) be one of the subgraphs of G induced by J . Define µ i ( γ (cid:48) ) := µ ∗ (cid:0) { γ ∈ Γ : γ ∩ E i = γ (cid:48) } (cid:1) for all γ (cid:48) ∈ Γ i . Then µ i ∈ P (Γ i ) .Proof. By definition, µ i is a non-negative function on Γ i . To see that it is a pmf, then, it remainsto verify that µ i (Γ i ) = 1. Let γ ∩ E i = γ (cid:48) be the indicator variable γ ∩ E i = γ (cid:48) := (cid:40) γ ∩ E i = γ (cid:48) , γ ∩ E i (cid:54) = γ (cid:48) , and note that (cid:88) γ (cid:48) ∈ Γ i µ i ( γ (cid:48) ) = (cid:88) γ (cid:48) ∈ Γ i (cid:88) γ ∈ Γ γ ∩ E i = γ (cid:48) µ ∗ ( γ ) = (cid:88) γ ∈ Γ µ ∗ ( γ ) (cid:88) γ (cid:48) ∈ Γ i γ ∩ E i = γ (cid:48) . Since γ ∩ E i can match at most one of the trees in Γ i , the innermost sum is at most one. To seethat it actually equals to one, we need to verify that γ ∩ E i ∈ Γ i for any γ ∈ supp µ ∗ . That is, weneed to show that every tree in the support of µ ∗ restricts as a tree on G i .Suppose, to the contrary, that there is a spanning tree γ ∈ supp µ ∗ such that γ ∩ E i does notform a spanning tree of G i . Then, since the set γ ∩ E i is acyclic, either it doesn’t span all of G i or it is a forest with more than one tree. In either case, there must exist an edge e ∈ E i with theproperty that ( γ ∩ E i ) ∪ { e } does not contain a cycle. By Lemma 2.6, e / ∈ J . Consider the set γ (cid:48) = γ ∪ { e } . Since γ is a spanning tree of G , γ (cid:48) must contain a cycle. Moreover, since γ (cid:48) ∩ E i doesnot contain a cycle, the cycle in γ (cid:48) must cross at least one edge e (cid:48) of J . By removing this edge from γ (cid:48) , we obtain a new spanning tree γ (cid:48)(cid:48) = γ (cid:48) \ { e (cid:48) } ∈ Γ with the property that | γ (cid:48)(cid:48) ∩ J | < | γ ∩ J | = M ( J ) , which is a contradiction. This shows that µ i is indeed a marginal pmf on Γ i .7ext we show a technique for modifying pmfs on Γ in such a way that the edge usage probabilitieschange only on E i . Lemma 2.8.
Let µ ∗ be an optimal pmf for spanning tree modulus on G , let J be a critical set, let G i = ( V i , E i ) be one of the induced subgraphs, and let µ i be any pmf on Γ i , the family of spanningtrees of G i . Let η ∗ and η i be the corresponding edge usage probabilities of µ ∗ and µ i . Then thereexists a pmf µ ∈ P (Γ) with edge usage probabilities η satisfying η ( e ) = (cid:40) η i ( e ) if e ∈ E i ,η ∗ ( e ) if e / ∈ E i . Proof.
Consider the following procedure for randomly constructing a subset of edges F ⊂ E . First,pick a random γ ∈ Γ according to the pmf µ ∗ . Next, pick a random γ i ∈ Γ i according to the pmf µ i . Finally, define the random set F as F := ( γ \ E i ) ∪ γ i . We claim that F ∈ Γ.To see this, recall that in the proof of Lemma 2.7 we showed that γ ∩ E i ∈ Γ i . This impliesthat | γ ∩ E i | = | V i | − | γ i | . Since γ i ⊂ E i , it follows that | F | = | γ | − | γ ∩ E i | + | γ i | = | γ | = | V | − , so F has the correct number of edges for a spanning tree. Thus, F can only fail to be a spanningtree if it contains a cycle.Suppose such a cycle, C ⊂ E , does exist. Since F ∩ E i = γ i is a spanning tree, C must useat least one edge e ∈ E \ E i . Let S be the largest connected subset of C \ E i containing e . Since S ∈ γ , S must be the edges traversed by a path connecting two distinct vertices x, y ∈ V i and usingonly edges in E \ E i . Since γ ∩ E i must be a spanning tree of G i by Lemma 2.7, it contains a pathfrom x to y consisting only of edges in E i . But this implies that γ contains two different pathsconnecting x to y , which contradicts the fact that γ is a spanning tree.Hence, the procedure outlined above produces a random spanning tree on G . Let γ , γ i , and F represent the corresponding random objects described in this procedure. As stated, F is a randomspanning tree on G with a corresponding pmf µ . Although the formula for µ is complex, theresulting edge usage probabilities, η , are straightforward to compute.First, suppose that e ∈ E i . Then η ( e ) = P µ ( e ∈ F ) = P µ i ( e ∈ γ i ) = η i ( e ) . Similarly, if e / ∈ E i , then η ( e ) = P µ ( e ∈ F ) = P µ ∗ ( e ∈ γ \ E i ) = P µ ∗ ( e ∈ γ ) = η ∗ ( e ) . The recursive algorithm for spanning tree modulus is made possible by the following theorem.
Theorem 2.9.
Let J be a critical set for G and let G i = ( V i , E i ) for i = 1 , , . . . , k be the associated k = Q ( G J ) subgraphs constructed as above. Let η ∗ be the optimal edge usage probabilities for G andlet η ∗ i be the optimal edge usage probabilities for each G i . Then, for every e ∈ E i , η ∗ ( e ) = η ∗ i ( e ) . roof. Let µ ∗ be an optimal pmf for the spanning tree modulus of G and let µ ∗ i be an optimal pmffor the spanning tree modulus of G i . Let µ ∈ P (Γ) be the pmf guaranteed by Lemma 2.8 and let η be the corresponding edge usage probabilities. since µ ∗ i is optimal, Lemma 2.7 implies that (cid:88) e ∈ E i η ∗ i ( e ) ≤ (cid:88) e ∈ E i η ∗ ( e ) . By Lemma 2.8, then, (cid:88) e ∈ E η ∗ ( e ) ≤ (cid:88) e ∈ E η ( e ) = (cid:88) e ∈ E i η ∗ i ( e ) + (cid:88) e ∈ E \ E i η ∗ ( e ) ≤ (cid:88) e ∈ E η ∗ ( e ) . By part 2 of Theorem 1.1, it follows that η = η ∗ . In particular, for e ∈ E i , η ∗ ( e ) = η ( e ) = η ∗ i ( e ) . Theorem 2.9 suggests the following algorithm for computing spanning tree modulus using analgorithm for graph vulnerability, such as the one Cunningham provides. First, find the value θ ( G )and a critical set J . Theorem 2.5 shows that η ∗ takes the value θ ( G ) on all edges of J . Now, removethese edges from G . This results in a number of connected subgraphs G , G , . . . . By Theorem 2.9,if we find θ ( G ) along with a critical set J of G , then the optimal η ∗ (for spanning tree modulusof G !) takes the value θ ( G ) on the edges of J . This procedure can be repeated, each time finding η ∗ for at least one edge. Thus, after finitely many iterations, η ∗ will be known for all edges. Amore detailed description of this algorithm is presented in Section 5. In this section, we review the algorithm presented in [9] along with its theoretical background.In some places we have provided our own explanations or proofs where we feel it will aid inunderstanding.First, if J ⊆ E and γ ∈ Γ, then from (3) M ( J ) ≤ | J ∩ γ | ≤ min {| γ | , | J |} = min {| V | − , | J |} . Moreover, since J ⊆ E , we have | J | ≤ | E | . Thus, for any ∅ (cid:54) = J ⊆ E , θ ( J ) = M ( J ) | J | ∈ Θ := (cid:26) pq : 1 ≤ p ≤ min {| V | − , q } , ≤ q ≤ | E | (cid:27) . (6)Since there are finitely many options for the numerator and denominator in θ ( J ), there are finitelymany possible values for θ ( G ). In [9], this fact is exploited to compute θ ( G ). Essentially, oneperforms a binary search on the set of possible values, making use of an oracle that can determinewhether or not θ ( G ) ≤ pq for a given fraction pq . This oracle is derived by performing a fewtransformations on the problem that convert it to a problem on a matroid that can be solved by agreedy algorithm. Lemma 3.1.
For any p, q ≥ , we have θ ( G ) ≤ pq ⇐⇒ ≤ min J ⊆ E (cid:16) pq | J | − M ( J ) (cid:17) . (7)9 roof. θ ( G ) ≤ pq ⇐⇒ max J ⊆ E θ ( J ) ≤ pq ⇐⇒ θ ( J ) ≤ pq ∀ J ⊆ E ⇐⇒ ≤ pq | J | − M ( J ) ∀ J ⊆ E ⇐⇒ ≤ min J ⊆ E (cid:16) pq | J | − M ( J ) (cid:17) . From this lemma, we can see that checking whether θ ( G ) ≤ pq is equivalent to solving theminimization problem in (7). Cunningham called this minimization problem the optimal attackproblem . Next, the optimal attack problem is converted into a question about a matroid. By a matroid ,we mean (one of several equivalent definitions) a tuple M = ( E, f ) where E is a finite set and f : 2 E → N is a function assigning to every subset of E a non-negative integer value satisfying thefollowing properties.1. For each J ⊆ E , f ( J ) ≤ | J | .2. If J (cid:48) ⊆ J ⊆ E , then f ( J (cid:48) ) ≤ f ( J ).3. If J, J (cid:48) ⊆ E , then f ( J ∪ J (cid:48) ) + f ( J ∩ J (cid:48) ) ≤ f ( J ) + f ( J (cid:48) ).Any function f that satisfies these conditions is called a polymatroid function . An importantexample of a matroid in the context of the present work is the graphic matroid M = ( E, f ) where E is the edge set of a connected graph, and f is the graphic rank function defined as f ( J ) := | V | − Q ( G J ) . (8)Using Lemma 2.1, we can write M ( J ) = | V | − − f ( J ) . (9)So, the minimization (7) can be rewritten asmin J ⊆ E (cid:16) pq | J | − | V | + 1 + f ( J ) (cid:17) . Thus, we arrive at a fundamental lemma for Cunningham’s algorithm.
Lemma 3.2.
The following are equivalent.1. θ ( G ) ≤ pq min J ⊆ E (cid:16) pq | J | + f ( J ) (cid:17) ≥ | V | − .2 The polymatroid theorem and graph vulnerability Given a polymatroid function f on a set E , we define the polymatroid associated with f to be thepolytope defined as P ( f ) := { x ∈ R E ≥ , x ( J ) ≤ f ( J ) for all J ⊆ E } , (10)where we use the notation x ( J ) to represent the sum x ( J ) = (cid:88) e ∈ J x ( e ) . For any y ∈ R E ≥ , any maximal vector x ∈ P ( f ) with x ≤ y is called a P ( f )-basis of y .The following is the key theorem of [9] that establishes the connection between graph vulnera-bility and polymatroid bases. Theorem 3.3 (Theorem 1 of [9]) . Let y ∈ R E ≥ and let x be any P ( f ) -basis of y , then x ( E ) = min J ⊆ E (cid:0) y ( J ) + f ( ¯ J ) (cid:1) . (11)To see how Theorem 3.3 can be applied to the graph vulnerability problem, we recall thegraphic rank function f defined in (8) is a polymatroid function. Thus, if we define y ≡ pq (theconstant vector) and let x be a P ( f )-basis of y , then Lemma 3.2 combined with Theorem 3.3implies that θ ( G ) ≤ pq if and only if x ( E ) ≥ | V | −
1. Thus, an algorithm that can efficientlycompute polymatroid bases can be used together with a binary search to compute the vulnerabilityof a graph. Cunningham provided such an algorithm in [9].
By definition, if f is a polymatroid function, x ∈ P ( f ), x ≤ y and J ⊆ E , then x ( J ) ≤ f ( J ) and x ( J ) ≤ y ( J ), so x ( E ) = x ( J ) + x ( J ) ≤ y ( J ) + f ( J ) . (12)Theorem 3.3 implies that if x is a P ( f )-basis of y , then there exists a J ⊆ E for which (12) holdsas equality. In particular, this J must satisfy x = y on J and x ( J ) = f ( J ) . (13)A set J satisfying the second of these equalities is called tight with respect to x . Cunningham’sgreedy algorithm simultaneously finds a P ( f )-basis of a given y together with a set J satisfying (13).A pseudocode listing of this algorithm is shown in Algorithm 1. Remark . In fact, Cunningham’s original version of Algorithm 1 used the non-strict inequality( ≤ ) rather than the strict inequality ( < ) on line 5. This choice only exacerbates the difficulty offinding the critical set described in Section 4.1. Additional modifications are described in Section 4.At the beginning of the algorithm, x is initialized to the zero vector and J is initialized to theempty set (in other words, J is initialized to all of E ). The algorithm proceeds by looping over alledges j of E . On each iteration of the loop, one computes the value (cid:15) max ( j ) = max { (cid:15) : x + (cid:15) j ∈ P ( f ) } (14)along with a set J (cid:48) ( j ) containing j and satisfying f ( J (cid:48) ( j )) = x ( J (cid:48) ( j )) + (cid:15) max ( j ) . (15)11 lgorithm 1 Cunningham’s algorithmInput: G=(V,E), y x ← J ← ∅ for all j ∈ E do (cid:15), J (cid:48) ( j ) ← min { f ( J (cid:48) ) − x ( J (cid:48) ) : j ∈ J (cid:48) ⊆ E } if (cid:15) < y ( j ) − x ( j ) then J ← J ∪ J (cid:48) ( j ) else (cid:15) = y ( j ) − x ( j ) end if x ( j ) ← x ( j ) + (cid:15) end for return x, J = E \ J The value (cid:15) max is the largest value by which we can increment x on edge j without leaving P ( f )and the set J (cid:48) ( j ) is a constraint that would be violated if we were to increase x by any more onthat edge.Next in the algorithm is a decision. If x ( j ) can be increased by (cid:15) max without violating theconstraint that x ( j ) ≤ y ( j ), then x ( j ) is incremented by that amount and the edges in J (cid:48) ( j ) areadded to J (equivalently, J is intersected with J (cid:48) ( j )). Otherwise, x ( j ) is set to y ( j ) and J is notchanged.A proof of the correctness of the algorithm can be found in [9]. Additional details omitted fromthe discussion there can be found in [14]. The important theorem is as follows. Theorem 3.5.
When Algorithm 1 completes, the vector x is a P ( f ) -basis of y and J is a tight set with respect to x . That is, x ( J ) = f ( J ) . The most computationally challenging part of Algorithm 1 occurs on line 4 when minimizing f ( J ) − x ( J ) over all subsets J ⊆ E that contain a particular edge j . Although this appearsto be combinatorially difficult at first look, Cunningham’s approach was to recast this optimizationproblem as a minimum cut problem on an auxiliary graph.As described in [9], given x ∈ P ( f ) and j ∈ E , the first step is to construct an undirectedcapacitated graph G (cid:48) . The vertex set for G (cid:48) is V ∪ { r, s } , where r and s are new vertices which willrespectively be the source and sink of a network flow. Each edge e ∈ E has a corresponding edgein G (cid:48) with capacity x ( e ). Edges are added connecting from s to each vertex v ∈ V and havingcapacity 1. Edges are also added from r to each v ∈ V having capacity ∞ if v is an end pointof j , or x ( δ ( v )) otherwise. Here δ ( U ) = { e ∈ E, e has exactly one end in U ⊆ V } , and δ ( v ) isshorthand for δ ( { v } ). An example of this augmented graph G (cid:48) is shown in Figure 1. As shownin [9], it is straightforward to recover (cid:15) max ( j ) in (14) from the value of a minimum rs -cut in G (cid:48) .Moreover, the edges of a minimum rs -cut (after removing any edges incident on r or s ) form a tightset J (cid:48) ( j ) satisfying (15). 12
111 1 1a b cdefr s(x bc +x cd ) x ab x bc x cd x de x ef x fa (x ab + x bc )(x de + x ef )(x cd + x de )
12 1212 12 12 12121212 a b cdef
Inf
Inf
G G' cddeeffa ab bc x x xxxx Figure 1: An example of the minimum cut problem described in Section 3.4. The original graph G is shown on the left. The goal is to increase the value of x on the highlighted edge j = { f, a } asmuch as possible without violating any constraints of the polymatroid defined in (10). The right-hand side shows the corresponding flow graph G (cid:48) . The maximum increment (cid:15) max ( j ) is computedfrom the value of the minimum cut; a tight set J (cid:48) ( j ) is obtained from the minimum cut edges. The polynomial-time algorithm for computing θ ( G ), described in [9] proceeds as follows. First,recall that θ ( G ) must belong to a finite set (e.g., θ ( G ) must belong to Θ as defined in (6)). Thus,if one can produce a polynomial-time oracle to determine whether θ ( G ) ≤ pq for a given pq , then asimple binary search of Θ will produce the value θ ( G ) in polynomial-time. Algorithm 1 providesjust such an oracle if one uses the minimum cut formulation of Section 3.4. Before we proceed to computing the spanning tree modulus, we need to discuss some modificationsto Cunningham’s algorithm. The first modification is necessary in order to ensure that we can obtainnot only the graph vulnerability, θ ( G ) but also a critical set of edges. The second modification ishelpful for efficient computation in exact arithmetic. An important step in the spanning tree modulus algorithm described in Section 2 is the identificationof both the vulnerability θ ( G ) and a critical set J satisfying (5). This latter point proved somewhatmore difficult than we originally anticipated, due to an interesting consequence of the theory.What we observed in our initial implementations of Algorithm 1 is that, when it is called with y = θ ( G ), it will often return an empty set E \ J . (That is, at the end of the algorithm, J = E .)This phenomenon is more common when using exact arithmetic than when using floating pointarithmetic. This failure to produce a critical set initially surprised us and eventually exposed asubtle misunderstanding on our part. Since it does not appear to be addressed in the literature,we wish to call attention to this aspect of the algorithm and to present a simple modification thatis guaranteed to produce a critical set. 13 / / / / / / / / / Figure 2: An example, described in Section 4.1, of how Cunningham’s algorithm may not producea critical set of edges.The key to understanding why Algorithm 1 might return an empty set when called with y exactly equal to θ ( G ) is to recall the guarantee on J . In particular, Theorem 3.5 guarantees that J is tight with respect to the P ( f )-basis x . Now, consider the following theorem. Theorem 4.1. If θ ( G ) = pq and if x is a P ( f ) -basis for y ≡ pq , then E is tight with respect to x .Proof. Since θ ( G ) = pq , we have f ( E ) ≥ x ( E ) since x ∈ P ( f )= min J ⊆ E (cid:18) pq | J | + f ( J ) (cid:19) by Theorem 3.3 ≥ | V | − f ( E ) since G is connected . This implies that x ( E ) = f ( E ). In other words, E is tight.Theorem 4.1 shows that there is no theoretical barrier to Algorithm 1 returning the empty setwhen y = θ ( G ). To see how this can occur in practice, consider the graph in Figure 2. This graphhas θ ( G ) = with a critical set consisting of the three left-most edges. The left side of Figure 2shows the value of x after 7 steps of Algorithm 1 with y ≡ . Edges are labeled with their current x -value and the darker edges are those that have already been visited by the algorithm. In each ofthe steps thus far, the inequality on line 5 of the algorithm has been false and, therefore, J = ∅ .There are two edges remaining to process.Suppose the algorithm next moves to the upper of these two edges. In considering the poly-matroid constraints in line 4 of the algorithm, there are two possible “tightest” constraints thatmight be located. The first is the set J (cid:48) consisting of the tetrahedral subgraph. This set has rank f ( J (cid:48) ) = 3 and (currently) x ( J (cid:48) ) = . Thus, x on the edge currently under consideration cannot bemade larger than . The other constraint that may be found in this step is the set J (cid:48) = E . This sethas rank f ( J (cid:48) ) = 5 and (currently) x ( J (cid:48) ) = . Again, x on the edge currently under considerationcannot be increased above . The latter choice will result in J = E and the algorithm will notlocate a critical set.Which of these two constraints are found on line 4 of the algorithm depends heavily on im-plementation details for the minimum cut algorithm. For example, we have observed that thealgorithm returns an empty set more frequently in our Python implementation (based on the Net-workX library [13]) than in our C++ implementation (based on the Boost Graph Library [15]) ofthis algorithm. 14n practice, this means that using the oracle-based binary search described in [9, 11] will alwaysfind θ ( G ), but may not result in finding a critical edge set. Our suggestion to address this problemis based on the following theorem. Theorem 4.2.
Suppose that θ ( G ) = pq and that p (cid:48) q (cid:48) < pq satisfies (cid:18) p (cid:48) q (cid:48) , pq (cid:21) ∩ Θ = (cid:26) pq (cid:27) . (16) Suppose further that ˜ x is a P ( f ) -basis for y ≡ p (cid:48) q (cid:48) and that J is tight with respect to ˜ x . Then J is acritical set for G .Proof. First, we show that J cannot be E . If it were, then we would have | V | − f ( E ) = ˜ x ( E ) = min J (cid:48) ⊆ E (cid:26) p (cid:48) q (cid:48) | J (cid:48) | + f ( J (cid:48) ) (cid:27) , which, by Lemma 3.2, would imply that θ ( G ) ≤ p (cid:48) q (cid:48) < pq = θ ( G ) , yielding a contradiction.Now, when Cunningham’s algorithm terminates, we have both ˜ x and the tight set J with theproperty that ˜ x = p (cid:48) q (cid:48) on J (cid:54) = ∅ . Moreover, since θ ( G ) > p (cid:48) q (cid:48) , Lemma 3.2 implies that | V | − > p (cid:48) q (cid:48) | J | + f ( J ) . By (9), this implies that p (cid:48) q (cid:48) | J | < | V | − − f ( J ) = M ( J ) . Thus, we have that p (cid:48) q (cid:48) < M ( J ) | J | ≤ θ ( G ) = pq . Choosing p (cid:48) and q (cid:48) so that (16) holds guarantees that M ( J ) / | J | = p/q and, thus, that J iscritical.Thus, if Cunningham’s algorithm produces the θ ( G ), but fails to produce a critical set, we canre-run Cunningham’s algorithm with y slightly smaller than θ ( G ) to obtain a critical set. A choicefor p (cid:48) and q (cid:48) can be found using the following simple lower bound on the distance between distinctnumbers in Θ. If p/q, p (cid:48) /q (cid:48) ∈ Θ and p (cid:48) /q (cid:48) < p/q , then pq − p (cid:48) q (cid:48) = pq (cid:48) − qp (cid:48) qq (cid:48) ≥ | E | . (17)Thus, choosing p (cid:48) q (cid:48) = pq − | E | = p | E | − qq | E | guarantees that (16) holds. 15 .2 Modifications for exact arithmetic Our primary goal in this section is to build upon Cunningham’s algorithm to construct an algorithmfor computing spanning tree modulus in exact arithmetic. We first observe that this is alreadypossible using Algorithm 1 as written, provided all computations are performed using rationalarithmetic. The main downside to this approach is that the arithmetic (which must be donein software) is much slower than arithmetic performed on hardware. On the other hand, if afloating point representation is used to improve the speed of the algorithm, one naturally sacrificesexactness for numerical approximation, and the impact of these approximations do not appear tobe analyzed in the literature. As an alternative, this section presents an implementation usinginteger arithmetic, which can be performed on hardware.The modification for integer arithmetic is based on the observation that if f is a polymatroidfunction and if q >
0, then qf is a polymatroid function. Moreover, there is a straightforwardconnection between P ( f )-bases and P ( qf )-bases. Lemma 4.3.
Let x be a P ( f ) -basis of y. Then qx is a P ( qf ) -basis of qy , for any q > .Proof. By definition, P ( qf ) = { x ∈ R E ≥ : x ( J ) ≤ qf ( J ) ∀ J ⊆ E } = { x ∈ R E ≥ : 1 q x ( J ) ≤ f ( J ) ∀ J ⊆ E } = { qx ∈ R E ≥ : x ( J ) ≤ f ( J ) ∀ J ⊆ E } = qP ( f ) . (18)Since x is a P ( f )-basis of y , we have qx ≤ qy . Thus, in order to show that qx is a P ( qf ) basisof qy , we need only verify maximality. If there exists z ∈ P ( qf ) such that z ≤ qy and qx ≤ z then q z ∈ P ( f ), q z ≤ y , and x ≤ q z , which implies that q z = x and, therefore, that z = qx . Algorithm 2
Integer arithmetic version of Cunningham’s algorithmInput: G = ( V, E ) , p, q x (cid:48) ← J ← ∅ for all j ∈ E do (cid:15), J (cid:48) ( j ) ← min { qf ( J (cid:48) ) − x (cid:48) ( J (cid:48) ) : j ∈ J (cid:48) ⊆ E } if (cid:15) < p − x (cid:48) ( j ) then J ← J ∪ J (cid:48) ( j ) else (cid:15) = p − x (cid:48) ( j ) end if x (cid:48) ( j ) ← x (cid:48) ( j ) + (cid:15) end for return x (cid:48) , J = E \ J In light of Lemma 4.3, consider Algorithm 2. Through a step-by-step comparison, one can seethat Algorithm 1 (with y = pq ) and Algorithm 2 are equivalent in the sense that x (cid:48) = qx and bothproduce the same J . An important aspect of this comparison is the relationship between line 4 ineach algorithm. Lemma 4.3 shows that these two steps effectively compute the same thing, with (cid:15) differing only by the multiplicative constant q . 16ote that x (cid:48) is initialized as an integer vector in line 1 of Algorithm 2. Since qf ( J (cid:48) ) is an integerfor any J (cid:48) ⊆ E , (cid:15) is also an integer in line 4. Since p is an integer (cid:15) remains an integer even if line8 is executed. Thus, in line 10, the updated x (cid:48) remains an integer vector. In each step described,only integer arithmetic is needed. All that remains, then, is to verify that the computation on line4 can be performed using integer arithmetic.This is the consequence of a straightforward modification to the minimum cut algorithm de-scribed in Section 3.4 (Figure 1 may help visualize the argument). If each capacity in the graph G (cid:48) is multiplied by 2 q , the resulting capacities are integer valued. Edges which had capacity 1now have capacity 2 q ; edges which had capacity x ( e ) now have capacity 2 x (cid:48) ( e ); and edges whichhad capacity x ( δ ( v )) now have capacity x (cid:48) ( δ ( v )). Moreover, any minimum rs -cut of G (cid:48) with theoriginal capacities is also a minimum rs -cut with the new capacities and vice versa. To performline 4 of Algorithm 2, then, we may generate G (cid:48) as before, but with all capacities multiplied by2 q . A minimum cut can now be found using an integer arithmetic maximum flow algorithm. Theedges of this cut are the edges J (cid:48) ( j ) that we seek and the value of the cut is 2 (cid:15) (twice the largestincrement we can make to x (cid:48) ( j ) while remaining in P ( qf )). The value of (cid:15) can then be found byinteger division. As outlined in Section 2, the modified version of Cunningham’s algorithm presented in Section 4allows us to compute the spanning tree modulus of G in exact arithmetic. Pseudocode for thealgorithm is shown in Algorithm 3. Algorithm 3
Modulus using graph vulnerabilityInput: G = ( V, E ) q ← queue([ G ]) while q is not empty do G (cid:48) ← pop( q ) compute θ ( G (cid:48) ) and a critical set J for all e ∈ J do η ∗ ( e ) ← θ ( G (cid:48) ) end for remove edges in J from G (cid:48) for all nontrivial connected components G (cid:48)(cid:48) of G (cid:48) do push( q, G (cid:48)(cid:48) ) end for end while We initialize a queue of graphs with the initial graph G . While this queue is not empty, weremove a graph G (cid:48) from the queue and compute its vulnerability along with a critical set of edges.As described in Section 2, this tells us the value of the optimal η ∗ on the edges of J . ApplyingTheorem 2.9, we then remove J from G (cid:48) and add all nontrivial connected components of theresulting graph back into the queue for processing. Once the queue is empty, we will have foundthe value of η ∗ on all edges of G . 17 = 1 * =
12 * =
25 * =
38 * = Figure 3: Steps of the spanning tree modulus applied to Zachary’s karate club graph.
To see that this provides a polynomial-time algorithm, note that the time complexity of eachiteration of the loop in Algorithm 2 is dominated by the cost of finding a minimum cut. One ofthe most efficient known algorithms for computing the minimum cut is the highest-label preflow-push algorithm which has time complexity O ( | V | | E | ) (see [7]). Since the loop in Algorithm 2 isexecuted at most once for each edge in E , the overall complexity of Algorithm 2 is O ( | V | | E | ).Finding the vulnerability and critical set is performed using a binary search over a set of O ( | V || E | )options for the ratio pq and, therefore will call Algorithm 2 on the order of O (log | V | ) times. Thus,finding the critical set has a time complexity of O ( | V | | E | log | V | ). Each execution of this binarysearch is guaranteed to identify η ∗ on at least one edge and, therefore, Algorithm 3 will perform abinary search no more than | E | times. This provides an upper bound on the time complexity forcomputing the modulus in this way of O ( | V | | E | log | V | ). Here, we present a few examples of spanning tree modulus computed using the new algorithm.
Consider the graph in Figure 3 (Zachary’s karate club network). The sequence of figures shows theorder in which values of η ∗ are discovered by Algorithm 3. The critical set for the original graph isthe single edge highlighted in the first subfigure. Since every spanning tree of G must use this edge,its η ∗ value is 1. When this edge is removed indicated by the dashed line in the next subfigure, thegraph is split into two components, only one of which is nontrivial. Again, the critical set found bythe algorithm is highlighted. This time, the associated η ∗ is 1 /
2. When these edges are removed,there is again a single nontrivial component, as shown in the third subfigure, and the algorithmproceeds by finding a critical set of this subgraph. After a few more steps, η ∗ is known on all edgesand the algorithm terminates. The modulus can be computed from η ∗ asMod(Γ) = (cid:32) (cid:18) (cid:19) + 5 (cid:18) (cid:19) + 8 (cid:18) (cid:19) + 34 (cid:18) (cid:19) (cid:33) − = 6809969 . | E |10 c o m p u t e t i m e ( s ) Complete Graphs E | | E |10 c o m p u t e t i m e ( s ) Multipartite Graphs E | | E |10 c o m p u t e t i m e ( s ) G(n,p) Graphs E | | E |10 c o m p u t e t i m e ( s ) Random Geometric Graphs E | Figure 4: Run-time complexity scaling tests as described in Section 5.2.2.
Experimentally, the time complexity estimate from Section 5.1 appears to be pessimistic, as shownin Figure 4. For this figure, we considered four classes of graphs, as described below. For eachclass of graph, we generated a number of test cases on which we ran a C++ implementation ofthe algorithm to compute modulus. Then, on a logarithmic scale, we performed a least-squareslinear regression to find an approximate run time complexity of the form | E | p . In all cases, theactual run-time is significantly faster than the bound predicts. The four classes of graph used inthis experiment are as follows.1. The complete graphs K n with n = 3 , , . . . ,
40. For these graphs, the entire edge set is critical.2. A class of multipartite graphs parameterized by an integer k ≥
2. The vertices of the graphare partitioned into k sets V , V , . . . , V k with | V i | = i . For i = 1 , , . . . , k −
1, every vertexin V i is connected to every vertex in V i +1 . This test included values of k between 2 and 16.These graphs tend to have optimal η ∗ which take k − G ( n, p ) graphs with n chosen randomly in the range [10 , p = 2 log( n ) /n .These graphs tend have η ∗ with only a few distinct values.4. Random geometric graphs formed by placing n vertices in the unit square independently anduniformly at random and then connecting vertices with Euclidean distance closer than radius r = 3 / √ n . Values of n were chosen uniformly from the range [10 , η ∗ that take a variety of distinct values.19igure 5: Visualization of the spanning tree modulus for the C. elegans metabolic network asdescribed in Section 5.2.3.
C. elegans metabolic network
As a final example, we consider the spanning tree modulus of the graph formed from the
C. elegans metabolic network, found in [10]. The data for this graph were downloaded from [6]. After thenetwork is symmetrized and self-loops are removed, the resulting undirected graph has 453 vertices,2025 edges, and approximately 6 . × spanning trees. The optimal η ∗ on this graph takes 32distinct values. Figure 5 provides a visualization of these values. Each edge is colored based onits η ∗ value. Each vertex is sized and colored based on the smallest value of η ∗ among its incidentedges. (Larger vertices correspond to smaller values of η ∗ .) Acknowledgments
This material is based upon work supported by the National Science Foundation under GrantNo. 1515810.
References [1]
Albin, N., Clemens, J., Fernando, N., and Poggi-Corradini, P.
Blocking duality forp-modulus on networks and applications.
Annali di Matematica Pura ed Applicata (1923-)198 , 3 (2019), 973–999.[2]
Albin, N., Clemens, J., Hoare, D., Poggi-Corradini, P., Sit, B., and Tymochko, S.
Fairest edge usage and minimum expected overlap for random spanning trees. arXiv preprintarXiv:1805.10112 (2018).[3]
Albin, N., Kottegoda, K., and Poggi-Corradini, P.
Spanning tree modulus for securebroadcast games.
Networks 76 , 3 (2020), 350–365.[4]
Albin, N., and Poggi-Corradini, P.
Minimal subfamilies and the probabilistic interpre-tation for modulus on graphs.
The Journal of Analysis 24 , 2 (2016), 183–208.205]
Albin, N., Sahneh, F., Goering, M., and Poggi-Corradini, P.
Modulus of families ofwalks on graphs. In
Contemporary Mathematics (2017), vol. 699.[6]
Arenas, A. https://deim.urv.cat/~alexandre.arenas/data/welcome.htm . AccessedAug. 30, 2020.[7]
Cheriyan, J., and Mehlhorn, K.
An analysis of the highest-level selection rule in thepreflow-push max-flow algorithm.
Information Processing Letters 69 , 5 (1999), 239–242.[8]
Clemens, J.
Spanning tree modulus: deflation and a hierarchical graph structure . PhD thesis,Kansas State University, 2018. Available at http://hdl.handle.net/2097/39115 .[9]
Cunningham, W. H.
Optimal attack and reinforcement of a network.
Journal of the ACM(JACM) 32 , 3 (1985), 549–561.[10]
Duch, J., and Arenas, A.
Community detection in complex networks using extremaloptimization.
Physical review E 72 , 2 (2005), 027104.[11]
Gueye, A., Walrand, J. C., and Anantharam, V.
Design of network topology in an ad-versarial environment. In
International Conference on Decision and Game Theory for Security (2010), Springer, pp. 1–20.[12]
Gueye, A., Walrand, J. C., and Anantharam, V.
A network topology design game:How to choose communication links in an adversarial environment? In
Proc. of the 2ndInternational ICST Conference on Game Theory for Networks, GameNets (2011), vol. 11.[13]
Hagberg, A. A., Schult, D. A., and Swart, P. J.
Exploring network structure, dynam-ics, and function using NetworkX. In
Proceedings of the 7th Python in Science Conference (Pasadena, CA USA, 2008), G. Varoquaux, T. Vaught, and J. Millman, Eds., pp. 11 – 15.[14]
Kottegoda, K.
Spanning tree modulus and secure broadcast games . PhD thesis, KansasState University, 2020. Available at https://hdl.handle.net/2097/40756 .[15]
Siek, J., Lumsdaine, A., and Lee, L.-Q.