**Theorem:** is an equivalence relation

14 Will-be-set-by-IN-TECH

*Variant 3*: In this variant, each sensor *s* constructs LD graph over one-hop neighbors *N*(*s*, 1)

*Variant 4*: In the basic two-hop algorithm, each sensor *s* constructs LD graph over two-hop

**10. Taming the exponential state space of the maximum lifetime sensor**

If we consider the LD graph, it is quickly obvious that even creating this graph will take exponential time since there are 2*<sup>n</sup>* cover sets to consider where, *n* is the number of sensors. However, the target coverage problem has a useful property - if the local targets for every sensor are covered, then globally, all targets are also covered. In [35], we make use of this property to look at the LD graph locally (fixed 1-2 hop neighbors), and are able to construct all the local covers for the local targets and then model their dependencies. Based on these dependencies, a sensor can then prioritize its covers and negotiate these with its neighbors. Simple heuristics based on properties of this graph were presented in [35] and showed a 10-15% improvement over comparable algorithms in the literature. [15] built on this work by examining how an optimal sequence would pick covers in the LD graph and designing heuristics that behave in a similar fashion. Though the proposed heuristics are efficient in practice, the running time is a function of the number of neighbors and the number of local targets. Both of these are relatively small for most graphs but theoretically are exponential in

A key issue that remains unresolved is the question of how to deal with this exponential space of cover sets. In this paper we present a reduction of this exponential space to a linear one based on grouping cover sets into *equivalence classes*. We use [*Ci*] to denote the equivalence class of a cover *Ci*. The partition defined by the equivalence relation on the set of all sensor covers Given a set *C* and an equivalence relation �, the equivalence class of an element *Ci* ∈ *C* is the subset of all elements in *C* which are equivalent to *Ci*. The notation used to represent the equivalence class of *Ci* is [*Ci*]. In the context of the problem being studied, *C* is the set of all sensor covers and for any single cover *Ci*, [*Ci*] represents all other covers which are *equivalent* to *Ci* as given by the definition of some equivalence relation �. Our approach stems from the understanding that from the possible exponential number of sensor covers, several covers are very similar, being only minor variations of each other. In Section 11, we present the definition of the relation �, based on a grouping that considers cover sets equivalent if their lifetime is bounded by the same sensor. We then show the use of this relation to collapse the exponential LD Graph into an *Equivalence Class* (EC) Graph with linear number of nodes. This theoretical insight allows us to design a sampling scheme that selects a subset of all local covers based on their equivalence class properties and presents this as an input to our simple LD graph degree-based heuristic. Simulation results show that class based sampling cuts the running time of these heuristics by nearly half, while only resulting in a less than 10% loss in quality.

In this section, we present our approach of dealing with the exponential solution space of possible cover sets. The next section utilizes these ideas to develop heuristics for maximizing

). In this variant, each sensor *s* constructs LD

).

*<sup>s</sup>*�∈*N*(*s*,2) *<sup>T</sup>*(*s*�

*<sup>s</sup>*�∈*N*(*s*,1) *<sup>T</sup>*(*s*�

and targets in

**cover problem**

*<sup>s</sup>*�∈*N*(*s*,1) *<sup>T</sup>*(*s*�

neighbors *N*(*s*, 2) and targets in

the number of targets and sensors.

**11. Dealing with the exponential space**

).

graph over two-hop neighbors *N*(*s*, 2) and targets in

**Proof:** is reflexive, since *Ci Ci*. is symmetric, since if *Ci Cj* then, *Cj Ci* since both covers *Ci* and *Cj* share the same bottleneck sensor. Finally, if *Ci Cj* and *Cj Ck*, then *Ci Ck* and is transitive since if *Ci* shares the same bottleneck sensor with *Cj* and *Cj* shares the same bottleneck sensor with *Ck* then, clearly both *Ci* and *Ck* have the same bottleneck sensor in common. Therefore, is and equivalence relation.

Every equivalence relation defined on a set, specifies how to partition the set into subsets such that every element of the larger set is in exactly one of the subsets. Elements that are related to each other are by definition in the same partition. Each such partition is called an *equivalence class*. Hence, the relation partitions the set of all possible sensor covers into a number of *disjoint* equivalence classes.

**Figure 4.** Example Sensor Network

*Notation:* Henceforth, we represent the equivalence class of covers sharing a bottleneck sensor *si* by [*si*]. Note that this is a slight abuse of notation since *si* is not a member of this class, but is instead the property that is common to all members of this class. Hence, [*si*] can be read as the equivalence class for all covers having sensor *si* as their bottleneck sensor.

We now define what we would call the Equivalence Class (EC) Graph. Each node of this graph represents an equivalence class. Just as the LD graph models the dependency between sensor covers, the EC Graph models the dependency between classes of covers.

*Definition 2:* Equivalence Class Graph (EC). The Equivalence Class graph *EC* = (*V* , *E* ) where, *V* is the set of all possible equivalence classes defined by and two classes [*si*] and [*sj*] are joined by an edge for every cover in each class that share some sensor in common. Hence, the graph *EC* is a multi-edge graph.

The cardinality of the vertex set of the Equivalence Class Graph is at most *n*. This result follows from the observation that for any network of *n* sensors, there can be at most one equivalence class corresponding to each sensor, since every cover can have only one of the *n* sensors as its bottleneck (in case two or more sensors all have the same battery and are the bottleneck, sensor id's can be used to break ties).

### 16 Will-be-set-by-IN-TECH 40 Wireless Sensor Networks – Technology and Protocols

To better understand these definitions, let us consider an example. Consider the sensor network shown in Figure 4. The network comprises of seven sensors, *s*1, ...,*s*<sup>7</sup> and two targets, *T*1, *T*2. Observe that *T*<sup>2</sup> is the bottleneck target for the network since it is the least covered target (8 units of total coverage compared to 33 for *T*1). Also note that only one sensor, *s*<sup>1</sup> can cover both targets.

For the given network, the set of all possible minimal sensor covers, *S* is,

$$S = \{ \{ \mathbf{s\_2}, \mathbf{s\_6} \}, \{ \mathbf{s\_2}, \mathbf{s\_7} \}, \{ \mathbf{s\_3}, \mathbf{s\_6} \}, \{ \mathbf{s\_3}, \mathbf{s\_7} \}, \{ \mathbf{s\_4}, \mathbf{s\_6} \}, \{ \mathbf{s\_4}, \mathbf{s\_7} \}, \{ \mathbf{s\_1} \} \}$$

For each individual cover in this set, the bottleneck sensor is the sensor shown in bold face.

Figure 5 shows the Lifetime Dependency graph for these covers. As defined, an edge exists between any two covers that share at least one sensor in common and the weight of this edge is given by the lifetime of the common sensor having the smallest battery (the bottleneck). For example, an edge of weight 4 exists between *C*<sup>1</sup> and *C*<sup>2</sup> because they share the sensor *s*<sup>2</sup> having a battery of 4.

**Figure 5.** LD Graph for the example network

To obtain the EC Graph from this LD Graph, we add a node to represent the equivalence class for each sensor that is a bottleneck sensor for any cover. For the above example, given all sensor covers in the set *S*, there are three sensors *s*1,*s*6,*s*<sup>7</sup> that are each the bottleneck for one or more covers in *S*. Hence, the EC Graph is a three node graph. Figure 6 shows the complete EC Graph for the covers in *S*. There is a node corresponding to the equivalence class for each of the three sensors *s*1,*s*6,*s*<sup>7</sup> and for each cover in the class we retain edges to the class corresponding to the bottleneck sensor of the cover on which the edge terminated in the LD graph. Hence, we have three edges between the nodes *s*<sup>6</sup> and *s*7.

It is key to realize that the EC graph is essentially an encapsulation of the LD Graph that can have at most *n* nodes. This view is presented in Figure 7, where we show the LD Graph that is embedded into the EC Graph. Each rectangular box shows the nodes in the LD graph that are in the same equivalence class. This figure also illustrates our next theorem.

**Figure 6.** EC Graph for the example network

16 Will-be-set-by-IN-TECH

To better understand these definitions, let us consider an example. Consider the sensor network shown in Figure 4. The network comprises of seven sensors, *s*1, ...,*s*<sup>7</sup> and two targets, *T*1, *T*2. Observe that *T*<sup>2</sup> is the bottleneck target for the network since it is the least covered target (8 units of total coverage compared to 33 for *T*1). Also note that only one sensor, *s*<sup>1</sup> can

For each individual cover in this set, the bottleneck sensor is the sensor shown in bold face. Figure 5 shows the Lifetime Dependency graph for these covers. As defined, an edge exists between any two covers that share at least one sensor in common and the weight of this edge is given by the lifetime of the common sensor having the smallest battery (the bottleneck). For example, an edge of weight 4 exists between *C*<sup>1</sup> and *C*<sup>2</sup> because they share the sensor *s*<sup>2</sup>

> C2 {S3,S7}

4

4

1

To obtain the EC Graph from this LD Graph, we add a node to represent the equivalence class for each sensor that is a bottleneck sensor for any cover. For the above example, given all sensor covers in the set *S*, there are three sensors *s*1,*s*6,*s*<sup>7</sup> that are each the bottleneck for one or more covers in *S*. Hence, the EC Graph is a three node graph. Figure 6 shows the complete EC Graph for the covers in *S*. There is a node corresponding to the equivalence class for each of the three sensors *s*1,*s*6,*s*<sup>7</sup> and for each cover in the class we retain edges to the class corresponding to the bottleneck sensor of the cover on which the edge terminated in the LD

It is key to realize that the EC graph is essentially an encapsulation of the LD Graph that can have at most *n* nodes. This view is presented in Figure 7, where we show the LD Graph that is embedded into the EC Graph. Each rectangular box shows the nodes in the LD graph that

are in the same equivalence class. This figure also illustrates our next theorem.

C5 {S3,S6}

1

C3 {S4,S7}

C6 {S4,S6}

10

C7 {S1}

For the given network, the set of all possible minimal sensor covers, *S* is,

*S* = {{*s*2, **s6**}, {*s*2, **s7**}, {*s*3, **s6**}, {*s*3, **s7**}, {*s*4, **s6**}, {*s*4, **s7**}, {**s1**}}

C1 {S2,S7}

4

1

graph. Hence, we have three edges between the nodes *s*<sup>6</sup> and *s*7.

10

C4 {S2,S6}

**Figure 5.** LD Graph for the example network

10

cover both targets.

having a battery of 4.

**Theorem:** For sensor covers in the same equivalence class, the induced subgraph on the LD Graph is a clique

**Proof:** This theorem states that for the nodes in the LD graph that belong to the same class, the induced subgraph is a clique. Since by definition, all sensor covers in a class [*s*] share the sensor *s* as their bottleneck sensor, the induced subgraph will be a complete graph between these nodes.

Also, a subtle distinction has been made between inter-class edges and intra-class edges in going from the LD graph to the EC graph.

**Figure 7.** EC Graph for the example network along with the LD Graph embedded in it

### **12. Sampling based on the equivalence class graph**

The previous section defined the concepts behind reducing the exponential space of covers in the LD Graph to the linear space of the EC Graph. In this section, we build on these concepts to discuss techniques for generating a limited number of covers for the LD Graph. Specifically, our goal is to improve the timing performance of the distributed algorithms we presented in [15, 35]. As presented, the EC Graph is not very useful since it still requires the exponential LD graph to be populated, before it can be constructed. However, by realizing that the exponential space of cover sets can be expressed in this linear space of equivalence classes, we can generate only a subset of the set of all covers.

#### 18 Will-be-set-by-IN-TECH 42 Wireless Sensor Networks – Technology and Protocols

Recall that even though the number of global sensor covers is exponential in the number of sensors, our heuristics presented in [15, 35] worked by constructing *local* covers. After exchanging one or two hop coverage information with neighboring sensors, a sensor can exhaustively construct all possible local covers. A local cover here is a sensor cover that covers all the local targets. The number of local covers is also exponential but is determined by the maximum degree of the graph and the number of local targets, typically much smaller values than the number of all sensors or targets. The heuristics then construct the LD graph over these local covers. The choice of which cover to use is determined by looking at properties of the LD graph such as the degree of each cover in the LD graph.

By making use of the idea of related covers in the same equivalence class, our goal is to use our existing heuristics from [15, 35] but to modify them to run over a subset of the local covers as opposed to all local covers. This should give considerable speedup and if the subset is selected carefully, it may only result in a slight reduction of the overall lifetime. We present such a local cover sampling scheme in Section 12.1 and then present the modified basic algorithm of [15, 35] to operate on this sample in Section 8. Finally, we evaluate the effectiveness of sampling in Section 13.
