Robustness in Highly Dynamic Networks
We investigate a special case of hereditary property that we refer to as robustness. A property is robust in a given graph if it is inherited by all connected spanning subgraphs of this graph. We motivate this definition in different contexts, showing that it plays a central role in highly dynamic networks, although the problem is defined in terms of classical (static) graph theory. In this paper, we focus on the robustness of maximal independent sets (MIS). Following the above definition, a MIS is said to be robust (RMIS) if it remains a valid MIS in all connected spanning subgraphs of the original graph. We characterize the class of graphs in which all possible MISs are robust. We show that, in these particular graphs, the problem of finding a robust MIS is local; that is, we present an RMIS algorithm using only a sublogarithmic number of rounds (in the number of nodes ) in the model. On the negative side, we show that, in general graphs, the problem is not local. Precisely, we prove a lower bound on the number of rounds required for the nodes to decide consistently in some graphs. This result implies a separation between the RMIS problem and the MIS problem in general graphs. It also implies that any strategy in this case is asymptotically (in order) as bad as collecting all the network information at one node and solving the problem in a centralized manner. Motivated by this observation, we present a centralized algorithm that computes a robust MIS in a given graph, if one exists, and rejects otherwise. Significantly, this algorithm requires only a polynomial amount of local computation time, despite the fact that exponentially many MISs and exponentially many connected spanning subgraphs may exist.
Highly dynamic networks are made of dynamic (often mobile) entities such as vehicles, drones, or robots. It is generally assumed, in these networks, that the set of entities (nodes) is constant, while the set of communication links varies over time. Many classical assumptions do not hold in these networks. For example, the topology may be disconnected at any instant. It may also happen that an edge present at some time never appears again in the future. In fact, of all the edges that appear at least once, one can distinguish between two essential sets: the set of recurrent edges, which always reappear in the future (or remain present), and the set of non recurrent edges which eventually disappear in the future. The static graph containing the union of both edge sets is called the footprint of the network , and its restriction to the recurrent edges is the eventual footprint of the network .
It is not clear, at first, what assumptions seem reasonable in a highly dynamic network. Special cases have been considered recently, such as always-connected dynamic networks , -interval connected networks , or networks the edges of which correspond to pairwise interactions obeying a uniform random scheduler (see e.g. [2, 17]). Arguably, one of the weakest possible assumption is that any pair of nodes be able to communicate infinitely often through temporal paths (or journeys). Interestingly enough, this property was identified more than three decades ago by Awerbuch and Even  and remained essentially ignored afterwards. The corresponding class of dynamic networks (Class 5 in —here referred to as for consistency with various notations [8, 12, 1]) is however one of the most general and it actually includes the three aforementioned cases.
Dubois et al.  observe that class is actually the set of dynamic networks whose eventual footprint is connected. In other words, it is more than reasonable to assume that some of the edges are recurrent and their union does form a connected spanning subgraph. Solving classical problems such as symmetry-breaking tasks relative to this particular set thus makes sense, as the nodes can rely forever on the corresponding solution, even though intermittently [6, 8]. Unfortunately, it is impossible for a node to distinguish between the set of recurrent edges and the set of non recurrent edges. So, the best the nodes can do is to compute a solution relative to the footprint, hoping that this solution still makes sense in the eventual footprint, whatever it is. (Whether, and how the nodes can learn the footprint itself is discussed later on.)
This context suggests a particular form of heredity which we call robustness. In classical terms, robustness can be formulated as the fact that a given property must be inherited by all the connected spanning subgraphs of the original graph. Significantly, this concept admits several possible interpretations, including the dynamic interpretation developed here. A more conventional, almost direct interpretation is that some edges in a classical (static) network are subject to permanent failure at some point, and the network is to be operated so long as it remains connected. While this interpretation is more intuitive and familiar, we insist on the fact that the dynamic interpretation of robustness is what makes its study compelling, for this notion arises naturally in class , which is one of the most general class of dynamic networks imaginable. The reader may adopt either interpretation while going through the paper, keeping in mind that our results apply to both contexts and are therefore quite general.
Contributions. We investigate the concept of robustness of a property, with a focus on the maximal independent set (MIS) problem, which consists of selecting a subset of nodes none of which are neighbors (independence) and such that no further node can be added to it (maximality). As it turns out, a robust MIS may or may not exist, and if it exists, it may or may not be computable locally depending on the considered graph (resp. footprint).
For example, if the graph is a triangle (see Figure (a)a), then only one MIS exists up to isomorphism, consisting of a single node. However, this set is no longer maximal in one of the possible connected spanning subgraphs (e.g. after removing an adjacent edge to the selected node). Therefore, the triangle graph admits no robust MIS. Some graphs do admit a robust MIS, but not all of the MISs are robust. Figures (b)b and (c)c show two MISs in the bull graph, only one of which is robust. Finally, some graphs like the square graph (Figure (d)d) are such that all MISs are robust. Although the last two examples seem to suggest that robust MISs are related to maximum MISs, being maximum is actually neither a necessary nor a sufficient condition.
In this paper, we characterize the class of graphs such that all MISs are robust, denoted . We prove that consists exactly of the union of complete bipartite graphs and a new class of graphs called sputniks, which contains among others all the trees (for which any property is trivially robust). While the sufficient side is easy to establish, proving that these graphs are the only ones is more difficult. Interestingly, while the best known algorithms for deterministic distributed MIS in general graphs are superlogarithmic in the number of nodes , namely they take rounds  (better randomized algorithms are known ), graphs in turn out to be specific enough to find an MIS (robust by definition) by using only information available within a sublogarithmic distance. We present an algorithm that first settles specific subsets of the networks using information available within constant distance, the residual instance being a disjoint union of trees. The residual instance can then be given to state-of-the-art algorithms like Barenboim and Elkin’s for graphs of bounded arboricity , which is known to use only information within distance . An added benefit of this reduction is that any further progress on the MIS problem on trees will automatically transpose to robust MISs in . (Note that we deliberately do not use the terms “rounds” or “time”, due to the non equivalence of locality and time in the context of a footprint.)
Next, we turn our attention to general graphs and ask whether a robust MIS can be found (if one exists) using only local information. We answer negatively, proving an lower bound on the locality of the problem. This result implies a separation between the MIS problem and the robust MIS problem in general graphs, since the former is feasible within hops . It also implies that no strategy is essentially better than collecting the network at a single node and subsequently solving the problem in an offline manner. Motivated by this observation, we consider the offline problem of finding a robust MIS in a given graph if one exists (and rejecting otherwise). The trivial strategy amounts to enumerating all MISs until a robust one is found, however there may be exponentially many MISs in general graphs (Moon and Moser , see also [10, 11] for an extension to the case of connected graphs). We present a polynomial time algorithm for computing a robust MIS in any given graph (if one exists). Our algorithm relies on a particular decomposition of the graph into a tree of biconnected components (-tree), along which constraints are propagated about the MIS status of special nodes in between the components. The inner constraints of non trivial components are solved by reduction to the 2-SAT problem (which is tractable). As a by-product, the set of instances for which a robust MIS is found characterizes the existential analogue of , that is the class of all graphs that admit a robust MIS. (Whether a closer characterization exists is left as an open question.)
Further discussion on the dynamic interpretation. As pointed out, in a dynamic network there is no way to distinguish between recurrent and non recurrent edges, therefore the nodes cannot learn the eventual footprint  (this observation is the very basis of the notion of robustness). Now, what about the union of both types of edges, that is, the footprint itself? Clearly, the footprint can never be decided in a definitive sense by the nodes, since some edges may appear arbitrary late for the first time. However, it is also clear that every edge of the footprint will eventually appear; thus, over time the nodes can learn the footprint in a stabilized way, by updating their representation as new edges are detected. It is therefore possible to update some structure or property that eventually relates to the correct footprint. (Alternatively, one may assume simply that prior information about the footprint is given to the nodes, or that an oracle informs the nodes once every edge of the footprint has appeared.) Again, the reader is free to ignore the dynamic interpretation if the static one makes for a sufficient motivation.
Outline. Section 2 presents the main definitions and concepts. Then, we characterize in Section 3 the class and present a dedicated MIS algorithm that requires only information up to a sublogarithmic number of hops. Section 4 establishes the non-locality of the problem in general and describes a tractable algorithm that computes a robust MIS in a given graph if one exists. Section 5 concludes with some remarks.
2 Main concepts and definitions
Many of the concepts presented in the introduction, including that of temporal paths, footprint, or classes of dynamic networks are not defined here. The authors believe that the informal descriptions given in introduction are sufficient to understand the dynamic interpretation of the results. (If that is not the case, the reader is referred to  for thorough definitions using the time-varying graph formalism.) Our results themselves are formulated using standard concepts of graph theory, making them independent from both interpretations.
2.1 Basic definitions
Let be an undirected graph, with the set of nodes (vertices) and the set of bidirectional communication links (edges). We denote by the number of nodes in the graph, and by the diameter of the graph, that is, the length of the longest shortest path in over all possible pairs of nodes. We denote by the neighborhood of a vertex , which is the set of vertices . The degree of a vertex is . A vertex is pendant if it has degree . A cut vertex (or articulation point) is a vertex whose removal disconnects the graph. A cut edge (or bridge) is an edge whose removal disconnects the graph. We say that an edge is removable if it is not a cut edge. A spanning connected subgraph of a graph is a graph such that , , and is connected. In the most general variant, we define robustness as follows.
Definition 1 (Robustness).
A property is said to be robust in if and only if it is satisfied in every connected spanning subgraph of (including itself).
In other words, a robust property holds even after an arbitrary number of edges are removed without disconnecting the graph. Robustness is a special case of hereditary property, and more precisely a special case of decreasing monotone property (see for instance ). In this paper, we focus on the maximal independent set (MIS) problem. An MIS is a set of nodes such that no two nodes in the set are neighbors and the set is maximal for the inclusion relation. Following Definition 1, a robust MIS in a graph (RMIS, for short) is an MIS that remains maximal and independent in every connected spanning subgraph of . Observe that independence is stable under the removal of edges; therefore, it is sufficient that the MIS be maximal in all these subgraphs in order to be an RMIS. We define two classes of graphs related to the robustness of MISs.
Definition 2 ().
This class is the set of all graphs in which all MISs are robust.
Definition 3 ().
This class is the set of all graphs that admit at least one robust MIS.
We define the distributed problem of computing an RMIS in a given graph as follows.
Definition 4 (RobustMIS problem).
Given a graph and an algorithm executed at every node of , solves RobustMIS on iff every node eventually terminates by outputting IN or OUT, and the set of nodes outputting IN forms an RMIS on . Algorithm solves RobustMIS in a class of graphs iff for all , solves RobustMIS on .
Finally, let us define two classes of graphs that turn out to be closely related to RMISs, namely complete bipartite graphs and sputnik graphs. The latter is introduced here for the first time.
Definition 5 (Complete bipartite graph).
A complete bipartite graph is a graph such that and . In words, the vertices can be partitioned into two sets and such that every vertex in shares an edge with every vertex in (completeness), and these are the only edges (bipartiteness).
Definition 6 (Sputnik).
A graph is a sputnik iff every vertex belonging to a cycle also has a pendant neighbor. (An example of sputnik is shown in Figure 2.)
2.2 Computational model
Based on the chosen interpretation of our results, the base graph in the above definitions refers either to the footprint of a dynamic network, or to the network itself. In the dynamic case, the actual timing of the edges is arbitrary, so the classical equivalence between time and locality in synchronous network does not hold. Nonetheless, we rely on the model [16, 19] to describe the algorithms. To avoid confusion between locality and time in the dynamic case, we always state the complexities in terms of locality, saying that an algorithm (or problem) is -local if it can be solved in rounds in the model. (Other terminologies include saying that such problems are in .) For completeness, let us recall the main features of the model. In this model, the nodes operate in synchronous discrete rounds and they wake up simultaneously. In each round, a node can exchange messages of arbitrary size with its neighbors and perform some local (typically unrestricted) computation. The complexity of an algorithm over a class of graphs is the maximum number of rounds, taken over all graphs of this class, performed until all nodes have terminated. In the dynamic interpretation of our results, the algorithms are seen as being restarted every time the local knowledge of the footprint changes.
3 Characterization of and locality of RobustMIS
In this section, we show that , the class of graphs in which all MISs are robust, corresponds exactly to the union of complete bipartite graphs and sputnik graphs. Then we present an algorithm that solves RobustMIS in using information available only within a sublogarithmic number of hops in .
3.1 Characterization of
We first show that all MISs are robust in complete bipartite graphs and in sputnik graphs. Due to space limitation, the proofs of the two following lemmas are postponed to Appendix A. They follow easily from the very definition of RMIS and of these classes of graphs.
All MISs are robust in complete bipartite graphs.
All MISs are robust in sputnik graphs.
We now prove the stronger result that if a graph is such that all possible MISs are robust, then it must be either a bipartite complete graph or a sputnik.
If is not a sputnik, and yet every MIS in is robust, then is bipartite complete.
If is not a sputnik, then some node in a cycle has no pendant neighbor. In general, may be an articulation point, and so the graph may result in several components. Let be the resulting components with vertex back in each of them. In particular, let be the one that contains and observe that contains at least vertices (cycle). The other components, if they exist, all contain at least two vertices other than (otherwise would have a pendant neighbor).
Claim 1: If all MISs in are robust, then all neighbors of in have the same neighborhood.
We prove this claim by contradiction. Let two neighbors of be such that . We will show that at least one MIS is not robust. Without loss of generality, assume that some vertex belongs to . Then we can build an MIS that contains both and (as a special case, may be the same vertex as , but this is not a problem). For each of the components , choose an edge and add another neighbor of to the MIS (such a neighbor exists, as we have already seen). One can see that , and all can no longer enter the MIS because they all have neighbors in it. Now, choose the remaining elements of the MIS arbitrarily. We will show that the resulting MIS is not robust, by consider the removal of edges as follows. In all components , remove all edges incident to except ; and in , remove all edges incident to except . The resulting graph remains connected, by definition, since each of the is connected. And yet, no longer has a neighbor in the MIS, which contradicts robustness.
Now, Claim 1 implies that none of ’s neighbors in has a pendant neighbor (since their neighborhoods are the same). As a result, the arguments that applied to because of its absence of pendant neighbors, apply in turn to ’s neighbors in . In particular, it means that if some node is neighbor to in , then all neighbors of (including ) must have the same neighborhood. Therefore, cannot be an articulation point and we are left with the single component , in which all neighbors of have the same neighbors and these neighbors in turn have the same neighbors, which implies that the graph is complete bipartite. ∎
All MISs are robust in a graph if and only if is complete bipartite or sputnik.
3.2 RobustMIS is locally solvable in
We now prove that computing deterministically an RMIS in class can be done locally, by presenting a distributed algorithm that computes a (regular) MIS using only information available within -hops a sublogarithmic number of hops in . By definition of the class, this MIS is robust. Informally, the algorithm proceeds as follows (due to space limitations, the pseudo-code and the formal proof of the algorithm are moved to Appendix A). Class consists of exactly the union of bipartite complete graphs and sputniks (Theorem 1). First, the nodes decide if the graph is complete bipartite by looking within a constant number of hops (three). If so, membership to the MIS is decided according to some convention (e.g. all nodes in the same part as the smallest identifier are in the MIS). Otherwise, the graph must be a sputnik and every node decides (without more information) which of the following three cases it falls into: 1) it is a pendant node (set in Figure 2), 2) it is not a pendant node but has at least one pendant neighbor (set ), or 3) none of the two cases apply (set ). In the first case, it enters the MIS, while in the second it decides not to. We prove that the set of nodes falling into the third case does form a disjoint union of trees, each of which can consequently be solved by state-of-the-art algorithms. In particular, Barenboim and Elkin  present a -local algorithm that solves MIS in graphs of bounded arboricity (and a fortiori trees). On the negative side, we show (using standard arguments) that Linial’s lower bound for -coloring  in cycles extends to RobustMIS in class , leading to the following theorem.
RobustMIS is -local in class .
4 Nonlocality of RobustMIS in general graphs and global resolution
In this section, we prove that the problem of computing deterministically an RMIS in general graphs, if one exists, is not local. Precisely, we first observe that deciding whether an RMIS exists is not a local problem; then, we prove a lower bound on the distance at which it might be necessary to look to solve the problem if an RMIS exists, where is the diameter of the network. Motivated by this result, we present an offline algorithm that compute an RMIS, in polynomial time, if one exists. It can be used in a strategy where all the information about the network is collected at one node (or several, the algorithm being deterministic).
4.1 RobustMIS is non local in general graphs
Let us first observe that the problem of deciding whether an RMIS exists is not local. Consider two graphs and which respectively consist of a -long path and to a lollipop graph (i.e. a graph joining a -long path to a clique of size ). Then, clearly, a node at one extremity of and the (unique) pendant node of cannot distinguish their neighborhood (even with identifiers, which could be exactly the same in this neighborhood) whereas admits an RMIS and does not. We go further and prove that, even if some RMISs do exist, then finding one is non local. To prove this result, we exhibit an infinite family of graphs , each of which has diameter linear in (and ). We first show through Lemmas 4 and 5 that every admits only two RMISs and which are complements of each other; that is . Intuitively, these MISs are such that two nodes at distance must take opposite decisions, although they have the same view up to distance . (The real proof is more complex and involves showing that identifiers do not help either.) As a result, the nodes may have to collect information up to distance in order to decide consistently.
Let be an infinite famility of graphs defined as follows. Graph is such that and induces a cycle ------ as shown in Figure 3. Then is obtained from as follows: and .
For any , define as the set of nodes and . Observe that (written ). Set is illustrated in Figure 3.
For any , and are RMISs in .
We prove this for . The same holds symmetrically for . First, observe that is a valid MIS: no two of its nodes are neighbors by construction (independence) and all nodes in have neighbors in (maximality). Now, to obtain a connected spanning subgraph of , one can remove from at most one edge from each simple cycle of . Since any node of has a number of neighbors in strictly greater than the number of simple cycles it belongs to, is robust. ∎
For any , and are the only two RMISs in , implying that nodes and must take opposite decisions in all RMISs.
We say that an edge is critical with respect to some MIS in if is removable (i.e. not a cut edge) and is no longer maximal in . The existence of a critical edge implies that the considered MIS is not robust. Let us now consider an RMIS in . We prove several claims on .
Claim 1: If , then and .
If , then (independence). It also holds that , otherwise the edge is critical (robustness). It follows that (independence) and (maximality).
Claim 2: If , then and . (symmetric to Claim 1)
Claim 3: If , then and for all .
By contradiction, if for some , then (independence). Let be smallest possible, then edges and are critical w.r.t. (recall that, if , by construction and by Claim 1), which contradicts robustness. Therefore, . The maximality of allows us to conclude.
Claim 4: If , then and for all . (symmetric to Claim 3)
Claim 5: If , then and for all .
By contradiction, if for some , then (independence). Let be smallest possible (recall that, if , by construction and by Claim 1). Let be if and be otherwise. The edges and are then critical, which contradicts robustness. Therefore, . The independence of allows us to conclude.
Claim 6: If , then and for all . (symmetric to Claim 5)
Claims 1 to 6 imply that if and otherwise. ∎
Finally, we relate these results to the locality of the RobustMIS problem.
RobustMIS requires the nodes to use information up to distance in .
The proof would be straightforward in an anonymous network, due to the fact that and have indistinguishable structural neighborhoods (a.k.a. views ) up to distance , and yet, they must take different decisions (Lemma 5). Unique identifiers make the argument more complicated, since and do have unique labeled views (i.e. views taking into account identifiers) even at distance .
Let us call and the extremities of the network. Observe that the distance between both extremities is larger than . Let , , and be three possible labeling functions that assign unique identifiers to the neighborhood of an extremity up to distance (say) and such that the three labelings have no identifier in common. Let be the labeled graph whose structure is isomorphic to , in which the neighborhood of is labeled according to and the neighborhood of is labeled according to ; the rest of the nodes are labeled arbitrarily. Let be defined similarly, but using instead of in the neighborhood of . Finally, let be defined similarly, but using in the neighborhood of and in the neighborhood of . Now, if and use only information up to distance , then they must take identical decisions in at least one of the three labeled graphs, contradicting Lemma 5. ∎
4.2 A global algorithm to compute a robust MIS (if one exists)
We now describe an algorithm that tests constructively whether an RMIS exists in a graph . Our algorithm relies on the construction of an auxiliary tree called -tree, which represents a particular decomposition of the graph based on biconnected components (it is neither a block-cut tree, nor a bridge tree, but a mix of these two types of decomposition). Roughly speaking, our algorithm works by propagating constraints about the MIS along the -tree. Each non-trivial component is solved on the way up by means of a reduction of its constraints to 2-SAT (which is polynomial-time solvable).
In the following, we describe how the -tree is built over . It is followed by an informal presentation of the algorithm—due to the lack of space, the formal algorithm has been moved to Appendix B and its proof is presented in Appendix C.
Decomposition of . In the context of this section, we call biconnected component (or simply component) in a maximal subgraph such that the removal of any node in does not disconnect (i.e. is -vertex-connected). By abuse of notation, we write if is a vertex of the subgraph . We consider here a mix of the so-called block-cut tree and bridge tree and refer to it as the -tree. Let be the set of biconnected components of (see Figure 4 for an illustration).
Two adjacent components either share a common articulation point or they are linked by a bridge. For instance, node in Figure 4 is common to components and , and edges and are bridges between and , and and respectively. Let be the set of all articulation points (whether or not they are shared) and the set of bridges. Let be the set of all pendant vertices, which form singleton components—in Figure 4, . Finally, let be the set of components that contain three or more vertices—. Remark that if is empty, then is acyclic.
The decomposition (or -tree) of , is the graph such that and is defined by the two following rules: , , if and only if ; and , and . Figure 4 (right side) shows the -tree corresponding to the graph of the left side.
Algorithm. The algorithm works on , the -tree made over the four sets , , , and with respect to . If the set is empty, it means that is acyclic. In that case, trivially admits an RMIS, which is returned by the algorithm. Otherwise (), a component vertex is arbitrarily selected to be the root of , denoted by . Then, the classical concepts in oriented trees, such as children, parent, descendant, subtree, or leaf apply to the vertices of . For ease of reading, we abuse the term “admit” by saying that a subtree of “admits an RMIS” if the subgraph of corresponding to admits an RMIS.
At the higher level, the algorithm proceeds within two phases. Based on , the first one is called the labeling phase. Initiated from the leaves of the tree, it evaluates whether the subgraph of corresponding to the current subtree admits a robust MIS or not and labels each subtree according to that. If it does admit an RMIS, it may impose some constraints about the membership of the higher nodes. For instance, a robust MIS of the subtree may exist only if the articulation point leading up to the parent belongs to it. Then, the goal of the labeling phase consists of propagating (and memorizing within labels) such constraints up through subtle interactions among the various types of vertices (namely, pendant nodes, articulation point, bridge, or component) leading up to the root. Besides, the inner topological configuration of a single component may also impose non-trivial constraints for the existence of a robust MIS. Intuitively, it must have properties that relate to (but are slightly more complex than) bipartiteness. The second (short) phase of the algorithm is called the deciding phase. It simply consists of deciding whether the graph admits a robust MIS or not considering the label of the root of the -tree.
Labeling Phase. As already mentioned, a given subtree of may or may not admit an RMIS. Intuitively, the global decision depends on topological contraints, established over . Obviously, those constraints influence the possible topological organization of a global RMIS toward the parent of . So, this mecanism involves in a crucial way the unique such that through which is connected to the remainder of . In the following is called the attachment point of . In other words and more conveniently, the attachment point of the root of is either itself if or the parent of if . For instance, in Figure 4, assuming that is the component vertex M, then, is the attachment point of itself (), is the one of both and , while is the attachment point of (), (), and itself (.
Constraint transmission takes place from the leaves to the root by tagging each vertices with the following labels: admits an RMIS that includes , the attachment point of ); for Possibly Out (meaning that admits an RMIS that does not include ); for Possibly External (meaning that is not tagged , and it admits an RMIS that does not include assuming that another node , external to belongs to the RMIS); and for Negative (meaning that none of the three other tags is applicable to ). An extra label, is used at the root (see below). Note that the algorithm associates to each label a set of vertices that is used to store a robust MIS of satisfying the constraint of the label. Also, remark that and are mutually exclusive. Furthermore, a vertex can be tagged with more than a single tag, namely either and (together), or and (together).for Possibly In (meaning that
The analysis consists of recursively tagging each vertex from the leaves to the root. Let us first consider as a leaf. There are two cases: either or . In the former case, is tagged with both and . (Indeed, being a pendant node, can or cannot be in the RMIS depending or its unique neighbor.) For instance, in Figure 4, assuming that , the vertices , , and are tagged and . If , then the algorithm checks whether must be tagged , , , or . For instance, in the same example, is tagged and . Indeed, is a square (sub)graph (refer to Figure 4) and its attachment point is . Clearly, it admits two possible RMISs: either or . In former case, does not belong to the RMIS (implying the label of type ); in the latter, belongs to the RMIS (implying the label of type ). The actual finding is solved through reduction to the 2-SAT problem described below.
From now on, consider that is an internal vertex (i.e. ). Provided that none of its descendants is tagged , an internal vertex is analyzed according of its type (whenever a vertex has two tags, each corresponding rule is applied) as follows.
Consider first the case where . If its (unique) descendant is tagged , then is tagged ; if is tagged , then is tagged ; if is tagged , then is tagged , and if possible ( is not already tagged ), also . In the example (Figure 4), the vertices , , and are all tagged and .
When , let be the set of descendant vertices of . If every vertex is tagged , then is also tagged ; if every vertex is tagged , then is also tagged ; if every vertex is tagged either or and there exists tagged , then is tagged . For instance, vertices , , and are all tagged and .
If , then, as for the leaves, is analysed using the 2-SAT reduction described below. However, by contrast with a leaf vertex, the analysis introduces extra clauses to the 2-SAT expression, according to the labels of its descendants.
If (), then the algorithm operates the last 2-SAT reduction that checks the existence of an RMIS, again accoring to the labels of its descendants. is then tagged either with ( admits no RMIS) or with ( admits at least one RMIS).
Testing a component vertex. The finding process is mainly based on the resolution of a 2-SAT expression. Let us first consider an internal component—leaf and root components are special cases that are addressed later. The procedure first consider that is equal to to which edges linking vertices both tagged are removed. Doing so, may be split into several components. If is not bipartite, then the component is tagged with . Otherwise, for each maximal connected component , one part of the bipartition is arbitrarily chosen in which each vertex () is labelled with a label equal to . The vertices of the other part are labelled . All those labels form a 2-SAT expression to which the tags coming up from the subtrees are included. For instance, a node that is tagged forces the label of the corresponding vertex to true. Also, the edge that was removed from to also forces the labels corresponding to and to be mutually exclusive (), meaning that at most one of the two can be included into the RMIS, but not both.
Since a vertex of can be tagged with one or two tags, the satisfiability of the 2-SAT expression is evaluated assuming first that the attachment point of belongs to the RMIS (Tag , ). Next, it is evaluated assuming that the attachment point of does not belong to the RMIS (Tag , ). If could not be tagged (i.e. the expression could not be satisfied assuming ), then it can still be tagged . This is done by temporarily adding an aerial at the attachment point of (i.e. a virtual extra vertex with the corresponding edge ) and repeating the whole above process with .
Note this process is also performed at the leaves and at the root (). However, in both cases, the process is simpler. Indeed, since the leaves have no descendant, it is sufficient to check whether is bipartite or not. For the root (that has no attachment point), it is sufficient to check whether the 2-SAT expression is satisfied or not.
Deciding phase. This phase simply consists in testing the label of (attributed in the labeling phase). If is labeled with , the algorithm rejects. Otherwise ( is labeled with ), the algorithm returns the set associated to the label of that is a robust MIS of thanks to the work done in the labeling phase.
This paper is dedicated to showing the actual impact of robustness in highly dynamic distributed systems. A property is robust if and only if it is satisfied in every connected spanning subgraphs of a given graph. Focusing on the minimal independent set (MIS) problem, we proved the existence of a significant complexity gap between graphs where all MIS are robust (building a robust MIS is then a local problem) and graphs where some MIS are robust (building a robust MIS is then a global problem).
We are convinced that robustness is a key property of highly dynamic systems to achieving stable structures in such unstable environments. The complete characterization of the class is left open, as well as the study of similar symmetry breaking tasks.
-  Eleni C Akrida, Leszek Gasieniec, George B Mertzios, and Paul G Spirakis. On temporally connected graphs of small cost. In International Workshop on Approximation and Online Algorithms (WAOA), pages 84–96. Springer, 2015.
-  Dana Angluin, James Aspnes, Zoë Diamadi, Michael J. Fischer, and René Peralta. Computation in networks of passively mobile finite-state sensors. Distributed Computing, 18(4):235–253, 2006.
-  Baruch Awerbuch and Shimon Even. Efficient and reliable broadcast is achievable in an eventually connected network. In Proceedings of the third annual ACM symposium on Principles of distributed computing (PODC), pages 278–281. ACM, 1984.
-  Leonid Barenboim and Michael Elkin. Sublogarithmic distributed MIS algorithm for sparse graphs using nash-williams decomposition. Distributed Computing, 22(5-6):363–379, 2010.
-  Nicolas Braud Santoni, Swan Dubois, Mohamed Hamza Kaaouachi, and Franck Petit. The next 700 impossibility results in time-varying graphs. International Journal of Networking and Computing, 6(1):27–41, 2016.
-  Arnaud Casteigts and Paola Flocchini. Deterministic algorithms in dynamic networks: Problems, analysis, and algorithmic tools. In tech. report commissioned by Defense Research and Development Canada (DRDC), 2013.
-  Arnaud Casteigts, Paola Flocchini, Walter Quattrociocchi, and Nicola Santoro. Time-varying graphs and dynamic networks. IJPEDS, 27(5):387–408, 2012.
-  Swan Dubois, Mohamed-Hamza Kaaouachi, and Franck Petit. Enabling minimal dominating set in highly dynamic distributed systems. In 17th International Symposium on Stabilization, Safety, and Security of Distributed Systems (SSS), pages 51–66, 2015.
-  Pierre Fraigniaud, Amos Korman, and David Peleg. Local distributed decision. In Foundations of Computer Science (FOCS), 2011 IEEE 52nd Annual Symposium on, pages 708–717. IEEE, 2011.
-  Zoltán Füredi. The number of maximal independent sets in connected graphs. Journal of Graph Theory, 11(4):463–470, 1987.
-  Jerrold R Griggs, Charles M Grinstead, and David R Guichard. The number of maximal independent sets in a connected graph. Discrete Mathematics, 68(2-3):211–220, 1988.
-  C. Gómez-Calzado, A. Casteigts, M. Larrea, and A. Lafuente. A connectivity model for agreement in dynamic systems. In 21st Int. Conference on Parallel Processing (EUROPAR), volume 9233 of Lecture Notes in Computer Science, pages 333–345, Vienna, Austria, 2015.
-  Valerie King. Lower bounds on the complexity of graph properties. In Proceedings of the twentieth annual ACM symposium on Theory of computing (STOC), pages 468–476. ACM, 1988.
-  Fabian Kuhn, Nancy A. Lynch, and Rotem Oshman. Distributed computation in dynamic networks. In Proc. of the 42nd ACM Symposium on Theory of Computing (STOC), pages 513–522, 2010.
-  Christoph Lenzen and Roger Wattenhofer. MIS on trees. In Proceedings of the 30th symposium on Principles of distributed computing (PODC), pages 41–48. ACM, 2011.
-  Nathan Linial. Locality in distributed graph algorithms. SIAM J. Comput., 21(1):193–201, 1992.
-  Othon Michail, Ioannis Chatzigiannakis, and Paul G Spirakis. New models for population protocols. Synthesis Lectures on Distributed Computing Theory, 2(1):1–156, 2011.
-  John W Moon and Leo Moser. On cliques in graphs. Israel journal of Mathematics, 3(1):23–28, 1965.
-  Moni Naor and Larry J. Stockmeyer. What can be computed locally? SIAM J. Comput., 24(6):1259–1277, 1995.
-  Regina O’Dell and Roger Wattenhofer. Information dissemination in highly dynamic graphs. In Joint Workshop on Foundations of Mobile Computing (DIALM-POMC), pages 104–110, 2005.
-  Alessandro Panconesi and Aravind Srinivasan. On the complexity of distributed network decomposition. Journal of Algorithms, 20(2):356–374, 1996.
-  Masafumi Yamashita and Tsunehiko Kameda. Computing on anonymous networks. i. characterizing the solvable cases. IEEE Transactions on parallel and distributed systems, 7(1):69–89, 1996.
Appendix A Missing proofs
Proof of Lemma 1
(All MISs are robust in complete bipartite graphs.)
There are two ways of chosing an MIS in a complete bipartite graph , namely or . Without loss of generality, assume is chosen. Then, in any connected spanning subgraph of , every node in has at least one neighbor in (the graph is bipartiteness). So the MIS remains maximal. (Independence is not affected, as discussed in Section 2.)
Proof of Lemma 2
(All MISs are robust in sputnik graphs.)
By definition, any removable edge in a sputnik graph belongs to a cycle, thus both of its endpoints have a pendant neighbor. On the other hand, it holds that a pendant node either is in the MIS, or its neighbor must be (thanks to maximality). As a result, after an edge is removed, both of its endpoints remain covered by the MIS, i.e. either they are in the MIS or their pendant neighbor is, which preserves maximality.
Proof of Theorem 2
(RobustMIS is -local in class .)
(Lower bound): If one can solve RobustMIS in looking at distance , then as a special case, one solves regular MIS in paths (Indeed, RMISs are MISs, and paths are trees, which are sputniks, which all belong to ). Then, one can convert the resulting MIS into a -coloring as follows: each node in the MIS takes color , then at most two nodes lie between these nodes. The one with smallest identifier takes color and the other takes color . Finally, it is well known that Linial’s lower bound for -coloring  in cycles extends to paths (within an additive constant), which gives the desired contradiction.
|01:||Collect the information available within distance from in|
|02:||If is a complete bipartite graph with no outgoing edges towards nodes not in Then|
|03:||Set as the node with the lowest identifier of|
|04:||Terminate outputting if is in the same part as , otherwise|
|05:||If is a pendant node Then|
|07:||If has a pendant neighbor Then|
|09:||Set as the set of outgoing edges of towards nodes that have a pendant neighbor|
|10:||Execute the MIS algorithm from  ignoring edges of|
(Upper bound): Let be a graph in . We will prove that Algorithm 1 computes a regular MIS (which by definition is robust) in . All nodes first gather information within distance three (Line 1) and decides if the graph is complete bipartite (Line 2). Three hops are sufficient because all the nodes in a complete bipartite graph are at most at distance 2. Both parts of the test (bipartiteness and completeness) are trivial. If the test is positive, then all nodes which are in the same part as the smallest identifier output IN, the others OUT (lines 3 and 4). Since is bipartite, the set of nodes outputting is independent, and since is complete, it is maximal. Now, if the graph is not complete bipartite, then it is a sputnik (Theorem 1). Let us partition the set of nodes of into three parts (refer to Figure 2 for an illustration): the set of pendant nodes in (i.e. nodes of degree one), the set of nodes with at least one neighbor in , and the set of the nodes which are neither in or in . Observe that it is easy for a node to determine which of the sets it belongs to, based on the (-hop) information it already has. Furthermore, two neighbors cannot be in , since this would imply a single-edge graph that would then be classified as complete bipartite in the previous step. Then, nodes in terminate outputting (Line 6) and nodes in terminate outputting (Line 8). The crucial step is that the subgraph of induced by the nodes of (denoted in the following) is a forest due to the definition of a sputnik. Indeed, by definition, any node involved in a cycle has at least a pendant neighbor and thus belong to . Furthermore, these nodes impose no constraint onto the remaining nodes in since they are not in the MIS, and yet, they do not need additional neighbors to be. As a result, the edges between and can be ignored (Line 9) and a generic MIS algorithm be executed on the induced forest . One such algorithm , dedicated to graphs of bounded arboricity (which the case of ) requires looking only within hops. Note that variable in this formula corresponds to the number of nodes in , which is dominated by .
Finally, we will prove that the produced MIS is valid in . Let us call this MIS, and the MIS produced by algorithm  on . Then clearly (all nodes in output ). is independent since is independent in (and thus in ); no node in is neighbor to a node in (by construction); and no two nodes of are neighbors (as already discussed). As to the maximality, if there exists an independent set for some in , then must belong to either or . Being in is not possible since all nodes in are already in . Being in contradicts independence of since any node in is neighbor to at least one node in (that belongs to ). Finally, being in contradicts the fact that is maximal, which concludes the proof.
Appendix B Pseudo-code of Algorithm of Section 4
Appendix C Proof of Algorithm of Section 4
We consider that we apply FindRMIS to a graph whose -tree is . The objective of this section is to prove that FindRMIS terminates in a polynomial time and returns a robust MIS of if this latter admits one, otherwise. Our proof contains mainly three steps. First (Section C.1), we prove that FindRMIS returns a robust MIS of whenever is a tree. Once this trivial case eliminated, we define a set of notations and definitions in Section C.2. These notations are used in the sequel of the proof. Then, we prove central properties provided by Function TestRMIS (Section C.3) and by Functions LabelNode (Section C.4). We use these properties to prove that the execution of FindRMIS up to Line 19 produces a well-labeling of (in a sense defined below) in Section C.5. Finally, we prove that FindRMIS uses this well-labelling of to return a robust MIS if admits one, otherwise (Section C.6).
c.1 Case of the tree
If is a tree, FindRMIS terminates in polynomial time and returns a robust MIS of .
Assume that is a tree. Line 01 of FindRMIS build the -tree of (that take a polynomial time in the size of ). Then, the test on Line 02 is true (since any biconnected component of a tree has a size of 1) and FindRMIS returns a non empty set of nodes that share the same color in a 2-coloring of (computed in a polynomial time) on Line 04. Note that this set is trivially a MIS of the tree and hence a robust MIS of since any tree belongs to (see Theorem 1). ∎
c.2 Notations and Definitions
In the following of the proof, according to Lemma 6, we restrict our attention to the case where the graph analysed by FindRMIS is not a tree. We define in the following a set of notations used in the proof.
The -tree of is now rooted towards a node . First, we denote by the -subtree of rooted to a node . For any node , we denote its set of children in by . For any node , we denote its parent in by and its attachment point ( if , otherwise) by .
For any node , we say that induces the subgraph of defined as follows. If , then and . If , then and . If , then and