1 Introduction
Network design is an important subject in computer science and combinatorial optimization. The goal in network design is to build a network that meets some prescribed properties while minimizing the construction cost.
Survivable network design problems (SNDP) are a class of problems where we wish to design a network that is resilient against link or node failures.These problems have been phrased as optimization problems on graphs, where we are given an vertex (undirected or directed) graph with costs on edges or vertices together with a connectivity requirement . The goal is to find a minimumcost subgraph , such that every pair of vertices are connected by edgedisjoint (resp., openly vertexdisjoint) paths. In other words, we wish to design a network in which every pair of vertices remains connected (unless ), even after removing edges (or vertices). The edgeconnectivity version of SNDP (ECSNDP) models the existence of link failures and the vertexconnectivity (VCSNDP) models the existence of both link and node failures. These two problems were known to be NPhard and have received a lot of attention in the past decades (see, e.g., [26, 16, 32, 34]).
While VCSNDP and ECSNDP address the questions that arise from designing telecommunication networks, another direction of research focuses on the questions that arise from media broadcasting as in cable television or streaming services. In this case, we may wish to connect the global server to a single local server in each community, who will forward the stream to all the clients in the area through their own local network. The goal here is slightly different from the usual SNDP, as it is not required to construct a network that spans every client; instead, we simply need to choose a local server (or representative), which will take care of connecting to other clients in the same group. This scenario motivates the Group Steiner Tree problem (GST) and its faulttolerant variant, the Rooted Group SNDP.
In Rooted Group SNDP, we are given a graph with costs on edges or vertices, a root vertex , and a collection of subsets of vertices called groups, , together with connectivity demands , . The goal in this problem is to find a minimum cost subgraph such that has edgedisjoint (or openly vertexdisjoint) paths connecting the root vertex to some vertex , for all . In other words, we wish to choose one representative from each group and find a subgraph of such that each representative is edge(or vertex)connected to the root.
When , the problem becomes the wellknown Group Steiner Tree (GST) problem. Here, we are given a graph with edge or vertex costs, a root and a collection of subsets of vertices called groups, , and the goal is to find a minimumcost subgraph that has a path to some vertex in each , for . The GST problem is known to admit an approximation algorithm [22] and cannot be approximated to a factor of unless [25].
The Rooted Group SNDP generalizes GST to handle fault tolerance. The case where is studied in [27, 23], culminating in the approximation algorithm for the problem. For , there is no known nontrivial approximation algorithm. It is known among the experts that this problem is at least as hard as the LabelCover problem^{1}^{1}1The hardness for the case of directed graph was shown in [27], but it is not hard to show the same result for undirected graphs..
Chalermsook, Grandoni and Laekhanukit [13] studied a relaxed version of the problem in which we are not restricted to connect to a single vertex in each group and thus need only edgedisjoint paths connecting the root vertex to the whole group . Despite being a relaxed condition, the problem remains as hard as the LabelCover problem, and they only managed to design a bicriteria approximation algorithm.
To date, there is no known bicriteria or even subexponentialtime polylogarithmic approximation for Rooted Group SNDP when . The following is an intriguing open question:
What are the settings (i.e., ranges of or graph classes) in which Rooted Group SNDP admits a polylogarithmic approximation?
In this paper, we focus on developing algorithmic techniques to approach the above question. We design polylogarithmic algorithms for a special class of graphs – graphs with bounded treewidth – in the hope that it will shed some light towards solving the problem on a more general class of graphs, for instance, planar graphs (this is the case for the Steiner tree problem, where a subexponentialtime algorithm for planar graphs is derived via decomposition into lowtree width instances [33]).
Our main technical building block is a dynamic program (DP) that solves rooted versions of ECSNDP and VCSNDP in boundedtreewidth graphs. However, a straightforward DP computation is not applicable for Restricted Rooted Group SNDP, simply because the problem is NPhard on trees (so it is unlikely to admit a polynomialsize DPtable). Hence, we “embed” the DP table into a tree and devise a polylogarithmic approximation algorithm using randomized rounding of a suitable LPformulation. We remark that when the cost is polynomially bounded (e.g., in the Word RAM model with words of size ), polynomialtime algorithms for ECSNDP and VCSNDP follows from Courcelle’s Theorem [17, 6] (albeit, with much larger running time). However, employing the theorem as a blackbox does not allow us to design approximation algorithms for Restricted Rooted Group SNDP.
To avoid confusion between the relaxed and restricted version of Rooted Group SNDP (usually having the same name in literature), we refer to our problem as Restricted Group SNDP. (For convenience, we also omit the word ”rooted”.)
1.1 Related Work
SNDP problems on restricted graph classes have also been studied extensively. When , the problems are relatively well understood. Efficient algorithms and PTAS have been developed for many graph classes: lowtreewidth graphs [1, 18], metriccost graphs [14], Euclidean graphs [9], planar graphs [8], and graphs of bounded genus [7]. However, when , the complexity of these problems remains wide open. Borradaile et al. [7, 10] showed an algorithm for on planar graphs, but under the assumption that one can buy multiple copies of edges (which they called relaxed connectivity setting). Without allowing multiplicity, very little is known when : Czumaj et al. [19] showed a PTAS for in unweighted planar graphs, and Berger et al. [3] showed an exact algorithm running in time for the uniform demand case (i.e., for all pairs ). Thus, without the relaxed assumption, with nonuniform demands or , the complexity of SNDP problems on boundedtreewidth graphs and planar graphs is not adequately understood.
The technique of formulating an LP from a DP table has been used in literature. It is known that any (discrete) DP can be formulated as an LP, which is integral [31]. (For Stochastic DP, please see, e.g., [30, 21, 11, 20].) However, the technique of producing a tree structure out of a DP table is quite rare. Prior to this paper the technique of rounding LP via a tree structure was used in [24] to approximate the SparsestCut problem. The latter algorithm is very similar to us. However, while we embed a graph into a tree via a DP table, their algorithm works directly on the tree decomposition. We remark that our technique is based on the previous work in [12] with almost the same set of authors.
1.2 Hardness of Approximating Restricted Group SNDP
As mentioned, it is known among the experts that vertexcost variant of the Restricted Group SNDP has a simple reduction for the LabelCover problem and more generally, the Constraint Satisfaction problem (CSP). The original construction was given by Khandekar, Kortsarz and Nutov [27] for the Restricted Group SNDP on directed graphs. However, the same construction applies for the VertexWeighted Restricted Group SNDP. We are aware that this fact might not be clear for the readers. Thus, we provide the sketch of the proof in Appendix C.
We remark that the CSP hardness implies that even for , VertexWeighted Restricted Group SNDP cannot be approximated to within a factor of , for any , unless , and the approximation hardness is conjectured to be polynomial on , say for some , under the Sliding Scale Conjecture [2]. So far, we do not know of any nontrivial approximation for this problem for .
The edgecost variant has been studied in [27, 23], and a polylogarithmic approximation is known for the case [27]. For , there is no known nontrivial approximation algorithm. The relaxed variant where the disjoint paths from the root may end at different vertices in each group has also been studied in [27, 23]. Chalermsook, Grandoni and Laekhanukit proposed a bicriteria approximation algorithm for the Relaxed Restricted Group SNDP [13]; however, their technique is not applicable for the restricted version. Note that the hardness of the edgecost variant of Relaxed Restricted Group SNDP is , for any [13]. It is not hard to construct the same hardness result for Restricted Group SNDP. We believe that Restricted Group SNDP is strictly harder than the relaxed variant.
1.3 Our Results & Techniques
Our main result is the following approximation result for Restricted Group SNDP.
Theorem 1.1.
There is an approximation for Restricted Group SNDP that runs in time for some function .
The proof of this theorem relies on the technique introduced in [12]. We give an overview of this technique and highlight how this paper departs from it.
In short, this technique “bridges” the ideas of dynamic program (DP) and randomized LP rounding in two steps^{2}^{2}2One may view our result as a “treeembedding” type result. Please see [12] for more discussion along this line. Here we choose to present our result in the viewpoint of DP & LP.. Let us say that we would like to approximate optimization problem . In the first step, a “nice” DP table that captures the computation of the optimal solution is created, and there is a 1to1 correspondence between the DP solution and the solution to the problem. However, since the problem is NPhard (in our case, even hard to approximate to within some polylogarithmic factor), we could not follow the standard bottomup computation of DP solutions. The idea of the second step is to instead write an LP relaxation that captures the computation of the optimal DP solution, and then use a randomized dependent rounding to get an approximate solution instead; the randomized rounding scheme is simply the wellknown GKR rounding [22]. Roughly speaking, the size of the DP table is , while the LP relaxation has variables and constraints, so we could get an approximation in time .
The main technical hurdle that prevents us from using this technique to Restricted Group SNDP directly is that there was no systematic way to generate a “good” DP table for arbitrary connectivity demand . (The previous result was already complicated even for .) This is where we need to depart from the previous work. We devise a new concept that allows us to systematically create such a DP table for any connectivity demand . Our DP table has size for some function and , and it admits the same randomized rounding scheme in time , therefore yielding the main result.
As byproducts, we obtain new algorithms for some wellstudied variants of SNDP, whose running time depends on the treewidth of the input graph (in particular, ).
Subset connectivity problems:
Subset Connectivity is a wellstudied SNDP problem (Subset EC and Subset VC for edge and vertex connectivity, respectively). In this setting, all pairs of terminals have the same demands, i.e., for all . This is a natural generalization of Steiner tree that has received attention [14, 32, 29].
Theorem 1.2.
There are exact algorithms for Subset EC and Subset VC that run in time for some function . This result holds for vertex or edgecosts.
Rooted SNDP:
Another setting that has been studied in the context of vertex connectivity requirements is the Rooted SNDP [15, 32]. In this problem, there is a designated terminal vertex , and all positive connectivity requirements are enforced only between and other terminals, i.e. only if or . For the edge connectivity setting, Rooted SNDP captures Subset EC ^{3}^{3}3This is due to the transitivity of edgeconnectivity. Specifically, any vertices that have edgedisjoint paths connecting to the root also have edgedisjoint paths between themselves.
Theorem 1.3.
There are exact algorithms for Rooted ECSNDP and Rooted VCSNDP that run in time for some function . This result holds for costs on vertices or edges.
Further technical overview:
Let us illustrate how our approach is used to generate the DP table, amenable for randomized rounding. The following discussion assumes a certain familiarity with the notion of treewidth and DP algorithms in lowtreewidth graphs.
Given graph , let be a tree decomposition of having width , i.e. each bag corresponds to a subset . Let denote the subtree of rooted at . For each bag , let denote the subgraph induced on all bags belonging to the subtree of rooted at , i.e. . At a high level, DPs for minimization problems in lowtreewidth graphs proceed as follows. For each “bag” , there is a profile for , and we define a DP cell for each possible such profile, which stores the minimumcost of a solution (a subgraph of ) that is consistent with the profile . Then, a recursive rule is applied: Let be the left and right children of in respectively. The DP makes a choice to “buy” a subset of edges (that appear in bag ) and derives the cost by minimizing over all profiles that are “consistent” with :
where the sign represents the notion of consistency between the profiles. Different optimization problems have different profiles and consistency rules. Often, consistency rules that are designed for connectivity1 problems (such as Steiner tree) are not easily generalizable to higher connectivity problems (such as SNDP).
In this paper, we devise a new consistency rule (abbreviated by ) for checking “reachability” (or connectivity 1) in a graph, which allows for easy generalization to handle high connectivity problems.
Roughly speaking, our consistency rule solves the Steiner tree problem (connectivity1 problem). To solve a connectivity problem, we have a DP cell for each . Then the consistency check is a “direct product” test for all coordinates, i.e.,
In this way, our new concept makes it a relatively simple task to generalize a DP for connectivity1 problems to a DP for connectivityk problems (and facilitate the proof of correctness). There is a slight change in the way DPs are designed for each problem, but they follow the same principle.
Organization:
We develop our techniques over several sections, and along the way, show nontrivial applications for various SNDP problems. Section 2 provides some notation and important definitions. Section 3 presents the new viewpoint for designing DP and presents a simple showcase by deriving (known) results. Section 4 presents algorithms for ECSNDP. Lastly, Section 5 presents an approximation algorithm for group connectivity problems.
2 Preliminaries
Tree decomposition:
Let be any graph. A tree decomposition of is a tree with a collection of bags (i.e., each node of is associated with a subset of nodes of ) that satisfies the following properties:


For any edge , there is a bag such that .

For each vertex , the collection of nodes whose bags contain induces a connected subgraph of . That is, is a subtree of .
The treewidth of , denoted , is the minimum integer for which there exists a tree decomposition such that ( is the width of ).
Fix a tree decomposition with the stated properties. For each node , denote by the subtree of rooted at . We also define as the subgraph induced by ; that is, .
For each , let denote the topmost bag for which . For each , we say that an edge appears in the bag if , and only if is the topmost bag in which this happens. We denote the edges inside the bag by . For a subset of bags, , we define .
We will use the following result, which shows that a tree decomposition of of width is computable in time .
Theorem 2.1 ([5]).
There is an algorithm that, given a graph , runs in time and finds the tree decomposition such that for all .
Connection sets and operators:
Let . A connection set over is a subset of which will be used to list all pairs that are connected via a path, i.e., iff there is a path connecting to .
Let be a connection set over . The transitive closure operator, denoted by , is defined naturally such that contains all pairs for which there is a sequence and for all . Let . The projection operator “” is defined such that . See Figure 1 for an illustration.
Given two connection sets of and of , the union is a connection set over .
3 New Key Concept: Global Local Checking for DP
This section introduces the key concept devised for handling all our problems systematically.
Highlevel intuition:
Our DP will try to maintain a pair of local and global information about connectivity in the graph. Roughly speaking, a local connection set for (more precisely, for ) gives information about connectivity of the solution inside the subgraph (the subgraph induced in subtree ), while the other connection for gives information about connectivity of the global solution (i.e., the solution for the whole graph ).
For instance, if we have a tentative solution , we would like to have the information about the reachability of inside each bag, i.e., , so we could check the reachability between and simply by looking at whether . However, a DP that is executing at bag may not have this global information, and this often leads to complicated rules to handle this situation.
We observe that global information can be passed along to all cells in the DP with simple local rules so that checking whether the connectivity requirements are satisfied can be done locally inside each DP cell. In the next section, we elaborate on this more formally.
Equivalence:
One could imagine having a DP cell for all possible connection sets , which makes a decision on , the set of edges bought by the solution when executing the DP. The roles of and are to give information about local and global reachability, respectively. We are seeking a solution that is “consistent” with these profiles, where can be partitioned based on the tree as .
Given , we say that the pairs satisfy the local (resp., global) connectivity definition if, for every bag (having left and right children as and , respectively),
where the projection operator on is simplified as .
The main idea is that the local connectivity definition gives us “local” rules that enforce consistency of consecutive bags, and this would be suitable for being embedded into a DP. The global connectivity rules, however, are not easily encoded into DP, but it is easy to argue intuitively and formally about their properties. The following lemma (proof in Section 6) shows that the local and global connectivity definitions are, in fact, equivalent.
Lemma 3.1.
Let be a subset of edges and a pair of connectivity sets for every . Then, the pairs satisfy the local connectivity definition iff they satisfy the global connectivity definition.
The notions of local and global connectivity, as well as the equivalence between them can be generalized both for the edgeconnectivity version with vertexcosts as well as vertexconnectivity with vertexcosts. We defer the details of this generalization to Appendix B.
A warmup application: steiner trees.
We now show an approach that allows us to solve the Steiner Tree problem exactly in time, given a tree decomposition of width . We remark that the best known algorithm due to Cygan et al. [18] runs in time . In this problem, we are given graph with edgecosts and terminals , and the goal is to find a mincost subset that connects all the terminals. For simplicity, we denote by “root” , and the goal is to connect the root to all other terminals in .
Our DP table has a cell for every bag and every pair of connection sets for . We initialize the DP table by setting for all the leaf bags, and setting certain cells as invalid (by setting :

For every leaf bag and every pair , we set if and otherwise.

We mark the cells as invalid if .

Let be one of the terminals, and a bag. We mark a cell as invalid if but .
For all other cells, we compute the bags from their children. Let be a bag with leftchild and rightchild . Let be pairs of connection sets for , respectively, and . We say that is consistent with via (abbreviated by the notation ) if
Now, for any choice of valid DP cells and edge subsets for every (notice that a DP solution uses precisely one cell per bag ), we apply Lemma 3.1 to conclude that since the local connectivity definition is satisfied for pairs, so does the global connectivity definition. Since, for every valid DP cell such that contains a terminal , , we conclude that every terminal is connected to the root in the solution .
Conversely, given a solution , we can define , and a pair for every , using the global connectivity definition. Lemma 3.1 implies that the pairs satisfy the local connectivity definition, and therefore define valid DP cells (notice that for every terminal , connects to the root, so for every such that ). We thus establish that for every valid DP solution there is a corresponding feasible solution , and viceversa.
4 Extension to High Connectivity
This section shows how to apply our framework to problems with high connectivity requirements. We focus on edgeconnectivity and leave the case of vertexconnectivity to Appendix B.
When solving a problem in a high connectivity setting, there may be a requirement of disjoint paths. In particular, for each demand pair , there must be disjoint paths in the solution. So we could start naturally with a profile of the form:
for each bag , and enforce the local consistency conditions for each coordinate.
However, this idea does not work as a different demand pair, say , might use a path that belongs to different subgraphs as defined above. In other words, the disjoint paths for the demand pair might require a different partitioning of the solution set . Figure 2 illustrates a case in which different demand pairs use different partitions. Therefore, we need to enumerate all possible ways for the demands to “locally” partition the graph and use them to support all disjoint paths for each one of them. This requires a more careful local consistency check between the DP cells.
We consider the Rooted ECSNDP problem with edgecosts as an example to explain how to apply our framework in highconnectivity. For convenience, we add to every bag. To avoid confusion, the root of the tree will be referred explicitly as .
The organization of this section is as follows. In Section 4.1, we explain the setup of the cells of the DP table and a highlevel intuition about how the DP works. In Section 4.2 we describe the algorithm, in particular, how to compute the values of the DP table. We leave the discussion of its correctness and running time to Section 7.2.
4.1 Profiles
As in any standard dynamic programming approach based on tree decomposition, we have a profile for each bag , which tries to solve the subproblem restricted to in some way.
Let be a bag. A connection profile for is a ktuple such that . Let be the set of all connection profiles for . A profile of node is a collection of pairs of connection profiles , i.e., . A partial solution is said to be consistent with profile for if, for all ,

For each and for , there are paths connecting the respective vertices in such that and are edgedisjoint.

There is a global solution such that, for each and for , there are paths connecting the respective vertices in such that and are edgedisjoint.
In other words, a solution consistent with a profile must “implement” all connectivity requirements by and must be extensible to satisfy .
Passing down both local and global requirements in the DP table leads to a clean and simple DP algorithm. Our DP table has a cell for each bag and each profile for . This cell tentatively stores the optimal cost of a solution consistent with profile .
4.2 The DP
Valid cells:
Some table entries do not correspond to valid solutions of the problem, so we mark them as invalid and remove them from consideration (another way to think about this is that we initialize for all invalid cells), i.e., the following cells are invalid:

Any leaf that has nonempty connectivity requirements is invalid. That is, if ; otherwise, .

Any cell that cannot be extended into a feasible solution is invalid. If there is no pair such that for all , then there are fewer than edgedisjoint paths between and , and therefore the cell is invalid, so .

The bag together with profile is an invalid cell if there is a pair such that for some . In this case, we set .
Lemma 4.1.
For every , there are at most many valid cells .
DP computation:
For all other cells, we compute their values from the values of their children. Let be a bag with leftchild and rightchild . Let be their profiles respectively, and . We say that is consistent with via (abbreviated by ) if the following conditions are satisfied. For each pair , there are and , together with a partition of into such that, for every ,
Similarly, for any (resp., ) there are (resp., ) plus and some partition of , satisfying similar conditions as above.
Then the value of can be defined recursively among valid cells:
The final solution can be computed as . The correctness of this DP is deferred to Section 7.1.
5 Algorithms for Restricted Group SNDP
We now have sufficient technical tools to prove Theorem 1.1. In the first step, we turn the DP table into a tree instance of a variant of GST and, in the second step, apply randomized rounding to obtain a polylogarithmic approximation to the problem.
Tree Instance:
We start by showing how to transform the DP table into a tree , where we can solve a variant of the group Steiner tree problem. The following theorem formalizes this transformation, and we dedicate the rest of this section to proving the theorem. For convenience, we add a dummy bag with as the parent of the root bag.
Theorem 5.1.
Given a graph rooted at with treewidth and groups , there is a tree with groups and a set of accepted solutions such that: (i) the size of is ; (ii) for every , there is (and viceversa) such that and, for every , connects to iff connects to .
For each cell of the DP table introduced in Section 4.2, we create a node in . Namely, we create a vertex for every bag and . The root of the tree is (this is the only connection profile for ). For a bag with children , , we add connecting nodes connected to the nodes , , , for every , if . If there is only one child, the connecting node has degree , and we consider that for the purpose of describing the algorithm. An edge from to is labeled with the set of edges and is assigned cost . All other edges in the instance have cost .
Notice that, at this point, is not a tree, but we can turn it into one by making copies of the nodes as required. Specifically, we process the tree in a bottomup fashion: for each node , we make the same number of copies of and its descendants as there are incoming edges of such that each edge is incident to a different copy. In this manner, all the copies of are now the roots of subtrees, which are disjoint.
For convenience, we denote by (resp., ) any copy of the original node; when we need to distinguish copies, we denote by the set of all copies of a node .
The final step in our construction is to prune the tree by removing nodes that cannot be reached or that represent choices that cannot be part of a feasible solution. To do that, it is sufficient to apply the following rules to exhaustion: (i) remove if it is not connected to the root; (ii) remove a connecting node if one of its children was removed; (iii) remove if it is a leaf node but (i.e. for some ).
We can now restate the goal of the problem in terms of : we want to find nodes and edge sets for every bag , such that for all nonleaf bags with children , . Further, for every group , there must be a vertex and a partition of into sets, such that each contains a path from to .
The set of nodes with the respective connecting nodes (for all nonleaf bags ) induces a tree in . We say that such a tree is valid if every node has exactly one child in the graph (or none if is a leaf), and every connecting node in has fulldegree, i.e., all its neighbors are in the solution as well.
For every group , we define as follows: for every and every , every element of is in if there is such that for all .
The size of the instance follows by considering its height and maximum degree: the maximum degree of is by Lemma 4.1, and there is a tree decomposition of height by Lemma 2.2, which implies that . We conclude that .
The correctness of the reduction follows from the correctness of the DP for Rooted ECSNDP, and its proof is left to Section 7.1.
Algorithm:
We now show how to obtain a valid tree , given . Let be the mincost valid tree in that connects all the groups . Chalermsook et al. [12] showed that it is possible to find a valid tree with expected cost
, but whose probability of covering a group is just
.Using this result, we can obtain valid trees , …, , where . We can then obtain solutions that connect the same groups and have the same cost as , for all , and finally output the solution . Since the expected cost of each is , the expected cost of is .
By sampling independent valid trees, for large enough , we ensure that all the groups are covered with high probability (by union bound). We conclude that the algorithm outputs a randomized approximation to the problem, with high probability.
6 Details of the Global Local Checking for DP
In this section, we will prove a generalized version of Lemma 3.1, that works for edgeconnectivity and vertexconnectivity, both with edge and vertex costs. In vertexconnectivity problems, we are interested in finding internally disjoint paths. In order to handle this setting, we introduce a modified version of transitive closure.
For a set of vertices and a set of edges , we denote by the set of all pairs such that there is a path in the graph , that is, a path whose internal vertices are in , and whose edges are in . Formally,
We then keep track, for every bag, of which vertices are allowed to be used in the solution, that is, we use triples , instead of the previously used pairs .
Let for every , , for every , , and a triple for every . For the purposes of this section, we introduce the following definitions for local and global connectivity.
We say that the triples satisfy the local (resp. global) connectivity definition if, for every bag ,
We then prove the following lemma, proving that the given local and global connectivity definitions are equivalent.
Lemma 6.1.
Let be a subset of vertices, a subset of edges and a triple of profiles for every .
Then, the triples satisfy the local connectivity definition iff they satisfy the global connectivity definition.
Before proving the lemma, we show how Lemma 3.1 follows. We will prove that, if we fix and , the definitions of Lemmas 3.1 and 6.1 are equivalent.
For this, it is sufficient to see that , and that the common vertices in , , and are all in , thus
Similarly, since and only intersect inside ,
We conclude that when , and , the proof follows.
The following technical lemma will be useful when proving Lemma 6.1.
Lemma 6.2 (Path Lemma).
Let be any graph and be a tree decomposition of . Let be a bag and be a path of length at least whose endpoints are the only vertices of in , that is, .
Then there is a connected (subtree) component in such that, for any edge , has a bag that contains , i.e., every edge for some bag .
Proof.
We provide a simple proof by contradiction. Assume that there are two consecutive edges, that are in different connected components of (otherwise, all edges must be in the same component). Since the set of bags containing must be connected in but is not connected in , , we reach a contradiction. ∎
Proof of Lemma 6.1.
We remark that the function shares some properties with the usual definition of transitive closure, which are used throughout the proof:
Observation 6.3.
The function satisfies the following properties:


if ,
Comments
There are no comments yet.