**9. Variants of the basic algorithm**

12 Will-be-set-by-IN-TECH


(i) *C* becomes infeasible because a neighboring sensor *s*� ∈ *C* has turned off, or (ii) priority of

The transitions from *C*� are analogous to that from *C*, with the possibility of even going back

**Correctness:** We sketch a proof here that this algorithm ensures that, in each reshuffle round, all the targets are covered and the algorithm itself terminates enabling each sensor to decide

For contradiction, let us assume that in a given round a target *t* remains uncovered. This implies that either this target has no neighboring sensor within sensing range and thus network itself is dead, or else all the neighboring sensors which could have covered *t* have turned off. In the latter case, each of the sensor *s* whose *T*(*s*) contains t has made the transition from its current best cover *C* to off status. However, *s* only does that if *C* covers all its targets in *T*(*s*) and *s* ∈/ *C*. The last such sensor *s* to have turned off ensures that *C* is satisfied, which implies that all targets in *T*(*s*) including *t* are covered, a contradiction. Next, for contradiction, let us assume that the algorithm does not terminate. This implies that there exists at least one sensor *s* which is unable to decide, i.e., make a transition to either on or off status. There are

(ii) *s* is continually transitioning to the next best cover and none of them are getting satisfied,

For case (i), for each cover *C*, at least one of its sensor *s*� ∈ *C* has turned off. But the set of

(given that *s* constructs all possible covers). This leads to the contradiction, as before turning

For case (ii), each transition implies that a neighbor sensor has decided its on/off status, thereby making some of the covers at *s* infeasible and increasingly satisfying portions of some other covers, thus reducing the choices from the finite number of its covers. Eventually, when the last neighbor decides, *s* will be able to decide as well becoming on if any target in *T*(*s*) is

For case (iii), the possibility that all sensors are stuck at their best initial covers is conventionally broken by a sensor *s* ∈ *C* with least id in its current best cover *C* pro actively becoming on, even though *C* may not be completely satisfied. This is similar to the start-up problem faced by others distributed algorithms such as DEEPS with similar deadlock breaking solutions. At a later stage, if *s* is stuck at *C*, it means that either all its neighbors have decided or one or more neighbors are all stuck. In the former case, there exists a cover *C* at *s* which will be satisfied with *s* becoming on (case i). The latter case is again resolved by the start-up

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

), that none of the cover sets at s are able to

} would have formed part of a cover at *s* covering *t*

). Since *s* itself can cover

*C* is now lower because a sensor *s*� ∈/ *C* has turned on causing another cover *C*�

degree and lifetime as *C*, with fewer sensors remaining to be turned on.

three possibilities: (i) all the covers of *s* have become infeasible, or

) is covered.

deadlock breaking rule by either *s* or *s*� pro actively becoming on.

targets considered by sensor *s* is no larger than *T*� =

*T*(*s*), there exist a target *t* ∈ *T*� − *T*(*s*), from *T*(*s*�

cover. This implies that *s*� is off, else {*s*,*s*�

: Sensor *s* transitions to the next best priority cover *C*�

, if

, with same


and reach on/off status.

(iii) *s* is stuck at a cover *C*.

off, *s*� ensures that *t* ∈ *T*(*s*�

still uncovered, else going off.

to *C*.

or

We briefly discussed some of the properties of the LD graph earlier. For example, an edge *e* connecting two covers *C* and *C*� yields an upper bound on the cumulative lifetime of both the covers. However, if *w*(*e*), which equals *b*(*s*) for weakest sensor *s* ∈ *e*, is larger than the sum of the lifetimes of *C* and *C*� , then the edge *e* no longer constrains the usage of *C* and *C*� . Therefore, even though *C* and *C*� are connected, they do not influence each other's lifetimes. This leads to our first variant algorithm.

*Variant 1*: Redefine the edge weight e as follows:

If *mins*∈*eb*(*s*) *< lt*(*C*) + *lt*(*C*� ), then *w*(*e*) = *mins*∈*eb*(*s*), else *w*(*e*) = 0.

Thus, when calculating the degree of a cover, this edge would not be counted when not constraining, thus elevating the cover's priority. Next, the basic framework is exploiting the degree of a cover to heuristically estimate how much it impacts other covers, and the overall intent is to minimize its impact. Therefore, we sum the edge weights emanating from a cover for its degree. However, if a cover *C* is connected to two covers *C*� and *C*�� such that both *C*� and *C*�� have the same bottleneck sensor *s*, *s* is depleted by burning either *C*� or *C*��. That is, in a sense, only one of *C*� and *C*�� can really be burned completely, and then the other is rendered unusable because *s* is completely depleted. Therefore, for all practical purposes, *C*� and *C*�� can be collectively seen as one cover. As such, the two edges connecting *C* to *C*� and *C*�� can be thought of as one as well. This yields our second variant algorithm.

*Variant 2*: Redefine the degree of a cover *C* in the LD graph as follows. Let a cover *C* be connected to a set of covers *V*� = *C*1, *C*2, , *Cq* in graph *G*. If there are two covers *Ci* and *Cj* in *V*� sharing a bottleneck sensor *s*, then if *w*(*C*, *Ci*) *< w*(*C*, *Cj*) then *V*� = *V*� − *Cj* else *V*� = *V*� − *Ci*. With this reduced set of neighboring covers *V*� , the degree of cover *C* is

### *<sup>d</sup>*(*C*) = <sup>∑</sup>*C*�∈*V*� *<sup>w</sup>*(*C*, *<sup>C</sup>*� )

In the basic algorithm, each sensors constructs cover sets using its one-hop neighbors to cover its direct targets *T*(*s*). However, with the same message overheads and slightly increased time complexity, a sensor can also consider its neighbors' targets. This will enable it to explore the constraint space of its neighbors as well.

*Variant 3*: In this variant, each sensor *s* constructs LD graph over one-hop neighbors *N*(*s*, 1) and targets in *<sup>s</sup>*�∈*N*(*s*,1) *<sup>T</sup>*(*s*� ).

*Variant 4*: In the basic two-hop algorithm, each sensor *s* constructs LD graph over two-hop neighbors *N*(*s*, 2) and targets in *<sup>s</sup>*�∈*N*(*s*,1) *<sup>T</sup>*(*s*� ). In this variant, each sensor *s* constructs LD graph over two-hop neighbors *N*(*s*, 2) and targets in *<sup>s</sup>*�∈*N*(*s*,2) *<sup>T</sup>*(*s*� ).
