Abstract
Wireless sensor networks (WSNs) are extensively utilized in various circumstances. For applications, the construction of the virtual backbones (VBs) of WSNs has attracted considerable attention in this field. Generally, a homogeneous WSN is formulated as a unit disk graph (UDG), and the VB of the corresponding WSN is modeled as a connected dominating set (CDS) in the UDG. In certain applications, communication between sensors in a network may fail for various reasons, such as sensor movement, signal interference, and the appearance of obstacles. Consequently, a CDS in a UDG should possess fault tolerance on the edges. In this paper, we introduce a new concept called the 2 edge-connected 2 edge-dominating set (-ECDS); then, we design an approximation algorithm for computing -ECDSs in UDGs, the performance ratio of which is 30.51. By means of simulations, we compare our algorithm and existing algorithms in terms of the CDS size, running time, success rate, and network lifetime. The simulation results indicate that our algorithm exhibits better performance and is more suitable for constructing a VB with edge fault tolerance in a WSN.
1. Introduction
Wireless sensor networks (WSNs) are multihop self-organizing network systems that contain numerous sensor nodes. Because no predefined infrastructure is required, WSNs can be flexibly deployed in various circumstances, such as the Internet of Things, ocean monitoring, and traffic surveillance [1–5]. However, the wireless sensors in WSNs are usually powered by batteries, which means that minimizing sensor energy consumption is a critical challenge [6, 7]. Generally, the energy of sensor nodes in a WSN is mainly consumed in the signal transmission process. Specifically, when a signal is transmitted from a source node to a target node, the required energy increases exponentially with increasing distance [8]. Thus, most WSNs use a multihop communication strategy rather than long-range direct communication to enhance the energy efficiency of the sensor nodes [9–14].
In multihop communication, a message from a source node to a target node may be retransmitted many times, which can result in substantial wireless signal interference and collision and waste a large amount of energy. Hence, a high-quality routing path for information transmission is critical. To address this issue in WSN communication, the concept of the VB, inspired by the backbone of wired networks, is supposed to reduce information overload and improve the efficiency and lifespan of the network [1].
In theory, a VB is a subset of sensor nodes in a WSN that meets the following requirements [15]. First, each node in a WSN is adjacent to a node in this subset. Second, any two nodes in the subset have a routing path between them in the VB. To investigate VBs in homogeneous WSNs, the WSN is typically modeled as a UDG , where a vertex in is a simplification of a sensor node and an edge in stands for the message transmission between two sensors; a VB of a WSN is modeled as a CDS in the corresponding graph . In the research of WSNs, since a smaller VB entails less routing overhead and wireless signal collision, the size of the VB is an important index in measuring the quality of the VB. Thus, it is natural to find a minimum CDS (MCDS) of when constructing a CDS. However, Garey and Johnson [16] have proven that calculating MCDSs is NP-hard. Consequently, many efforts have been made to obtain an approximate solution to this problem by designing approximation algorithms.
In practical applications, in a WSN, a few sensors and the links between them may be out of operation for various reasons, such as sensor movement, signal interference, and the appearance of obstacles. Thus, the VB for a WSN should be fault tolerant such that it continues to work when some nodes and links fail. Fortunately, in recent years, progress has been made in designing node fault-tolerant VBs for WSNs. In fact, in 2005, Dai and Wu [17] proposed a special CDS, the connected dominating set, for a node fault-tolerant VB in a WSN against node failure. Later, Thai et al. [18] extended this concept to the famous connected dominating set (CDS), where . Since the construction of the minimum CDS is NP-hard, the construction of the minimum CDS is also NP-hard. As a result, numerous researchers have focused on developing approximation algorithms to calculate a CDS with a worst-case performance guarantee for any given pair of integers and () [19–27].
Note that the above literature considered only the problem of a fault-tolerant VB against node failure and neglected the impact of edge failure. In practical applications, edge failure may impact the operation of a VB in the considered WSN; in other words, edge failure may lead to failure of the VB even if all nodes in the VB are fault-free. For example, in a WSN with 9 nodes, which is modeled by the UDG shown in Figure 1, the VB consists of nodes , , and . When edge fails, some aspects of the VB, such as domination, will fail, even though each node is fault-free. In practice, edge failure in a WSN may be inevitable due to various factors, such as node movement, signal interference, and obstacles. For example, in the WSN shown in Figure 1, when node is moved to a position outside of the transmission range of (see Figure 1(b)), edge fails, which results in subset no longer being a VB.
(a) is not a CDS when edge fails
(b) Edge fails when node moves outside of the transmission range of , even though all nodes are fault-free
Note that in a UDG, if a CDS is a node fault-tolerant CDS, such as -CDS with , it must be an edge fault-tolerant CDS. Formally, in a UDG , a CDS is a node fault-tolerant CDS if for any , is still a CDS in . Similarly, in a UDG , a CDS is an edge fault-tolerant CDS if for any , is still a CDS in . Compared to that of constructing an edge fault-tolerant CDS in a UDG, the cost of constructing a node fault-tolerant CDS may be higher. On the other hand, in some UDGs, there may not exist a node fault-tolerant CDS, while there is an edge fault-tolerant CDS. For example, in the UDG shown in Figure 2, there are no node fault-tolerant CDSs; however, the CDS is an edge fault-tolerant CDS because when any edge in fails, is still a CDS. Hence, it is necessary to explore how to construct an edge fault-tolerant CDS in a UDG. Unfortunately, few efforts have been made in this direction in the existing literature.
In this paper, we investigate the construction of an edge fault-tolerant CDS in a UDG. Specifically, this paper introduces a new concept called the 2 edge-connected 2 edge-dominating set (in short, -ECDS) and develops a constant factor approximation algorithm to calculate a -ECDS in a given UDG.
The main work of our paper is described as follows: (i)To obtain an edge fault-tolerant VB in a WSN, we introduce a new concept called the -ECDS(ii)A centralized approximation algorithm is designed for the construction of a -ECDS in a given UDG, whose performance ratio is proven to be 30.51(iii)The designed algorithms are supported by strict theoretical analysis and simulation experiments. In the theoretical analysis, we conduct strict mathematical proof of the correctness of these algorithms. By means of simulation experiments, we illustrate that the CDSs output by our algorithms outperforms those obtained with the state-of-the-art algorithms presented in [25, 26]
The rest of this paper is organized as follows. In Section 2, related research is introduced. In Section 3, an introduction of the definitions, terms, and related results used in the remaining sections is provided. Section 4 presents an approximation algorithm for constructing a -ECDS. Section 5 reports simulation results on the comparison between our algorithm and other related algorithms. Finally, in Section 6, we summarize our work and introduce potential directions for future work.
2. Related Work
A WSN can be abstracted as a graph ; correspondingly, the VB of the WSN can be abstracted as a CDS of . In recent years, numerous efforts have been made to construct MCDSs. In a general graph, Guha and Khuller [28] proved that for the MCDS problem, it is impossible to obtain a polynomial time approximation algorithm with a performance ratio for any unless , where is the number of nodes in the graph. They introduced a -approximation algorithm and a -approximation algorithm based on a greedy strategy, where is the maximum degree of nodes in the corresponding network graph and is the harmonic function. In [29], Du et al. improved this result and presented an -approximation algorithm , which is the best result in general graphs thus far.
For UDGs, the MCDS problem has been widely investigated, and a variety of results have been obtained [26, 30–39], in which different approximation algorithms have been proposed for this problem. These algorithms usually consist of two phases: (1) a maximal independent set (MIS), which serves as a dominating set in a given UDG, is determined, and (2) some nodes are selected into the MIS such that it becomes connected. Researchers analyzed the performance ratio of the resulting CDS from two aspects: the size of the MIS obtained in the first phase and the number of newly added nodes in the second phase. For the MIS size, in [33], Wan et al. demonstrated that the upper bound of an MIS is in a UDG, where represents the size of the MCDS in the UDG. Later, this upper bound was improved by [30, 34–37], where [30] obtained an upper bound of , which is the best result thus far. For the size of the newly added nodes, in [33], Wan et al. showed that the size bound generated by their algorithms in the second phase is , where is the MIS obtained in the first phase. This result was used by [34, 35] to evaluate the performance ratios of their algorithms. In [31, 38], the Steiner tree strategy was used to design approximation algorithms for the MCDS problem, and the size of the newly added nodes in the second phrase was no more than , where is the number of Steiner nodes in the minimum Steiner tree containing the MIS obtained in the first phase. To our knowledge, this is the best result thus far.
In research on the construction of node fault-tolerant VBs, Dai and Wu [17] introduced a concept called the -CDS. For a -CDS in a given , after nodes are deleted from , the set of residual nodes in the -CDS is still a CDS for the subgraph induced by the residual nodes of . They presented three algorithms to compute a -CDS for a given UDG. Unfortunately, they did not present the performance ratios of these three algorithms. In [18], Thai et al. extended this concept to the famous -connected -dominating set, where . In their paper, a centralized approximation algorithm was provided for the minimum -CDS problem. Since then, numerous constant factor approximation algorithms for the construction of -CDSs have been proposed. In [40], Wu et al. presented a distributed algorithm with a performance ratio of . In [25], Shang et al. proposed another approximation algorithm, whose performance ratio is or 11 , for constructing a -CDS. In [26], Shi et al. noted mistakes in the proof process of the performance ratio of the algorithm in [25] and found that the ratio should be or 21 rather than or 11 . Moreover, Shi et al. [26] used a submodular function and greedy strategy to design a new approximation algorithm with a performance ratio of , where is the performance ratio of the algorithm for constructing the -CDS. In 2010, Kim et al. [23] introduced a approximation algorithm for computing a -CDS in a UDG, where is the performance ratio of the algorithm for the -CDS () problem. In [41], Liu et al. used Tutte decomposition to design a approximation algorithm to calculate a -CDS () in a UDG, where is the performance ratio of the algorithms for the -CDS () problem. When , they noted that the performance ratio of their algorithm is 62.30, which is better than the 580/3 performance ratio achieved by [23]. In [8], Wang et al. introduced the concepts of “good points” and “bad points” and proposed an algorithm to calculate a -CDS in a given UDG, where and . The main idea of their algorithm is to first obtain a -CDS by means of an existing algorithm and then convert all degree- bad points in the -CDS into good points by adding “-paths.” Second, they construct a simplified auxiliary graph for the CDS obtained in each iteration. Finally, the -CDS is constructed by means of the simplified auxiliary graph. They achieved a performance ratio of for the -CDS problem ( for the -CDS problem), where is the performance ratio of the algorithm proposed in [26] for -CDS problem .
In recent years, research on link failure in WSN communication has attracted considerable attention. In [42], Zonouz et al. proposed a model, called time-dependent lognormal shadowing radio propagation, to analyze and estimate the reliability of a wireless link under consideration of the power consumption in different modes and wireless channel conditions. In [43], Fu et al. noted that the capacity of links is significantly limited in most WSNs. They believed that when the load of a few links in the network exceeds their capacity, link failures may occur, which may cause paralysis of the global network. Later, in [44], Draz et al. provided a link failure detection algorithm to proactively diagnose faulty links in a WSN and introduced a recovery mechanism against link failures. In [45], Xu et al. used independent Bernoulli processes to describe link failures in a WSN and employed a Kalman-consensus filter and CI algorithm to estimate these link failures through a hierarchical fusion method. In [46], to improve the robustness of VBs, Liang et al. proposed a new concept, robust VB, and corresponding algorithms against link failures in WSNs with unstable transmission ranges. In their work, a more robust VB, named the -robust CDS, is obtained by their algorithms, and based on this VB, the communication in the corresponding WSN does not fail when , where is the effective transmission range of the nodes and is the initial transmission range of the nodes.
As described above, link failures can impact WSN communications. A natural idea is to investigate VBs with link fault tolerance, namely, the problem of edge fault-tolerant VBs against link failure. Unfortunately, research on the construction of edge fault-tolerant VBs in WSNs remains scarce. In this paper, we consider this problem and introduce the concept of the -ECDS for UDG, which is a kind of edge fault-tolerant VB in the corresponding homogeneous WSN, and propose an approximation algorithm for the construction problem of the -ECDS.
3. Preliminaries
For convenience, some concepts, notations, and knowledge related to graph theory are now introduced. In this paper, all considered graphs are connected unless otherwise specified.
3.1. System Model and Problem Definition
In this paper, we adopt the following assumptions: the sensors in the considered WSN are randomly placed in a given area and immobile thereafter; each sensor has the same transmission radius and initial energy; two sensors can communicate with each other if and only if one of them is within the transmission range of the other; and in the considered WSN, each link between sensors is bidirectional. We abstract each sensor of the WSN as a node of a graph and each communication link between two sensors as an edge between the corresponding nodes. Thus, a WSN is modeled as an undirected connected graph .
The problem that we address in this paper is called the minimum-ECDS problem. For the sake of understanding the minimum -ECDS problem, we first introduce some necessary concepts related to this problem.
Definition 1 (2 edge-connected graph). A graph is called a 2 edge-connected graph if for any , is connected, where is the spanning subgraph induced by edge set . In particular, a graph with a single node is defined as a 2 edge-connected graph.
Definition 2 (2 edge-dominating set). In a given graph , a subset is called a 2 edge-dominating set if for each node , .
In a given UDG , let and . If , then we say that is 2 edge-dominated by .
Definition 3 (2 edge-connected 2 edge-dominating set). In a given UDG , a CDS is a -ECDS if the following conditions hold: (1) is a 2 edge-dominating set of (2) is a 2 edge-connected graph
A -ECDS with the minimum cardinality is called a minimum -ECDS.
Definition 4 (minimum -ECDS problem). For a given graph , the minimum -ECDS problem is the problem of constructing a minimum -ECDS for .
Note that because the MCDS problem for a graph is NP-hard, the minimum -ECDS problem for a graph is also NP-hard. In this paper, we will design an approximation algorithm for the minimum -ECDS problem.
3.2. Notations
In this subsection, we use to denote a UDG. (i): the spanning subgraph induced by , namely, (ii): the subgraph induced by (iii): the edge subset, where each edge is incident to , namely, (iv): , where (v): the set of neighbor nodes of (vi): (vii): the ID of node (viii): the energy of node (ix): the set consisting of all edges of (x): the set consisting of all nodes of
3.3. Definitions
Definition 5 (weight function ). Given two 3-tuple variables and , for a weight function , if and only if at least one of the following conditions is true: (i)(ii) and (iii) and and
Definition 6 (bridge). In a given UDG , is called a bridge of if is disconnected.
According to Definitions 1 and 6, a given UDG is a 2 edge-connected graph if and only if each edge is not a bridge of .
Definition 7 (edge-disjoint). In a given UDG , let and be two different paths. Then, and are called edge-disjoint if .
Definition 8 (simple cycle). In a given UDG , let be a path of . The path is called a simple cycle in if and .
According to Whitney’s theorem [47], the proposition that for a given , is a bridge of is equal to any one of the following propositions.
(1)In , such that all paths between and contain edge (2) has no simple cycle containing
Definition 9 (-block). In a given UDG , let . is a -block of if one of the following conditions holds: (1) consists of a single node, and for any nonempty subset , is not 2 edge-connected(2) consists of at least two nodes; is a 2 edge-connected graph; and for any nonempty subset , is not 2 edge-connected(3) and is a 2 edge-connected graph
Remark 10. According to the definitions of the -block and 2 edge-connected graphs, for a given graph UDG and a set , we have the following conclusions: (1)If is a -block of , then is 2 edge-connected blocks(2) is the unique -block of if and only if is 2 edge-connected
Definition 11 (path). In a given UDG , let and . A path from to with nodes is called a path if its inner nodes belong to .
Lemma 12. In a given UDG , for any , there exist two paths that are edge-disjoint between and if and only if is a 2 edge-connected graph.
According to Definition 7 and Whitney’s theorem, the proof of Lemma 12 is easy to obtain.
4. Algorithm and Analysis
In this section, we present an algorithm (called LLZ20) to construct a -ECDS in a 2 edge-connected UDG . LLZ20 includes three main parts. First, a CDS in is constructed with the two-stage approximation algorithm (called ACC11) in [32]. Next, a connected 2 edge-dominating set is calculated by adding some nodes to the CDS obtained in the first part; this can be implemented by calling Algorithm 2, whose flow chart is shown in Figure 3. Finally, paths are added to connect the nodes of the connected 2 edge-dominating set obtained in the second part to make it a ()-ECDS; this can be implemented by calling Algorithm 3, whose flow chart is shown in Figure 4. In Algorithm 3, to compute -blocks in a subgraph, we need to call another algorithm, Algorithm 4, whose flow chart is shown in Figure 5. LLZ20 is described formally in Algorithm 1.
| ||||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||||||||
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
For readers to understand LLZ20 more intuitively, an example network graph is presented in Figure 6 to illustrate the steps of LLZ20. For convenience, let the initial energy of each node be the same. (1)For a given WSN, which is abstracted as the network graph (shown in Figure 6(a)), LLZ20 calls ACC11 to construct a CDS in (line 1). In this process, , , and are selected consecutively to form a CDS, and then, pseudocontrol node is deleted because does not affect the connectivity of the CDS. When this step is complete, (blue nodes shown in Figure 6(b)) is the resulting CDS (2)In line 2 of LLZ20, Algorithm 2 is called to calculate a dominating set (green nodes shown in Figure 6(c)) in . Before Algorithm 2 is executed, nodes , , , , and are not 2 edge-dominated by the CDS . When Algorithm 2 is executed, and are consecutively selected to obtain a connected 2 edge-dominating set , and the pseudocontrol node set is an empty set (see Figure 6(c) for details)(3)In line 3 of LLZ20, Algorithm 3 is called to calculate the set , which consists of the inner nodes of the selected path. Specifically, before Algorithm 2 is executed, is not 2 edge-connected. When Algorithm 2 is executed, the path and the path are consecutively selected; in other words, and are consecutively selected into the set . After this step is finished, is the resulting -ECDS (see Figure 6(d) for details)
4.1. Analysis of Algorithm Correctness
In this subsection, we provide proof of the correctness of our algorithms and show that a -ECDS must be obtained after executing LLZ20. For this purpose, we need to show only that the following three results are true: (1) ACC11 in [32] can generate a CDS, (2) Algorithm 2 can generate a connected 2 edge-dominating set, and (3) Algorithm 3 can generate a -ECDS.
According to [32], the first result is true. Next, we show the correctness of the second result that Algorithm 2 can generate a connected 2 edge-dominating set.
Lemma 13. After executing Algorithm 2, the output is a connected 2 edge-dominating set.
Proof. We need to prove that is connected and that is a 2 edge-dominating set. First, since is a CDS and , is connected. Next, we prove that is a 2 edge-dominating set. Let , where (, respectively) is (, respectively) obtained after executing line 15. Then, . Let ; then, . We claim that there are two edges with a common endpoint such that their other endpoints are in . If , then according to lines 2-7, , our claim is true. If , then according to lines 8-14, after executing line 14, is an MIS in , which means there is an edge with one endpoint and another endpoint belonging to . On the other hand, since is a CDS, there is an edge with endpoint and another endpoint belonging to . Hence, our claim is true. According to the above analysis, is a 2 edge-dominating set.
According to the above lemma and lines 10-12 of Algorithm 2, it is easy to obtain the following corollary.
Corollary 14. After Algorithm 2 is executed, for any , is a 2 edge-dominating set in .
Now, we show that (the result of Algorithm 3) is a -ECDS. Before we present the proof, let us first introduce some definitions and lemmas used in the following discussions. The following preliminaries, which serve as proof of the correctness of the results, are necessary.
For node chosen in line 3, let (line 9), be a set of red nodes with the same after executing the th iteration of the for-loop (lines 10-24) in Algorithm 4, which is the iteration for (line 10). Let be the number of of the red nodes in (line 11) before executing the th iteration of the for-loop (lines 10-24), and let be the subset of that consists of all nonred nodes in (line 11) before executing the th iteration of the for-loop (lines 10-24) in Algorithm 4. When , let be the nonempty subset of , which consists of all red nodes with the same before executing the th iteration of the for-loop (lines 10-24) in Algorithm 4. Then, . In this case, is called the TC decomposition of , is called a red TC decomposition piece of , and is called a nonred TC decomposition piece of . Clearly, if there is no TC decomposition in , then .
For a better understanding of TC decomposition, let us consider the network graph shown in Figure 7, which is one part of the network obtained before executing the th iteration of the for-loop (lines 10-24) in Algorithm 4, where the integer is determined as follows. Assume that in network graph , is the node chosen by line 3 in Algorithm 4 and , the th iteration of the for-loop (lines 10-24) is referred to as the iteration, in which the edge is considered (line 10). Assume that is the simple circle determined by line 11 in the th iteration, where and before the th iteration of the for-loop (lines 10-24). Then, , , , , . Finally, is a TC decomposition of .
Lemma 15. If there is no TC decomposition in , then contains a simple circle with all nodes of .
Proof. According to the above discussion, it is easy to see that the result is true.
Lemma 16. Suppose that and is the TC decomposition of , where . If is 2 edge-connected, then is 2 edge-connected.
Proof. According to the definition of and line 19, , where is the node set of the simple circle selected in line 11 of Algorithm 4. Clearly, . We claim that . Otherwise, after executing the th iteration of the for-loop (lines 10-24) in Algorithm 4, the s of the nodes in are not equal to , which implies that is not contained in , a contradiction. Let and be the edge sets in and , respectively. Construct a new graph , where , . Clearly, is connected: we claim that is 2 edge-connected. We need to prove only that for any edge , is connected.
Case 1. . Since is 2 edge-connected, is still connected. According to and the fact that is connected, we have that is connected.
Case 2. . Since is a simple circle, is still connected. Note that and are 2 edge-connected ; thus, we have that is connected.
Hence, is 2 edge-connected. Since is a spanning subgraph of , is 2 edge-connected.
Lemma 17. After executing line 29 in Algorithm 4, is a 2-block in .
Proof. According to line 6, lines 14-15, and lines 18-22, consists of red nodes with the same or a single blue node. Consider the following cases.
Case 1. consists of a single blue node. Let be this node. Clearly, is not in any simple circle in (otherwise, according to lines 10-24, would be colored red). We claim that for any nonempty subset , is not 2 edge-connected. In contrast, assume that there exists a nonempty subset such that is 2 edge-connected. Let ; then, there exist two edge-disjoint paths between and in that form a simple circle and contain node , a contradiction. Thus, this claim is true. According to the definition of a -block, is a -block.
Case 2. consists of red nodes with the same .
According to the definition of (line 29) and the structure of the for-loop (lines 2-28), we conclude that there is some selected node (line 3) with and some integer such that the corresponding is . Now, consider the following two subcases:
Case 1. There is no TC decomposition in ().
According to Lemma 15, contains a simple circle with all nodes in , which implies that is 2 edge-connected nodes. Next, we show that for any nonempty set , is not 2 edge-connected. To the contrary, assume that is 2 edge-connected. Let and ; then, there are two edge-disjoint paths between and in that form a simple circle . has at least one edge that does not belong to BRANCH. Note that for any , there exists a unique simple cycle containing , whose other edges belong to BRANCH. Hence, there exists a simple cycle containing and an edge , whose other edges belong to BRANCH. Without loss of generality, suppose that . When is selected in line 3, . Then, a simple circle (line 11), whose edges are all in set , is determined in the iteration in which is chosen (line 10). Clearly, is . After this iteration is finished, are colored red, and . Furthermore, after executing line 9, it is still true that , which implies that , a contradiction to the assumption that . Hence, is not 2 edge-connected. As a result, is a -block.
Case 2. There is a TC decomposition in .
We first prove that is 2 edge-connected. Assuming that is not a 2 edge-connected graph, we will arrive at a contradiction. Let be the TC decomposition of ; then, according to Lemma 16, there must exist such that is not 2 edge-connected. According to the structure of the for the-loop (lines 2-28), there is some and some integer such that .
If there is no TC decomposition in , then according to Lemma 15, is 2 edge-connected, a contradiction. If there is a TC decomposition in , we have that there exists a such that is not 2 edge-connected, where . Repeating this procedure, we obtain a series of sets and that satisfy the following conditions:
(1) is a red TC decomposition piece of , (2) is not 2 edge-connected(3) has a TC decomposition, and has no TC decompositionHere, . Notably, the iteration of this procedure can terminate because each that has a TC decomposition is determined by an edge in and the number of edges in is bounded (see the definition of TC decomposition). According to Lemma 15, is 2 edge-connected, a contradiction. Hence, is 2 edge-connected.
Next, we show that for any nonempty set , is not 2 edge-connected. A similar discussion to the proof of Case 1 can be used to prove this result.
From the above analysis, is a -block.
Lemma 18. After executing line 29 in Algorithm 4, contains exactly all -blocks in .
Proof. Lemma 17 shows that each is a -block. Next, we need to prove only that except for , there are no other -blocks in . In contrast, assume that there is another -block with in . Consider the following cases.
Case 1. . Note that ; then, there exists some such that . According to the definition of a -block, is not a -block, a contradiction.
Case 2. . Consider the following subcases.
Case 1. There is such that . According to the definition of a -block, is not a -block, a contradiction.
Case 2. There is not an such that . Note that . Then, and such that and . According to the assumption, is a -block, which implies that is 2 edge-connected paths; thus, there exist 2 edge-disjoint paths between and that form a simple circle. Hence, is 2 edge-connected, a contradiction to the assumption that is a -block.
Thus, contains exactly all -blocks in .
Lemma 19. In each iteration of the while-loop (lines 3-11) in Algorithm 3, before the execution of line 4, there must exist a shortest path in that connects at least 2 different -blocks in .
Proof. According to line 3, before the execution of line 4, there exist at least two -blocks in , where . In the following discussions, is a set obtained before the execution of line 4. Let be all the -blocks in .
First, we prove that in , there must exist an path that connects at least 2 different -blocks. Since , there must exist a bridge in . Let be a bridge in ; then, such that all paths between and contain bridge , which implies that there are no edge-disjoint paths between and in . On the other hand, since is a 2 edge-connected graph, there are two edge-disjoint paths between and in (Lemma 12). Let be the shortest path from to in that does not contain bridge and has at least one node outside . For convenience, for , we use to denote a path from to and to denote , and we let , where each is nonempty and its nodes are outside and the nodes in are in . We claim that there exists some such that and belong to two different -blocks in . In contrast, assume that for each , belongs to the same -block, say in (see Figure 8). According to the definition of a -block, there is a path from to in the -block . Now, using to replace in , we obtain a new path in that does not contain bridge , a contradiction. Hence, the claim is true.
Now, we suppose that satisfies the condition that and belong to two different -blocks in , say , . Let ; then, is an . Next, we prove that there is an in by induction on , the number of nodes in . When , the result is clearly true.
When , since is a dominating set, there is a node in , say , such that . If , then is an ; the result is true. If , then is an ; the result is true.
Assume that when , the result is true. Now, we consider the situation . Then, . Similarly, since is a dominating set, there is a node in , say , such that . If , then is an ; the result is true. If , then is an . According to the inductive assumption, we have that the result is true.
Lemma 20. In Algorithm 3, let be the set obtained after executing the th iteration of the while-loop (lines 3-11) and let be the set consisting of all -blocks in ( denotes the set consisting of all -blocks in ). Then, .
Proof. Let be the in the th iteration of the while-loop (lines 3-11) in Algorithm 3 and . Without loss of generality, let be these two -blocks in , which are connected by , and let and be the two endpoints of with . Since is connected, there is a path between and in . Note that . Therefore, there is a simple circle containing and in , denoted by . After calling Algorithm 4 to recompute the -blocks of , the -block_IDs of nodes in are the same.
Let . Clearly, before executing the th iteration of the while-loop (lines 3-11). Let .
In the th iteration of the while-loop (lines 3-11) in Algorithm 3, after executing line 6 or line 9, which calls Algorithm 4 to recompute the -blocks in , each node is set to have the same value, while the values of the nodes in are unchanged. Thus, the number of different s of the nodes in is less than that of different s of the nodes in . According to line 29 in Algorithm 4 and Lemma 18, we conclude that the number of different -blocks in is less than that in ; in other words, .
Next, we use the above preliminaries to prove that generated by Algorithm 3 is a -ECDS of . In fact, according to Lemmas 18 and 19, we know that in Algorithm 3, the while-loop (lines 3-11) can be executed only if the number of -blocks in is more than 1. Thus, according to Lemma 20, we conclude that after executing Algorithm 3, there is only one -block in . Furthermore, according to the definition of a -block, is 2 edge-connected blocks. This implies that (line 12) is a -ECDS of . Note that and (see while-loop (lines 8-14) and line 15 in Algorithm 2); thus, . According to the for-loop (lines 13-17), it is easy to see that (line 18) is 2 edge-connected.
Let be the set of nodes deleted in the for-loop (lines 13-17); then, after Algorithm 3 is executed, and , which imply that . Next, we prove that is a 2 edge-dominating set. Equivalently, we need to prove only that for , is 2 edge-dominated by . Note that ; thus, or . Consider the following cases.
Case 1. . Since is an independent set and is 2 edge-connected, is 2 edge-dominated by , where is the obtained after the for-loop (lines 13-17) is executed.
Case 2. . Note that and that, according to Corollary 14, is 2 edge-dominated by . On the other hand, since , is 2 edge-dominated by .
Overall, is a 2 edge-dominating set. Thus, (line 18) is a -ECDS of .
According to the above discussions, we obtain the following theorem.
Theorem 21. The output of Algorithm 1 is a -ECDS of .
4.2. Analysis of the Performance Ratio and Time Complexity
In the above subsection, we provided proof that a -ECDS must be obtained by our algorithms. In this subsection, we prove that LLZ20 is an approximation algorithm and then present its performance ratio.
In line 1 of Algorithm 1, for a given graph , we utilize ACC11 in [32] to construct a CDS in . In this process, a CDS is calculated in 2 steps. In the first step, an MIS is obtained; in the second step, some nodes outside the MIS are added to the MIS such that it becomes a CDS . Das et al. [32] proved that the size of is no more than , where is the MCDS size in .
Lemma 22. After executing line 2 in Algorithm 1, , where is the MCDS size in .
Proof. According to lines 7-14 of Algorithm 2, is an MIS in . Since , , where is an MIS in . According to [30], . Hence, .
According to line 15 of Algorithm 2, we obtain the following inequalities:
Lemma 23. After executing Algorithm 3, .
Proof. Let be the number of -blocks in line 2 of Algorithm 3. Clearly, . According to Lemma 20, the number of iterations of the while-loop (lines 3-11) in Algorithm 3 is no more than . Note that in each iteration of the while-loop (lines 3-11), one or two new nodes are added to . Hence, .
Theorem 24. After executing line 3 in Algorithm 1, , where is the minimum -ECDS size in .
Proof. Let be the MCDS size in ; then, . According to Algorithm 3 and Lemmas 22 and 23, we have the following inequalities:
In the following paragraphs, we discuss the time complexity of LLZ20. The overall time cost of LLZ20 includes three components: (1) the time cost of computing a CDS by ACC11, (2) the time cost of computing a 2 edge-dominating CDS by Algorithm 2, and (3) the time cost of constructing a -ECDS by Algorithm 3.
Denote the number of nodes in a given input by . In the first phase, according to [32], the time cost of constructing a CDS by ACC11 is .
In the second phase, the time cost of calculating the set of the nodes that have only one dominator in is (the for-loop (lines 2-6)). Moreover, the time cost of finding an MIS in is (the while-loop (lines 8-14)). Hence, the time cost of constructing a 2 edge-dominating CDS by Algorithm 2 is .
In the third phase, since Algorithm 4 is called to compute the -blocks in the subgraph induced by the updated , the time complexity of Algorithm 4 must be analyzed. In Algorithm 4, the time cost of constructing a BFS tree is . In the iterations of the for-loop (lines 2-28), the time cost of computing all -blocks in based on is . Hence, the time complexity of Algorithm 4 is . Now, we discuss the time cost of using Algorithm 3 to obtain the -ECDS . In Algorithm 3, iteration of the while-loop (lines 3-11) is equal to , and the overall behavior of line 2, line 6, and line 9 is similar. Each computes the -blocks in the subgraph induced by the updated by calling Algorithm 4, which implies that all of their time costs are . Consequently, the time cost of adding paths to connect a 2 edge-dominating set to form a -ECDS (while-loop (lines 3-11)) is . In addition, the time cost of deleting some redundant nodes from (lines 13-17) is . Hence, in the third phase, the time complexity of constructing a -ECDS by Algorithm 3 is .
Overall, the time complexity of Algorithm 1 is .
Theorem 25. Suppose that the number of nodes in a given input is ; then, the time complexity of LLZ20 (Algorithm 1) is .
5. Simulation and Analysis
In the previous sections, we proposed an approximation algorithm LLZ20 to compute a -ECDS, a new CDS with edge fault tolerance, in a given network graph. At the same time, we conducted a theoretical analysis of the performance ratio of LLZ20. In this section, we perform simulation experiments to evaluate the performance of our algorithm in terms of the size of the CDS, running time, and success rate and compare our algorithms with the existing related algorithms proposed by [25, 26]. In the rest of this section, we refer to the algorithm in [25] as SYWH08 and that in [26] as SZZW16. To objectively compare the performances of these three algorithms (LLZ20, SYWH08, and SZZW16), we utilize the algorithm proposed in [32], which, to the best of our knowledge, is the algorithm with the minimum performance ratio in terms of the size of the CDS, to generate a CDS. Notably, the authors of [26] proposed an algorithm to calculate a -CDS based on a known -CDS; however, they did not present a specific method to generate such a -CDS. In our simulation experiments, we use the algorithms proposed by [48] to calculate a -CDS based on a CDS obtained by [32]’s algorithm. The key parameters used in the simulations are listed in Table 1. In the simulation experiments, the employed hardware and software are an Intel Core i5 CPU 2.56 GHz, 16 GB DRAM, 64-bit Windows 10, and the Programming IDE is MATLAB.
5.1. Effects of the Number of Nodes
In the experimental setup, for convenience, we choose a virtual space with a experimental area. We let the transmission radius of each node be 25 m and set the network size to .
First, we provide a brief introduction to the generation process of candidate networks. Consider nodes randomly distributed in the above virtual space. After a WSN has been determined, the program judges whether it is 2 connected: if yes, the network is chosen as a candidate network for the experiments; otherwise, it is abandoned. The procedure is repeated 100 times, and the candidate networks are saved. In the simulation experiment in this subsection, the chosen network graphs are 2 connected but not 2 edge-connected graphs. The main reasons for this selection are as follows. On the one hand, when the chosen network graph is a 2 connected graph, all three algorithms can generate a -ECDS; however, when the chosen network graph is a 2 edge-connected graph, only our algorithm can guarantee the generation of a -ECDS (SYWH08 and SZZW16 cannot). On the other hand, to objectively compare the performance of our algorithm with that of SYWH08 and SZZW16 in terms of CDS size and algorithm running time, the three algorithms should be able to generate a -ECDS in the same experimental environment.
For each candidate network, , LLZ20 (SYWH08 and SZZW16, respectively) is run to calculate a -ECDS, and the running time and resulting CDS size are recorded. These operations are repeated for all candidates, and the averages are calculated as the simulation result. Figures 9 and 10 exhibit the simulation results for LLZ20, SYWH08, and SZZW16 in terms of CDS size and algorithm running time, respectively.
Figure 9 presents the relationship between the simulation curves for the -ECDS size of these three algorithms. The resulting -ECDS size increases as the network size increases for all three algorithms. This result is reasonable because the larger the network size is, the greater the number of nodes needed to dominate the network. Moreover, our algorithm (LLZ20) outperforms SYWH08 in terms of the CDS size, and the CDS size difference between LLZ20 and SYWH08 increases as the network size increases. This is because SYWH08 is designed for a -CDS, which is a -ECDS, while LLZ20 is specifically designed for a -ECDS. This difference may cause the number of nodes added to the -ECDS to form the resulting -ECDS in SYWH08 to be greater than that in LLZ20. According to Figure 10, the average running time of our algorithm is almost the same as that of SYWH08. Strictly speaking, the average running time of SYWH08 is slightly less than that of our algorithm. This slightly longer running time is tolerable because the performance of our algorithm is clearly better than that of SYWH08 in terms of CDS size, and the difference in average running time is within 5 s, even when the network size is 250.
Figure 9 shows that the size of the -ECDS obtained by our algorithm is slightly larger than that obtained by SZZW16 for different network sizes. This result is acceptable for the following reasons. On the one hand, compared with SZZW16, our algorithm requires a shorter time to obtain the simulation results (see the discussion in the next paragraph). On the other hand, as mentioned in Introduction, some network graphs have an edge fault-tolerant CDS and do not contain any node fault-tolerant CDS. To guarantee that the simulation result of SZZW16 is obtained, 2-connected network graphs have to be chosen as the candidate networks for simulations in the simulation experiment. More specifically, compared with SZZW16, to guarantee that an expected CDS is obtained, our algorithm is designed to be suitable for a larger number of wireless networks; see the discussions regarding the next simulation for details. In addition, the difference between the size of the CDS obtained by our algorithm and that of the CDS obtained by SZZW16 is small (approximately 2).
Next, we consider the simulation results shown in Figure 10, which show that the performance of our algorithm is better than that of SZZW16 in terms of average running time.
Figure 10 shows that the average running time of our algorithm is less than that of SZZW16 and that the average running time of SZZW16 increases superlinearly with increasing network size, while the average running time of our algorithm increases slightly with increasing network size. When , the average running time of SZZW16 exceeds 570 s and is more than 57 times that of our algorithm. This result is reasonable. In fact, in the process of generating the -ECDS, to select some nodes to add to the -ECDS to form a -ECDS, SZZW16 needs to compute the potential function value of each node in the network to determine whether it can be selected, and the computation of the potential function value for a node is very complex. Therefore, this process has a high time cost. Consequently, it is natural that this time cost increases as the network size increases. However, in the process of selecting some nodes to add to a -ECDS to form a -ECDS, for a node outside the -ECDS, our algorithm only needs to make a simple comparison of the node neighbor information between this node and other nodes outside the -ECDS to determine whether it can be selected, which entails only a small time cost.
On the basis of the above analysis, we can conclude that among SYWH08, SZZW16, and LLZ20, our algorithm is the most suitable algorithm to compute a -ECDS in network graphs based on the comprehensive consideration of the CDS size and algorithm running time.
5.2. Effects of the Network Density
In this subsection, we present simulations carried out to investigate the effects of the network density to compare the performance of the three algorithms. Specifically, we investigate how a change in network density affects the CDS size for these three algorithms. To obtain simulation results showing how the CDS size changes as the network density changes, we fix the network size to and the node transmission radius to m and vary the area from to . In this experiment, we randomly generate 100 candidate networks, which are 2-connected, in an area with the size varying as described. For each candidate network, we run each of the three algorithms to obtain a -ECDS and record the CDS size. For a given density, we repeat this operation for 100 candidate networks and take the average of the simulation results.
Figure 11 compares the performance of the three algorithms in terms of the CDS size. From Figure 11, it is easily found that the CDS size increases as the network area size increases; in other words, the CDS becomes larger as the network density decreases. This is reasonable because the sparser the network is, the fewer nodes are dominated by a node in the network. In additional, from Figure 11, we can see that LLZ20 outperforms SYWH08 for each area size (i.e., network density) and shows similar performance to SZZW16. Specifically, the CDS generated by LLZ20 is smaller than that generated by SYWH08 by at least 57, and the difference increases as the network density increases (when the network area size is , the difference is approximately 81). On the other hand, the size of the CDS obtained by LLZ20 is generally close to that obtained by SZZW16, and as the density increases, their difference decreases. In particular, when the network area size is , this difference is approximately 2. This is acceptable for a reason similar to that mentioned when discussing the above simulation results, namely, the time complexity of SZZW16 is far greater than that of our algorithm, LLZ20. In other words, LLZ20 outperforms SZZW16 on average.
5.3. Comparison of the Success Rate
As mentioned in the beginning of Subsection 4.1, in theory, for any given 2 edge-connected network graphs, our algorithm can always output a -ECDS, while SYWH08 and SZZW16 may fail. If an algorithm cannot output an expected -ECDS for the problem of finding the minimum -ECDS for a given 2 edge-connected network, the algorithm is useless for this problem. In other words, in a randomly generated 2 edge-connected network, for the problem of finding the minimum -ECDS, the probability that the considered algorithm successfully outputs a -ECDS is an important factor in evaluating its performance. We call this probability the success rate of the considered algorithm. In this subsection, we compare the performance of three algorithms (LLZ20, SYWH08, and SZZW16) in terms of the success rate by means of a simulation experiment. For convenience, is utilized to denote the considered algorithm’s success rate, where is the number of total experimental networks and is the number of experimental networks in which a -ECDS is successfully output by the algorithm.
In the experimental setup, we also select 100 candidates, where the selection process is similar to that in the above subsection, except for the condition used to determine whether a randomly generated network graph is a candidate. In this simulation, this condition is the following: “After such a WSN has been determined, the program judges whether it is 2 edge-connected; if yes, this network is chosen as a candidate network for experiments; otherwise, it is abandoned.”
For each candidate network , we run LLZ20 to calculate a -ECDS and record whether a -ECDS can be output. After the results are obtained for 100 candidate networks, we calculate the success rate , where . We perform similar operations for SYWH08 and SZZW16 to obtain the corresponding success rates. The simulation results for these three algorithms are shown in Table 2.
According to Table 2, the success rate of our algorithm is 100% for all network sizes. This result is reasonable because in the theoretical analysis (Section 4), for any 2 edge-connected network graphs, we strictly prove that our algorithm must output a -ECDS. Table 2 also shows that the success rates of SYWH08 and SZZW16 are less than 100%, which is reasonable for the following reasons. On the one hand, when SYWH08 (SZZW16) runs in a network that is not 2 connected, it fails to generate a -2ECDS. On the other hand, the network graphs in the simulation experiments are 2 edge-connected but not necessarily 2 connected graphs (according to the definitions of a 2 edge-connected graph and 2 connected graph, a 2 connected graph must be a 2 edge-connected graph, but the inverse is not true). Moreover, Table 2 indicates that when the network size decreases, the number of candidate networks in which SYWH08 and SZZW16 fail to output an expected -ECDS becomes larger. It is natural because when the network size decreases or the number of nodes deployed randomly in a given area decreases, the density of the network becomes sparser, which increases the probability that cut nodes exist in the network. Consequently, the probability that this network graph is not a 2 connected graph increases.
5.4. Comparison of the Network Lifetime
In this subsection, we compare SYWH08, SZZW16, and LLZ20 in terms of the network lifetime. Note that for each of these algorithms, the first step requires the employment of other algorithms to generate a -CDS. Therefore, to objectively compare the network lifetime performance of these three algorithms, we utilize the -CDS generated by the algorithm proposed in [49], which is an approximation algorithm with favorable performance in terms of the network lifetime, as the CDS generated in the first step. For the experimental setup, we choose a virtual space with a experimental area. We let the transmission radius of each node to be 25 m (or 35 m) and set the network size to . Similar to Subsection 4.1, 100 candidate networks are generated for this simulation experiment.
For convenience, we use the model proposed in [50] as the energy consumption model for our simulation. The energy consumption model mainly includes the following features: (1) the energy consumption for sending a packet is , (2) the energy consumption for receiving a packet is , and (3) the energy consumption in the idle listening state is . The definitions of the notations , , , and are given in Table 1. The energy consumption for constructing or reconstructing a CDS for these three algorithms is ignored.
To measure the performance of an algorithm in terms of the network lifetime, we need to introduce an index, called the number of and denoted by , which is defined as follows. Based on the above energy consumption model, for the algorithm of interest, the following actions are considered to constitute one : a sender and receiver are randomly selected, and successfully sends packets to via the shortest path in the CDS generated by the algorithm under the condition that whole network contains no nodes with an energy of 0. To compute , some additional assumptions are needed, as follows: (1) the initial energy of every node in the network is 1 J; (2) all nodes in the CDS are in the idle listening state; (3) the nodes outside the CDS are in the sleeping state, so their energy consumption is ignored; (4) each packet is 256 bytes; (5) all nodes on this shortest path in the CDS (except and ) both receive and transmit these packets; (6) for each node on this shortest path in the CDS, its neighbors outside the shortest path only receive these packets and do not forward them to their neighbors; and (7) a new CDS needs to be generated by the algorithm once the residual energy of any node in the CDS is reduced to 50%.
We take the average number of for 100 networks as the simulation result for each algorithm, and the simulation results are shown in Figure 12.
(a) Transmission range
(b) Transmission range
Figure 12 shows that the performance of our algorithm LLZ20 is much better than that of SZZW16 or SYWH08 in terms of the network lifetime. Specifically, the number of (network lifetime) under SZZW16 or SYWH08 is 360 fewer than that under LLZ20 for all network sizes. This result is reasonable because when a new CDS is constructed, LLZ20 uses the greedy strategy based on the remaining node energy to select the nodes to constitute its CDS, while both SZZW16 and SYWH08 use other strategies to select the nodes for their CDSs; this implies that compared with LLZ20, SZZW16 (or SYWH08) has a higher probability of selecting some nodes selected in previous rounds to perform message routing in the current round, which, in turn, implies that the number of under LLZ20 may be greater than that under SZZW16 (SYWH08).
Moreover, it can be observed that for LLZ20, the network lifetime increases as the network size increases. This is also reasonable. In the process of reconstructing a CDS via a greedy strategy based on energy, as the network size increases, the number of nodes with high residual energy available to form a CDS also increases. This means that compared with those in a smaller network, the new CDS nodes in a larger network will have higher residual energy after the same number of rounds. In contrast, from Figure 12, we can see that for SZZW16 or SYWH08, the network lifetime changes little with increasing network size. This is easily understood. Because some of the nodes chosen to form a new CDS during CDS reconstruction are selected in ways other than an energy-based greedy strategy in these two algorithms, this implies that there is a higher probability that nodes selected in previous rounds will be selected for message routing in the current round. In other words, in these two algorithms, it is expected that some nodes will be repeatedly selected to form different CDSs regardless of the network size, and the residual energy of these nodes will heavily impacts the lifetime of the whole network.
6. Conclusion
In this paper, to address the problem of the edge fault tolerance of VBs in WSNs, we introduced the concept of the -ECDS, a kind of CDS with edge fault tolerance, and proposed an effective algorithm for computing a -ECDS in a 2 edge-connected network graph. The proposed algorithm is proven to be an approximation algorithm with a performance ratio of . By means of simulations, we compared the performance of our algorithm with that of existing related algorithms in terms of CDS size, algorithm running time, and algorithm success rate; the simulation results show that our algorithm is more suitable than the existing related algorithms for constructing a CDS with edge tolerance. In recent years, how to improve the energy efficiency of networks has been investigated in several studies [39, 51]. In our future work, we will investigate the construction of VBs by considering edge fault tolerance and energy efficiency in heterogeneous WSNs and develop new algorithms for constructing -ECDSs for any and with in homogeneous WSNs.
Data Availability
The data used to support the findings of this study are included within the article.
Conflicts of Interest
The authors declare that there is no conflict of interest regarding the publication of this paper.
Acknowledgments
This work was supported in part by the National Natural Science Foundation of China under grant no. 61862003 and in part by the Natural Science Foundation of Guangxi Zhuang Autonomous Region of China under grant no. 2018GXNSFDA281052.