Approximation Algorithms for Fragmenting a Graph Against a Stochastically-Located Threat

Abstract

Motivated by issues in allocating limited preventative resources to protect a landscape against the spread of a wildfire from a stochastic ignition point, we give approximation algorithms for a new family of stochastic optimization problems. We study several models in which we are given a graph with edge costs and node values, a budget, and a probabilistic distribution over ignition nodes: the goal is to find a budget-limited set of edges whose removal protects the largest expected value from being reachable from a stochastic ignition node. In particular, 2-stage stochastic models capture the tradeoffs between preventative treatment and real-time response. The resulting stochastic cut problems are interesting in their own right, and capture a number of related interdiction problems, both in the domain of computational sustainability, and beyond. In trees, even the deterministic problem is (weakly) NP hard: we give a Polynomial-time approximation scheme for the single-stage stochastic case in trees when the number of scenarios is constant. For the 2-stage stochastic model in trees we give a $(1-\frac {1}{e})<(1-(1-1/2\delta )^{2\delta })$-approximation in trees which violates the budget by a factor of at most 2 (δ is the tree diameter), and a 0.387-approximation that is budget-balanced. For the single-stage stochastic case in trees we can save (1− (1 − 1/δ)^δ) OPT without violating the budget. Single-stage results extend to general graphs with an additional O(log n) loss in budget-balancedness. Multistage results have a similar extension when the number of scenarios is constant. In an extension of the single-stage model where both ignition and spread are stochastic we give a $(1-\frac {1}{e})$-approximation in trees. Our approximation guarantees in trees also hold for multistage and probabilistic-element-failure generalizations of the Maximum Coverage with Knapsack Constraint problem (MCKP).

A Appendix

1.1 A.1 A direct FPTAS following the classical FPTAS for Knapsack: single-stage deterministic GPP with general ignition set

Theorem 2

There exists a FPTAS in trees for the single-stage deterministic Graph Protection Problem (GPP) with a general ignition set.

Proof

Suppose that we replace the single ignition node s, by an ignition set S.

The input to the problem is a connected tree T = (V, E) with a specified ignition source set S, a non-negative value function $v: V\rightarrow \mathbb {Z}$, a non-negative cost function $c:E\rightarrow \mathbb {Z}$, and a budget B. Now the objective is to find the set of edges of cost at most B such that when the set is removed from T the value of nodes not reachable from any node in S is maximized. Notice that we can contract all edges with costs strictly greater than B since they will not be in any optimal solution.

First, break the tree into components by severing the tree at ignition nodes. That is, each component has the following property: for any node in that component, the component also contains all nodes that can be reached from that node by paths in the tree that do not contain ignition nodes except as endpoints. So ignition nodes will appear in multiple components (one appearance for each edge adjacent to the ignition node).

Now observe that in a particular component (which is itself a tree), all ignition points are leaves. We will run a Dynamic Programming method on each such component and then combine the resulting solutions using the observation that a non-ignition node v is protected in the original tree by a particular edge set exactly when v is protected in the component containing it by that edge set. Components that contain only nodes which are ignition nodes are treated separately since there is always an optimal solution that does not buy any edges in such components.

From the component Q choose an arbitrary non-ignition node to be the root r. For a pair of nodes x, y ∈ V, we will say y is below x if the shortest root to y path contains x. Further, if y is below x and is contained in an edge with x we will say that y is a child of x, The set of all children of x will be denoted χ(x). We will call the first edge on the shortest path from x to the root the parent edge of x, denoted e _x , and will refer to all edges and nodes in the component containing x in T∖e _x as being below e _x (with e _x also being weakly below e _x ).

For ease in analysis later, we describe the algorithm as having two stages: a first preprocessing stage which determines an ordering of the nodes of Q, and a main stage in which this ordering is used to run a dynamic program.

In the preprocessing stage, the algorithm finds an ordering of the nodes as follows:

• 1. Set i = 1.

• 2. Choose a non-root leaf of Q, label it node i.

• 3. Delete node i from Q.

• 4. i ← i + 1.

• 5. While Q∖r is nonempty, go to step 2.

• 6. label r as node n = |V(Q)|.

Having produced this ordering, we are ready to run the main stage of the algorithm on the original Q.

Notice that under any solution each particular node is either unsafe or safe (that is, the node is either reachable from an ignition node or not).

During the main stage of the algorithm we maintain two array entries A _s (j) and A _u (j) for j = {1,...,n = |V|} (the label j refers to a node as labeled in the preprocessing stage). Each entry A _s (j) is a list of pairs (t, w). A pair (t, w) in the list of entry A _s (j) indicates that there is a set R of edges strictly below j which has cost exactly t ≤ B, protects value exactly w weakly below j, and which is compatible with node j being safe. We say that a set of edges below node j is compatible with j being safe if the set of edges protects j from ignition from below, and j is specified to be safe.

Similarly, each entry A _u (j) is a list of pairs (t, w). A pair (t, w) in the list of entry A _u (j) indicates that there is a set R of edges below j which has cost exactly t ≤ B, protects value exactly w weakly below j, and j is specified to be unsafe.

Notice that the ordering from the preprocessing stage provides a natural ranking of the children of a node j. Also, for each node j which is not a leaf in T the algorithm maintains two separate arrays of length |χ(j)| which consist of entries g _s (j, 1), g _s (j, 2), ...., g _s (j, |χ(j)|) and of entries g _u (j, 1), g _u (j, 2), ...., g _u (j, |χ(j)|).

Each entry is a list of pairs (r, u). A pair (r, u) in the list of entry g _s (j, i) indicates that there is a set R of edges in which every edge is weakly below the parent edge of one of the first i children of node j, such that the total cost of R is exactly r ≤ B, the total value protected by R weakly below one of the first i children of j is exactly u, and which is compatible with node j being safe from ignition traveling through one of j’s first i children. We say that a set of edges below node j is compatible with j being safe (from ignition traveling through one of its first i children) if the set of edges protects j from ignitions below one of its first i children, and j is specified to be safe.

A pair (r, u) in the list of entry g _u (j, i) indicates that there is a set R of edges in which every edge is weakly below the parent edge of one of the first i children of node j, such that the total cost of R is exactly r ≤ B, the total value protected by R weakly below one of the first i children of j is exactly u, and j is specified to be unsafe.

For all types of arrays described, the lists do not contain all such pairs, but only keep track of the most efficient ones. To formalize this notion of efficiency we define the notion of one pair dominating another pair: a pair (t′,w′)dominates a pair (t, w) if t′≤t and w′ ≥ w, that is, if the set indicated by pair (t′, w′) costs at most as much and protects at least as much as the set corresponding to pair (t, w). Notice that we only compare pairs within a common array entry by this notion of domination: the status of j being safe (or unsafe) is uniform between any two pairs we shall make this comparison between.

Observe

Any set of edges which contains an edge e between two nodes of the same status (either both nodes are safe, or both nodes are unsafe) corresponds to a pair which is dominated by the pair corresponding to the set in which e has been removed.

Notice that domination is transitive. We will ensure that in any list no pair dominates another pair. This means that in any single list there can be at most one pair with cost t ≤ B, and at most one pair with value w.

Consider the original tree. Each node can either be saved by cutting B worth of edges or it can not (this can be efficiently determined by performing a mincut computation in which the node is the source and there is a super-sink that has edges to every ignition node of cost 2B). Find the largest-value single node saved by any B cost set, and call its value v ^∗. Notice that OPT is at least v ^∗ and at most n v ^∗. Thus, since all costs and values are integers, each list has length at most min(B + 1, n v ^∗ + 1). Now we are ready to give the dynamic program which constructs the lists.

If node 1 is an ignition node, set A _u (1) ← {(0, 0)}, and A _s (1) ← ∅.

If node 1 is not an ignition node, set A _u (1) ← {(0, 0)}, and A _s (1) ← {(v(1), 0)}.

For j←2 to n

If j is a leaf in Q,

  If node j is an ignition node,

    set A _u (j) ← {(0, 0)}, and A _s (1) ← ∅.

  If node j is not an ignition node,

    set A _u (j) ← {(0, 0)}, and A _s (1) ← {(v(j), 0)}.

Else

  Let y ₁ , y ₂ ,...,y _|χ(j)| correspond to the natural ordering on the labels of the children of j.

  Set $g_{s}(j,1)\leftarrow A_{s}(y_{1}) \cup$ $\{(r,u+c(e_{y_{i}})): (r,u) \in A_{u}(y_{1})\}$.

  Set $g_{u}(j,1)\leftarrow A_{u}(y_{1}) \cup$ $\{(r,u+c(e_{y_{i}})): (r,u)\in A_{s}(y_{1})\}$

    For i ← 2 to |χ(j)|

         $g_{s}(j,i)\leftarrow \{(r+t,u+w): (r,u)\in g_{s}(y_{i-1}),(t,w)\in A_{s}(y_{i}) \} \cup$

             $\{(r+t,u+w+c(e_{y_{i}})): (r,u)\in g_{s}(j, y_{i-1}),(t,w)\in A_{u}(y_{i}) \}$.

         $g_{u}(j,i)\leftarrow \{(r+t,u+w): (r,u)\in g_{u}(j,y_{i-1}),(t,w)\in A_{u}(y_{i})\}\cup$

             $\{r+t,u+w+c(e_{y_{i}}): (r,u)\in g_{u}(j,y_{i-1}),(t,w)\in A_{s}(y_{i})\}$.

        Remove all dominated pairs from g _s (j, i), as well as any pairs

            with cost >B.

        Remove all dominated pairs from g _u (j, i), as well as any pairs

            with cost >B.

    Set A _s (j)←{(r + v(j),u):(r, u)∈g _s (j, |χ(j)|)}

    Set A _u (j)←g _u (j, |χ(j)|)

    Remove any dominated pairs from A _s (j).

    Remove any dominated pairs from A _u (j).

    If j = |Q|, for each spending amount of at most B compare the pair

        from A _s (j) with the pair from A _u (j), and return the larger value

        pair for that spending level, and Stop.

This algorithm returns a list of undominated pairs for component Q in which the root node in Q may burn or not (since a particular pair in the final list returned may come from either A _s (|Q|) or A _u (|Q|). For the solution on the original tree we just consecutively merge 2 component lists at a time, deleting dominated pairs (and pairs with spending exceeding B). Once all component lists have been merged, the largest value pair that spends at most B is chosen for the full solution.

Now we prove that this algorithm produces the optimal solution. Our proof will argue about the A _s (j), and A _u (j) using strong induction on the ordered set of nodes and will require an internal lemma proved by induction about the g _s (j, i), and g _u (j, i).Claim The algorithm computes the optimal value.

Proof

Since the |Q|th node is the root, showing that A _s (|Q|), and A _u (|Q|) contain all non-dominated pairs corresponding to sets of edges in which every edge is strictly below the root is sufficient. We will prove this claim by strong induction on the ordered set of nodes (as ordered by the preprocessing step).

For the base case: by the form of the preprocessing step, the first node considered is a leaf in the tree Q. The leaf is either an ignition node or not, and either way the only two possibilities are those assigned by the algorithm.

The strong induction hypothesis is: suppose that for all nodes between the first and the (j − 1)st A _s (x) contains all non-dominated pairs corresponding to sets in which every edge in the set is strictly below the parent edge of x and in which x is safe, and A _u (x) contains all non-dominated pairs corresponding to sets in which every edge in the set is strictly below the parent edge of x, and in which x is unsafe.

We will show that the same statement holds for A _s (j) and A _u (j). First, if j is a leaf in T then the claim obviously holds.

If j is not a leaf then by our observation and our definitions it is sufficient to show that the following lemma holds:

Lemma 5

For each i in {1, 2, ...|χ(j)|}, g _s (j, i) contains all non-dominated pairs corresponding to sets in which every edge in the set is weakly below the parent edge of one of the first ith children of node j and j is safe, and g _u (j, i) contains all non-dominated pairs corresponding to sets in which every edge in the set is weakly below the parent edge of one of the first ith children of node j and j is unsafe.

Proof of Lemma:

We will prove this lemma by induction. The base case is for g _s (j, 1) and g _u (j, 1). By the form of the preprocessing ordering step: the children of j are addressed by the algorithm before j is, so by the strong induction hypothesis in our proof of the theorem, A _s (y ₁ ) contains all non-dominated pairs corresponding to sets in which every edge in the set is strictly below the parent edge of y ₁ and y ₁ is safe, and A _u (y ₁ ) contains all non-dominated pairs corresponding to sets in which every edge in the set is strictly below the parent edge of y ₁ and y ₁ is unsafe.

For g _s (j, 1), j is safe and either y ₁ is safe or not: if y ₁ is safe then only pairs that exclude the edge between them are possibly not dominated (and the algorithm includes these), if y ₁ is not safe then the edge between y ₁ and j must be purchased by any solution (and the algorithm includes all solutions that purchase this edge that are not dominated on account of a better pair existing below y _i with y _i unsafe-this is ensured by adding the parent edge of y _i to every pair in A _u (y _i )).

For g _u (j, 1), j is unsafe and either y ₁ is safe or not: if y ₁ is unsafe then only pairs that exclude the edge between them are possibly not dominated (and the algorithm includes these), if y ₁ is safe then the edge between y ₁ and j must be purchased by any solution (and the alg includes all solutions that purchase this edge that are not dominated on account of a better pair existing below y _i with y _i safe-this is ensured by adding the parent edge of y _i to every pair in A _u (y _i )). This is exactly what we need for the base case.

Now, suppose that the lemma holds for g _s (j, i − 1), g _u (j, i − 1). We want to show that it holds for g _s (j, i), g _u (j, i). This will involve analyzing a number of cases.

First, suppose that j is safe. Consider any set of edges R that has the property that all its edges are weakly below one of the first ith children of j and which is compatible with j being safe. Let (t, w) be the pair corresponding to R. We will show that some pair in g _s (j, i) dominates (t, w). First, suppose that none of the edges in R are weakly below the ith child of j. Then, by the induction hypothesis, (t, w) is dominated by some pair in g _s (j, i − 1). If this is not the case then some edges of R must be weakly below the ith child of j, call the set of these edges R′.

If y _i is safe: only pairs that exclude the edge (j, y _i ) are possibly not dominated. Consider the pair corresponding to the set R∖R′: by the induction hypothesis, it must be dominated by some pair in g _s (j, i − 1), call that pair (r, u). Consider the pair corresponding to the set R′: since R′ does not contain (j, y _i ) (unless it is dominated, in which case we’re done), by the induction hypothesis, this pair must be dominated by some pair in A _s (y _i ), call it (r′,u′). Then the pair (r + r′,u + u′) dominates (t, w) and is added by the algorithm to the g _s (j, i) list. Transitivity of domination ensures that deletion of dominated pairs from g _s (j, i) retains a pair which dominates (t, w).

If y _i is unsafe: all solutions must buy the edge (j, y _i ). Consider the pair corresponding to the set R∖R′: by the induction hypothesis, it must be dominated by some pair in g _s (j, i − 1), call that pair (r, u). Consider the pair corresponding to the set R′: since R′ contains (j, y _i ), by the induction hypothesis the pair corresponding to R′∖(j, y _i ) must be dominated by some pair in A _u (y _i ), call it (r′,u′). Then the pair $(r+r^{\prime }, u+u^{\prime }+c(e_{(y_{i})})$ dominates (t, w) and is added by the algorithm to the g _s (j, i) list. Transitivity of domination ensures that deletion of dominated pairs from g _s (j, i) retains a pair which dominates (t, w).

Now suppose that j is unsafe. Consider any set of edges R that has the property that all its edges are weakly below one of the first ith children of j and which is compatible with j being unsafe. Let (t, w) be the pair corresponding to R. We will show that some pair in g _u (j, i) dominates (t, w). First, suppose that none of the edges in R are weakly below the ith child of j. Then, by the induction hypothesis, (t, w) is dominated by some pair in g _u (j, i − 1). If this is not the case then some edges of R must be weakly below the ith child of j, call the set of these edges R′.

If y _i is unsafe: only pairs that exclude the edge (j, y _i ) are possibly not dominated. Consider the pair corresponding to the set R∖R′: by the induction hypothesis, it must be dominated by some pair in g _u (j, i − 1), call that pair (r, u). Consider the pair corresponding to the set R′: since R′ does not contain (j, y _i ) (unless it is dominated, in which case we’re done), by the induction hypothesis, this pair must be dominated by some pair in A _u (y _i ), call it (r′,u′). Then the pair (r + r′,u + u′) dominates (t, w) and is added by the algorithm to the g _u (j, i) list. Transitivity of domination ensures that deletion of dominated pairs from g _u (j, i) retains a pair which dominates (t, w).

If y _i is safe: all solutions must buy the edge (j, y _i ). Consider the pair corresponding to the set R∖R′: by the induction hypothesis, it must be dominated by some pair in g _u (j, i − 1), call that pair (r, u). Consider the pair corresponding to the set R′: since R′ contains (j, y _i ), by the induction hypothesis the pair corresponding to R′∖(j, y _i ) must be dominated by some pair in A _s (y _i ), call it (r′,u′). Then the pair $(r+r^{\prime }, u+u^{\prime }+c(e_{(y_{i})})$ dominates (t, w) and is added by the algorithm to the g _s (j, i) list. Transitivity of domination ensures that deletion of dominated pairs from g _u (j, i) retains a pair which dominates (t, w). This concludes the proof of the lemma. □

Since we have proved the lemma, the definitions of A _s (i), A _s (i), g _s (j,|χ(j)|), and g _u (j, |χ(j)|) immediately give that the lists A _s (j) and A _u (j) constructed by the algorithm contain all non-dominated pairs according to their definitions.

Thus, when we compare the largest value pair at each spending level of at most B between A _s (j) and A _u (j) we find the maximum amount of value that can be protected by that spending level in the component Q (where the root may burn or not), as desired.

Now we convert from a pseudo-polynomial time exact algorithm to a FPTAS via rounding.

We analyze the running time of the algorithm as stated. If node j is a leaf computing A _s (j) and A _u (j) takes constant time. If j is not a leaf then in the worst case it has O(n) children. Consider computing g _s (j, i), g _u (j, i) for arbitrary i in {1, 2, ..., χ(j)}: as many as O((min(B + 1, n v ^∗ + 1))²) pairs are produced which then must be sorted so that the dominated pairs can be eliminated. Thus, for each node j, computing A(j) takes at most O(n(min(B + 1, n v ^∗ + 1))² log((min(B + 1, n v ^∗ + 1))²) time, so in total the algorithm runs in O(n ² (min(B + 1, n v ^∗ + 1))² log((min(B + 1, n v ^∗ + 1))²). The running time of the algorithm as described is polynomial only if the numerical values are given in unary. If we had that min(B + 1, n v ^∗ + 1) was polynomial in the graph size we’d have the FPTAS we want.

So, suppose that we round each of the node values down to the largest multiple of μ for some μ we will specify in a moment. The value protected by a set of edges will be at most n μ less under the rounded values than it is under the true values. If we want this difference to be no more than 𝜖 O P T then observing that v ^∗≤O P T ≤ n v ^∗ (based on the v ^∗ we specified as the maximum value of a single node that can be separated from every ignition node at cost at most B) we can set n μ = 𝜖 v ^∗ so that μ = 𝜖 v ^∗/n. Now, suppose we apply that rounding scheme and solve the problem optimally with respect to the rounded values, v′(x)). Letting S denote the set of nodes our solution saves and letting O denote the set of nodes that OPT saves:

$$\begin{array}{*{20}l} \sum\limits_{x\in S}v(x)&\geq \mu \sum\limits_{x\in S}v^{\prime}(x) \geq \mu \sum\limits_{x\in O}v^{\prime}(x)\geq \sum\limits_{x\in O}v(x)-|O|\mu \geq \sum\limits_{x\in O}v(x)-n\mu \geq \sum\limits_{x\in O}v(x)-\epsilon v^{*} \\ &\geq \sum\limits_{x\in O}v(x)-\epsilon OPT= (1-\epsilon)OPT. \end{array} $$

Thus, the solution produced is a (1−𝜖)-approximation. Notice that thanks to the rounding we have that (v ^∗)′ = ⌊v ^∗/(𝜖 v ^∗/n)⌋ = ⌊n/𝜖⌋, such that $\min (B+1, n(v^{*})^{\prime }+1)= O(n^{2}(\frac {1}{\epsilon }))$, giving total running time of $O(n^{6}(\frac {1}{\epsilon })^{2} \log (n^{4}(\frac {1}{\epsilon })^{2})$. Thus we have an FPTAS. □

1.2 Theorem 8.

Theorem 8

There exists a $(1-\frac {1}{e})$ -approximation algorithm for the single-stage stochastic GPP in trees with probabilistic edge transmission (provided that each ignition set has size 1). For MCKP with probabilistic element failure: there exists a $(1-\frac {1}{e})$ -approximation algorithm.

Proof

(MKCP case): The analysis is basically identical to that for the stochastic GPP with probabilistic edge transmission. We generalize MCKP by introducing the feature that we have the option to partially buy an item: a partially bought item can still probabilistically fail to materialize (and thus fail to cover the sets that contain it). The precise statement is below.

We’ll call the elements in the MCKP problem items. The maximum coverage problem with a knapsack constraint with probabilistic item failure is: given a family F = {S _j : j ∈ J} of subsets with weights w _j of a set I = {1,2,...,n} of items where each item has an associated step function that specifies probability of failure as a function of spending level and a cost c _j , and positive integer B, choose a spending level for each item with total spending at most B so as to maximize the expected total weight of the sets in F having nontrivial intersections with the realized non-failing set of items. We say a set having non-trivial intersection with the realized set of non-failing items is covered by the realized set, so we aim to maximize the expected weight covered. The expectation is over realizations of which items fail, where each item fails with independent probability that depends according to the step function on the spending level we chose for that item. We require that the steps of each step function be specified explicitly in the input (so that there are only polynomially many steps for each item).

Notice that this probabilistic model generalizes the previous MCKP model since in the previous model we had the option to either pay 100% of the item cost to reduce the probability of failure to 0, or the option to pay 0% of the item cost to leave the probability of failure at 1.

We consider each (spending level, item) pair an element our solution can buy with cost corresponding to the spending level times the item cost (we only have elements corresponding to critical spending levels at which the failure probability instantaneously drops). Denote the total set of such elements by X. The expected weight covered is a set function over these elements (where expectation is over a realization of item failure for each item). Denote this function by E. We wish to maximize this set function by buying elements subject to a knapsack constraint. If we are able to show that this set function is submodular, [11] will immediately yield a $(1-\frac {1}{e})$-approximation that is budget-balanced (provided that we can compute in polynomial time the improvement of E when a (spending level, item) pair is added to an existing set).

To prove submodularity we will establish that the law of diminishing returns holds: for an arbitrary (spending level, item) pair denoted by a, if A ⊆ B ⊆ X, then

$$\begin{array}{*{20}l} E(A \cup a)-E(A)\geq E(B \cup a)-E(B). \end{array} $$

For this we will need some notation. Let the item of the (spending level, item) pair a be denoted by e.

The item e has a step function with levels of spending and the resulting decreasing sequence of failure probabilities over e. Let α ₁, α ₂,... denote the decreasing sequence of failure probabilities that may be achieved by the ordered set of increasing spending levels (α ₁ is achieved with no spending). So a results in some probability of failure α _i . Before a is added, A contains some set of elements which affect the failure probability of e, and B contains a superset of those elements. Thus the probability of of failure of item e is (weakly) larger for the set A than for the set B. When a is added to each set, in both cases the new probability of failure for item e is the minimum of α _i and the current probability of failure for item e. The gap when a is added is larger for A than for B. Letting ℘ _e (⋅d) denote the probability of failure for item e as a function of the set of elements:

$$\begin{array}{*{20}l} \wp_{e}(A)\geq \wp_{e}(B) \Rightarrow \wp_{e}(A)-\wp_{e}(A\cup a)\geq \wp_{e}(B)-\wp_{e}(B \cup a) \end{array} $$

Next, focus on a particular subset S _j from our family. Either S _j does not contain e (in which case the addition of e leaves the expected coverage of S _j unchanged) or it does. For the later case, the probability of every one of the other items in S _j failing (excepting e) is at least for A what it is for B. Let P(A) denote the probability that every one of the items in S _j fails under A, and let P(B)denote the probability that every one of the items in S _j fails under B. Then

$$\begin{array}{*{20}l} P(A)\geq P(B) &\Rightarrow P(A)(\wp_{e}(A)-\wp_{e}(A\cup a))\geq P(B)(\wp_{e}(B)-\wp_{e}(B \cup a))\\ & \Rightarrow P(A)\wp_{e}(A)-P(A)\wp_{e}(A\cup a)\geq P(B)\wp_{e}(B)-P(B) \wp_{e}(B \cup a).\\ & \Rightarrow (1-P(A)\wp_{e}(A\cup a))-(1-P(A)\wp_{e}(A)) \geq (1-P(B)\wp_{e}(B\cup a))-(1-P(B)\wp_{e}(B)).\\ & \Rightarrow E(A \cup a)-E(A)\geq E(B \cup a)-E(B). \end{array} $$

The second to last line compares the changes in the probability that the set S _j is covered which result when a is added to A and when a is added to B. The final inequality follows from simply summing the change in expected covered weight over all S _j ∈ F (including those for which the addition of e caused no changes in the probability of coverage). This establishes submodularity.

Additionally, the time to compute the change in E resulting from the addition of a single element simply requires computing the product of failure for all items in S _j twice for each S _j . This takes polynomial time in the input size. Then, we are required to do this for each possible element (there are polynomially many elements). Thus, [11] gives a $(1-\frac {1}{e})$-approximation for our problem. □

Our approximation guarantee for this stochastic generalization exactly matches the asymptotic guarantee obtained in [1] for the special case in which elements cover all sets which contain them with probability 1 if we 100% buy the element, and with probability 0 if we 0% buy it.