Cardinality constrained submodular maximization for random streams
Year: 2021

Abstract:
We consider the problem of maximizing submodular functions in single-pass streaming and secretaries-with-shortlists models, both with random arrival order. For cardinality constrained monotone functions, Agrawal, Shadravan, and Stein [ASS19] gave a single-pass (1 − 1/e − ε)-approximation algorithm using only linear memory, but their exponential dependence on ε makes it impractical even for ε = 0.1. We simplify both the algorithm and the analysis, obtaining an exponential improvement in the ε-dependence (in particular, O(k/ε) memory). Extending these techniques, we also give a simple (1/e − ε)-approximation for non-monotone functions in O(k/ε) memory. For the monotone case, we also give a corresponding unconditional hardness barrier of 1 − 1/e + ε for single-pass algorithms in randomly ordered streams, even assuming unlimited computation. Finally, we show that the algorithms are simple to implement and work well on real world datasets.

text: We consider the problem of maximizing submodular functions in single-pass streaming and secretaries-with-shortlists models, both with random arrival order. For cardinality constrained monotone functions, Agrawal, Shadravan, and Stein [ASS19] gave a single-pass (1 − 1/e − ε)-approximation algorithm using only linear memory, but their exponential dependence on ε makes it impractical even for ε = 0.1. We simplify both the algorithm and the analysis, obtaining an exponential improvement in the ε-dependence (in particular, O(k/ε) memory). Extending these techniques, we also give a simple (1/e − ε)-approximation for non-monotone functions in O(k/ε) memory. For the monotone case, we also give a corresponding unconditional hardness barrier of 1 − 1/e + ε for single-pass algorithms in randomly ordered streams, even assuming unlimited computation.
Finally, we show that the algorithms are simple to implement and work well on real world datasets.

heading: 1 Introduction
text: Over the past few decades, submodularity has become recognized as a useful property occurring in a wide variety of discrete optimization problems. Submodular functions model the property of diminishing returns, whereby the gain in a utility function decreases as the set of items considered increases. This property occurs naturally in machine learning, information retrieval, and influence maximization, to name a few (see [IKBA20] and the references within).
In many settings, the data is not available in a random-access model; either for external reasons (customers arriving online) or because of the massive amount of data. When the data becomes too big to store in memory, we look for streaming algorithms that pass (once) through the data, and efficiently decide for each element whether to discard it or keep it in a small buffer in memory.
In this work, we consider algorithms that process elements arriving in a random order. Note that the classical greedy algorithm which iteratively adds the best element [NWF78] cannot be used here, and hence we must look for new algorithmic techniques. The motivation for considering random element arrival comes from the prevalence of submodularity in big-data applications, in which data is often logged in batches that can be modelled as random samples from an underlying
35th Conference on Neural Information Processing Systems (NeurIPS 2021).
distribution.1 The problem of streaming submodular maximization has recently received significant attention both for random arrival order and the more pessimistic worst-case order arrival [ASS19, AEF+20, AF19, BMKK14, BV14, CGQ15, FKK18, FNSZ20, HKMY20, IV19, KMZ+19, MV19, NTM+18, HTW20, Sha20].

heading: 1.1 Submodular functions and the streaming model
text: Let f : 2E → R+ be a non-negative set function satisfying f(S∪{e})−f(S) ≥ f(T ∪{e})−f(T ) for all S ⊆ T ⊆ E\{e}. Such a function is called submodular. For simplicity, we assume f(∅) = 0.2 We use the shorthand f(e|S) := f(S ∪ {e})− f(S) to denote the marginal of e on top of S. When f(S) ≤ f(T ) for all S ⊆ T , f is called monotone. We consider the following optimization problem:
OPT := max |S|≤k f(S)
where k is a cardinality constraint for the solution size.
Our focus on submodular maximization in the streaming setting. In this setting, an algorithm is given a single pass over a dataset in a streaming fashion, where the stream is a some permutation of the input dataset and each element is seen once. The stream is in random order when the permutation is uniformly random. When there are no constraints on the stream order, we call the stream adversarial.
At each step of the stream, our algorithm is allowed to maintain a buffer of input elements. When a new element is streamed in, the algorithm can choose to add the element to its buffer. To be as general as possible, we assume an oracle model — that is, we assume there is an oracle that returns the value of f(S) for any set S. The decision of the algorithm to add an element is based only on queries to the oracle on subsets of the buffer elements. The algorithm may also choose to throw away buffered elements at any given time. The goal in the streaming model is to minimize memory use, and the complexity of the algorithm is the maximum number of input elements the algorithm stores in the buffer at any given time.
For the oracle model, an important distinction is between weak oracle access or and strong oracle access. In the weak oracle setting, the algorithm is only allowed to query sets of feasible elements (sets that have cardinality less than k). In the strong oracle setting however, the algorithm is allowed to query any set of elements. All our results apply to both the weak and strong oracle models.
Our aim will be to develop algorithms that only make one pass over the data stream, using Õε(k) memory, where k is the maximum size of a solution set in I. We assume that k is small relative to n := |E|, the size of the ground set.

heading: 1.2 Our contributions
text: On the algorithmic side, we give (1−1/e−ε) and (1/e−ε) approximation for cardinality constrained monotone and non-monotone submodular maximization respectively, both using O(k/ε) memory. The monotone result has an exponential improvement in memory requirements compared to Agrawal et al. [ASS19] (in terms of the dependence on ε), while the non-monotone result is the first to appear in the random-order streaming model, and improves upon the best known polynomialtime approximations under adversarial orders [AEF+20]. The algorithms are extremely simple to implement, and perform well on real world data (see Section 5), even compared to offline greedy algorithms.
On the hardness side, we prove that a (1 − 1/e + ε)-approximation for monotone submodular maximization would require Ω(n) memory (even with unlimited queries and computational power). This improves the hardness bound of 7/8 from [ASS19].

heading: 1.3 Related work
text: Prior work on this problem has focused on both the adversarial and random-order streaming setting. Algorithmic and hardness results further depend on whether the function f is monotone or non-
1Note that the random order assumption generalizes the typical assumption of i.i.d. sampling stream elements from a known distribution, as the random order assumption applies equally well to unknown distributions.
2Submodular functions f with f(∅) > 0 only improves the approximation ratio of our algorithms.
monotone, and whether f has explicit structure (e.g. such as by presenting a set system for f in the coverage case), or accessible only via oracle queries. Table 1 describes all the relevant results.
Algorithmic results. Submodular maximization in the streaming setting was first considered by Badanidiyuru et al. [BMKK14] who gave a (1/2− )-approximation in O(k log k/ ) memory for monotone submodular functions under a cardinality constraint, using a thresholding idea with parallel enumeration of possible thresholds. This work led to a number of subsequent developments with the current best being a (1/2− )-approximation in O(k/ ) memory [KMZ+19]. It turns out that the factor of 1/2 is the best possible in the adversarial setting (with a weak oracle), but an improvement is possible in the random order model (the input is ordered by a uniformly random permutation). This was first shown by Norouzi-Fard et al. [NTM+18], who proved that the 1/2-hardness barrier for cardinality constraints can be broken, exhibiting a (1/2 + c)-approximation in O(k/ε log k) memory where c < 10−13. In a breakthrough work, Agrawal, Shadravan, and Stein [ASS19] gave a (1 − 1/e − ε)-approximation using k 2poly(1/ε) memory and running time. We note that this is arbitrarily close to the optimal factor of 1 − 1/e, but the algorithm is not practical, due to its dependence on ε (even for = 0.1, the resulting constants are astronomical).
Lower bounds. A few lower bounds are known for monotone functions in the adversarial order model: with a weak oracle, any (1/2 + )-approximation would require Ω(n/k) memory [NTM+18]. Under a strong oracle, a lower bound of Ω(n/k3) memory for any (1/2+ )-approximation algorithm was shown in a recent paper by Feldman et al. [FNSZ20]. Another recent lower bound was proved by McGregor and Vu [MV19]: a (1− 1/e+ ε)-approximation for coverage functions requires Ω(n/k2) memory (this lower bound holds for explicitly given inputs, via communication complexity; we note that this is incomparable to the computational (1− 1/e+ ε)-hardness of maximum coverage [Fei98]). For non-monotone functions, Alaluf et al. [AEF+20] proved an Ω(n) memory lower bound for the adversarial order model with unbounded computation.
In the random-order model, Agrawal et al. [ASS19] show that beating 7/8 (for monotone submodular functions) requires Ω(n) memory. In contrast, we show that same construction as McGregor and Vu [MV19] also applies to randomly ordered streams: (1− 1/e+ ε) for coverage functions requires Ω(n/k2) memory even in the random-order model.
Submodular maximization in related models. A closely related model is the secretary with shortlists model [ASS19], where an algorithm is allowed to store a shortlist of more than k items (where k is the cardinality constraint). Unlike the streaming model however, once an element goes into the shortlist, it cannot be removed. Then, after seeing the entire stream, the algorithm chooses a subset of size k from the shortlist and returns that to the user. We note that the algorithms developed in this paper apply almost without modification to the shortlists model.

heading: 1.4 Overview of our techniques
text: Main algorithmic techniques. The primary impetus for our algorithmic work was an effort to avoid the extensive enumeration involved in the algorithm of Agrawal et al. [ASS19] which leads to memory requirements exponential in poly(1/ε).
To make things concrete, let us consider the input divided into disjoint windows of consecutive elements. The windows containing actual optimal elements play a special role — let’s call them active windows — these are the windows where we make quantifiable progress. When the stream is randomly ordered, we would ideally like to have each new element sampled independently and uniformly from the input. This leads to the intuition that the optimal elements are evenly spread out through all the windows. This cannot be literally true, since conditioned on the history of the stream, some elements have already appeared and cannot appear again. However, a key idea of Agrawal et al. [ASS19] allows us to circumvent this by reinserting the elements that we have already seen and that played a role in the selection process. What needs to be proved is that elements that were not selected can still appear in the future, conditioned on the history of the algorithm; that turns out to be true, provided that our algorithm operates in a certain greedy-like manner.
To ensure progress was made regardless of the positioning of the optimal elements, previous work made use of exponentially large enumerations to essentially guess which windows the optimal elements arrive in. Where we depart from previous work is the way we build our solution. The idea is to use an evolving family of solutions which are updated in parallel, so that we obtain a quantifiable gain regardless of where the optimal elements arrived. Specifically, we grow k solutions in parallel, where solution Li has cardinality i. In each window, we attempt to extend a collection of solutions Li (for varying i) by a new element e; if e is beneficial on average to every Li in the collection, we replace each Li+1 with the new solution Li ∪ {e}. Regardless of which windows happen to be active, we will show that the average gain over our evolving collection of solutions is analogous to the greedy algorithm. This is the basis of the analysis that leads to a factor of 1− 1/e. In addition to our candidate solutions Li, we maintain a pool of elements H that our algorithm has ever included in some candidate solution. We then use H to reintroduce elements artificially back into the input; this makes it possible to assume that every input element still appears in a future window with the same probability, which is key to the probabilistic analysis leading to 1− 1/e.
Non-monotone functions. Our algorithm for non-monotone submodular functions is similar, with the caveat that here we also have to be careful about not including any element in the solution with large probability. This is an important aspect of the randomized greedy algorithm for (offline) non-monotone submodular maximization [BFNS14] which randomly includes in each step one of the top k elements in terms of marginal values. We achieve a similar property by choosing the top element from the current window and a random subset of the pool of prior elements H .
Hardness results. Our hardness instances have the following general structure: there is a special subset of k good elements, and the remaining n − k elements are bad. The good elements are indistinguishable from each other, and ditto for the bad elements. In the monotone case, any k bad elements are a (1 − 1/e)-factor worse than the optimal solution (k good elements). Suppose furthermore that for parameter r > 0, as long as we never query the function on a subset with ≥ r good elements, the good elements are indistinguishable from bad elements. The only way to collect ≥ r good elements in the memory buffer is by chance – until we’ve collected the required number of good elements, they are indistinguishable from bad elements, so the subset in the memory buffer is random. The classic work of Nemhauser and Wolsey [NW78] constructs a pathological monotone submodular function with r = Ω(k), which we use to prove that without memory Ω(n) the algorithm cannot beat 1− 1/e. McGregor and Vu [MV19] construct a simple example of a coverage function with r = 2, which we use for our Ω(n/k2) bound. For an exponential-size ground set, we extend their construction to r = 3 which translates to the improved lower bound of Ω(n/k3/2).

heading: 2 A (1− 1/e− ε)-approximation in O(k/ε) memory
text: In this section, we develop a simple algorithm for optimizing a monotone submodular function with respect to a cardinality constraint. Due to space limitations, we focus on the intuition behind the results. Full proofs can be found in the supplementary.
Our algorithm begins by randomly partitioning the stream E into αk contiguous windows of expected size n/(αk), where α > 1 is a parameter controlling the memory dependence and approximation ratio. This is done by generating a random partition according to Algorithm 1. As the algorithm progresses, it maintains k partial solutions, the `-th of which contains exactly ` elements. Within each window we process all the elements independently, and choose one candidate element e to extend the partial solutions by. We then add e to a collection of partial solutions L` at the end of the window. The range of partial solution sizes ` that we use roughly tracks the number of optimal elements we are expected to have seen so far in the stream.
Intuitively, our algorithm is guaranteed to make progress on windows that contain an element from the optimal solution O. Let us loosely call such windows active (a precise definition will be given later). Of course, the algorithm never knows which windows are active. However, the key idea of our analysis is that we are able to track the progress that our algorithm makes on active windows. Since the input stream is uniformly random, intuitively we expect to see i/α optimal elements after processing i windows. With high probability, the true number of optimal elements seen will be in the rangeR := [i/α− Õ( √ k), i/α+ Õ( √ k)]. By focusing on the average improvement over levels in R, we can show that each level ` in this range gains 1k (f(O)− f(L`−1)) in expectation, whenever a (random) optimal element arrives.
For the analysis to work, ideally we would like each arriving optimal element to be selected uniformly among all optimal elements. This is not true conditioned on the history of decisions made by the algorithm. However, we can remedy this by re-inserting elements that we have selected before and subsampling the elements in the current window, with certain probabilities. A key lemma (Lemma 2.2) shows why this works, since the elements we have never included might still appear, given the history of the algorithm. Our basic algorithm is described in Algorithm 2, with the window partitioning procedure described in Algorithm 1.
Algorithm 1 Partitioning stream E into m windows. 1: Draw |E| integers uniformly from 1, . . . ,m 2: ni ← # of integers equal to i 3: ti ← ∑ 1≤j<i ni
4: for i = 1, . . . ,m do 5: wi ← elements ti to ti + ni in E 6: return {w1, w2, . . . , wm}
Algorithm 2 MONOTONESTREAM(f,E, k, α) 1: Partition E into windows wi for i = 1, . . . , αk with Algorithm 1. 2: L0` ← ∅ for ` = 0, 1, . . . , k 3: H ← ∅ 4: for i = 1, . . . , αk do 5: Ci ← wi 6: Li` ← L i−1 ` for ` = 0, 1, . . . , k
7: Sample each e ∈ H with probability 1αk and add to a set Ri 8: Ci ← Ci ∪Ri 9: zl, zh ← max{0, bi/αc − 20α √ k log k},min{k, di/αe+ 20α √ k log k}
10: e? ← argmaxe∈Ci ∑zh `=zl
f(e|Li−1` ) 11: if ∑zh `=zl f(Li−1` ∪ {e?}) > ∑zh `=zl
f(Li−1`+1) then 12: H = H ∪ {e?} 13: Li`+1 ← L i−1 ` ∪ {e?} for all ` ∈ [zl, zh] 14: for ` = 1, 2 . . . , k do 15: if f(Li`) ≥ f(Li`+1) then 16: Li`+1 ← Li` + arg maxe∈Li`+1 f(e|L`) 17: return arg max1≤`≤k f(Lαk` )
In its most basic implementation, Algorithm 2 requires O(αk + k2) memory (to store H and Li`’s for ` = 0, . . . , k). However, there are several optimizations we can make. Algorithm 2 can be
implemented in a way that the Li`’s are not directly stored at all. To avoid storing the L i `’s, we can augment H to contain not just e?, but also the index of the window it was added in. The index of the window tells us the range of levels that e? was inserted into, so all of the Li`’s can be reconstructed from H as H contains a history of all the insertions. Thus the memory use of Algorithm 2 is the size of H at the end of the stream. Since there are αk windows and each window introduces at most 1 element to H , we have the following observation: Observation 2.1. Algorithm 2 uses at most O(αk) space and O(nα √ k log k) time.
When E is streamed in random order, our partitioning procedure (Algorithm 1) has a much simpler interpretation. (A similar lemma can be found in the appendix of Agrawal et al. [ASS19].) Lemma 2.1. Suppose E is streamed according to a permutation chosen at random and we partition E by Algorithm 1 into m windows. This is equivalent to assigning each e ∈ E to one of m different buckets uniformly and independently at random.
The algorithm’s performance and behavior depends on the ordering of E. Let us define the history of the algorithm up to the i-th window, denotedHi, to be the sequence of all solutions produced up to that point. (Note that this history is only used in the analysis.) More precisely, we define the history as follows. Definition 2.1. Let Hi denote the state of the set H maintained by the algorithm, before processing window i. We define Hi to be the set of all triples (e, `, j) such that element e ∈ Hi was added to solution L` in window j. In other words,Hi contains all of the changes that the algorithm made to its state while processing the first i windows. For convenience, sometimes we treat Hi as a set of elements and say that e ∈ Hi if e ∈ Hi.
The history Hi describes the entire memory state of the algorithm up to the end of window i − 1. In the following, we analyze the performance of the algorithm in the i-th window conditioned the historyHi. Note that different random permutations of the input may produce this history, and we average over all of them in the analysis.
The next key lemma captures the intuition that elements not selected by the algorithm so far could still appear in the future, and bounds the probability with which this happens. Lemma 2.2. Fix a history Hi−1. For any element e ∈ E \ Hi−1, and any i ≤ i′ ≤ m = αk, we have Pr (e ∈ w′i | Hi−1) ≥ 1/(αk).
Next, we define a set of active windows. In each active window, the algorithm is expected to make significant improvements to its candidate solution. The active windows will only be used in the analysis of the algorithm, and need not be computed in any way. Definition 2.2. Let O be the optimal solution. For window i, let pie be the probability that e ∈ wi given Hi−1. Define its active set Ai to be the union of Ri and the set obtained by sampling each e ∈ wi with probability 1/(αkpie). We call wi an active window if |O ∩Ai| ≥ 1 and we call O ∩Ai the active optimal elements of window i.
Note that the construction of active sets in Definition 2.2 is valid as Lemma 2.2 guarantees 1/(αkpie) ≤ 1. More importantly, the active window Ai subsamples the optimal elements so that each element appears in Ai with probability exactly 1/(αk) regardless of the historyHi−1. This allows us to tightly bound the number of active windows in the input, as we show in the next lemma. Lemma 2.3. Suppose we have streamed up to the αβ-th window of the input for some β > 0. Then expected number of active windows seen so far satisfies
Z̄αβ := expected number of active windows = β −Θ(β/α). Furthermore, the actual number of windows concentrates around Z̄αβ to within ±O (√ β log 1δ ) with probability 1− δ.
Next we analyze the expected gain in the solution after processing each active window. Let Ai+1 the event that window wi+1 is active. Lemma 2.4. Let L̄i = {zil , zil + 1, . . . , zih} where zil and zih are the values of zl and zh defined in Algorithm 2 on window i. Conditioned on a historyHi and window i+ 1 being active,∑
`∈L̄i+1
E[f(Li+1`+1)− f(L i `) | Hi,Ai+1] ≥
1
k ∑ `∈L̄i+1 (f(O)−E[f(Li`) | Hi]). (1)
Under an ideal partition, each element of O appears in a different window, with one optimal element appearing roughly once every α windows. Thus after k active windows, we expect to obtain a 1− (1− 1/k)k ≈ (1− 1/e)-approximation (as in the standard greedy analysis). Theorem 2.5. The expected value of the best solution found by the algorithm is at least(
1− 1 e −O
( 1
α + α
√ log k
k
)) OPT.
Setting α = Θ(1/ε), we have a (1− 1/e− ε− o(1))-approximation using O(k/ε) memory.

heading: 3 A (1/e− ε)-approximation for non-monotone submodular maximization
text: In this section, we show that the basic algorithm described in Algorithm 2 can be altered to give a 1/e-approximation to the cardinality constrained non-monotone case (Algorithm 3).
Algorithm 3 NONMONOTONESTREAM(f,E, k, α) 1: Partition E into windows wi for i = 1, . . . , αk with Algorithm 1. 2: L0` ← ∅ for i = 0, . . . , k 3: H ← ∅ 4: xie ← Unif(0, 1) for e ∈ E, i ∈ [αk] 5: for i = 1, . . . , αk do 6: Ci ← ∅ 7: for e ∈ window wi do 8: for j = 1, . . . , i do 9: Reconstruct Lj−1` for all ` fromHi−1
10: Aje = {r | 1 ≤ r < j, ∑zrh `=zrl f(e|Lr−1` ) < fr or xre > qre} (see line 13 for fr) 11: qje = αk−j+|Aje|+1
αk
12: if xie ≤ qie then Ci ← Ci ∪ {e} 13: fi ← ∑zih `=zil
f(e?|Li−1` ) 14: Perform lines 7 to 16 of Algorithm 2. 15: return arg max` f(Lαk` )
Algorithm 3 uses the same kind of multi-level scheme as Algorithm 2. However, Algorithm 3 further sub-samples the elements of the input so that the probability of including any element is exactly 1/(αk) lines 7–13 (coloured in orange). The sub-sampling allows us to bound the maximum probability that an element of the input is included in the solution. In particular, the sub-sampling is done by having the algorithm compute (on the fly) the conditional probability that an element e could have been selected had it appeared in the past. This gives us the ability to compute an appropriate sub-sampling probability to ensure that e does not appear in H with too high a probability. In terms of the proof, the sub-sampling allows us to perform a similar analysis to the RANDOMGREEDY algorithm of Buchbinder et al. [BFNS14].3
Since many of the main ideas are the same, we relegate the details of the analysis to the supplementary.
Implementation of Algorithm 3 For clarity of exposition, we compute xie up front in line 4. However, we can compute them on the fly in practice since each element only uses its value of xie once (lines 10 and 12). This avoids an O(nαk) memory cost associated with storing each xie. Finally, we assume that there are no ties when computing the best candidiate element in each window. Ties can be handled by any arbitrary but consistent tie-breaking procedure. Any additional information used to break the ties (for example an ordering on the elements e) must be stored alongside fi for the computation of Aje (line 10). Theorem 3.1. Algorithm 3 obtains a (1/e − ε)-approximation for maximizing a non-monotone function f with respect to a cardinality constraint in O(k/ε) memory.
3A difference here is that instead of analysing a random element of the top-k marginals, we analyse the optimal set directly.
We remark that Algorithm 3 also achieves a guarantee of 1 − 1/e − ε for the monotone case, as Lemma 2.4 and Theorem 2.5 both still apply to Algorithm 3 when f is monotone. The main difference between the two is the sub-sampling (lines 7–13), which increases the running time of the algorithm.
4 1− 1/e hardness for monotone submodular maximization
The proofs of the following propositions and lemmas may be found in the supplementary. Proposition 4.1. Fix subsets G,B of elements (denoting “good” and “bad”) such that |G| = k and |B| = n− k; let r ∈ [0, k] be some parameter. Let m denote the size of the memory buffer, and let p denote the probability that a random subset of size m contains at least r − 1 good elements. Let f : G ∪B → R be a function that satisfies the following symmetries:
• f is symmetric over good (resp. bad) elements, namely there exists f̂ such that f(S) = f̂(|S ∩G|, |S ∩B|).
• For any set S with ≤ r − 1 good elements, f does not distinguish between good and bad elements, namely for g ≤ r − 1, f̂(g, b) = f̂(0, b+ g).
Then any algorithm has expected value at most
ALG ≤ (1− pk)f̂(0, k) + pk ·OPT. (2)
We now consider a few different f ’s that satisfy the desiderata of Proposition 4.1. Lemma 4.1 (monotone submodular function [NW78]). There exists a monotone submodular f that satisfies the desiderata of Proposition 4.1 for r = 2εk, and such that:
• f̂(0, k) = 1− 1/e+O(ε).
• OPT = f(G) = 1. Lemma 4.2 (polynomial-universe coverage function [MV19]). There exists a (monotone submodular) coverage function f over a polynomial universe U that satisfies the desiderata of Proposition 4.1 for r = 2, and such that:
• f̂(0, k) = (1− 1/e+ o(1))|U |.
• OPT = f(G) = |U |. Lemma 4.3 (exponential-universe coverage function (new construction)). There exists a (monotone submodular) coverage function f over an exponential universe U that satisfies the desiderata of Proposition 4.1 for r = 3, and such that:
• f̂(0, k) = (1− 1/e+ o(1))|U |.
• OPT = f(G) = |U |.
Our main hardness result follows from the lemmas above: Theorem 4.4. Any (1− 1/e+ ε)-approximation algorithm in the random order strong oracle model must use the following memory:
• Ω(n) for a general monotone submodular function.
• Ω(n/k2) for a coverage function over a polynomial universe.
• Ω(n/k3/2) for a coverage function over an exponential universe.

heading: 5 Experimental results
text: In the following section, we give experimental results for our monotone streaming algorithm. Due to space limitations, the experiments for the non-monotone algorithm can be found in the supplementary.
Our main goal is to show that our algorithm performs well in a practical setting and is simple to implement. In fact, we show that our algorithm is on par with offline algorithms in performance, and returns competitive solutions across a variety of datasets. All experiments were performed on a 2.7 GHz dual-core Intel i7 CPU with 16 GB of RAM.
We compare the approximation ratios obtained by our algorithm with three benchmarks:
• The offline LAZYGREEDY algorithm [Min78], which is both theoretically optimal and obtains the same solution as greedy (in faster time). Note that we don’t expect to outperform it with a streaming algorithm; but as we hoped, our algorithm comes close.
• The SIEVESTREAMING algorithm of Badanidiyuru et al. [BMKK14], which is the first algorithm to appear for adversarial streaming submodular optimization.
• The SALSA algorithm of Norouzi-Fard et al. [NTM+18], which is the first “beyond 1/2” approximation algorithm for random-order streams. This algorithm runs several varients of SIEVESTREAMING in parallel with thresholds that change as the algorithm progresses through the stream. 4 for adversarial order streaming. As we would expect, our algorithm performs better on random arrival streams.
Note that in terms of memory use, our algorithm is strictly more efficient. The analysis in previous sections show that the memory is O(k/ε) (with a small constant), versus O(k log k/ε) for both SIEVESTREAMING and SALSA. Thus in the experiments below, we focus on the approximation ratio obtained by our algorithm.
4SIEVESTREAMING is also known as threshold greedy in the literature [BV14]. Note that the later SIEVESTREAMING++ algorithm of [KMZ+19] is more efficient, but for approximation ratio SIEVESTREAMING is a stronger benchmark.
Datasets Our datasets are drawn from set coverage instances from the 2003 and 2004 workshops on Frequent Itemset Mining Implementations [oDM04] and the Steiner triple instances of Beasley [Bea87]. For each data set we run the three algorithms for cardinality constraints varying from k = 1 to 20. The results of the algorithms are averaged across 10 random stream orderings. Table 2 describes the data sources. Figure 1 shows the performance of the three algorithms on each data set. All code can be found at https://github.com/where-is-paul/submodular-streaming and all datasets can be found at https://tinyurl.com/neurips-21.

heading: 6 Conclusion and Future Work
text: In this work, we have presented memory-optimal algorithms for the problem maximizing submodular functions with respect to cardinality constraints in the random order streaming model. Our algorithms achieve an optimal approximation factor of 1 − 1/e for the monotone submodular case, and an approximation factor of 1/e for the non-monotone case. In addition to theoretical guarantees, we show that the algorithm outperforms existing state-of-the-art on a variety of datasets.
We close with a few open questions that would make for interesting future work. Although our algorithm is memory-optimal, it is not runtime-optimal. In particular, the SIEVESTREAMING [BMKK14] and SALSA [NTM+18] algorithms both run in time O(n log k/ε), whereas our algorithm runs in time O(n √ k log k/ε). The non-monotone variant of our algorithm runs even slower, as it needs to perform sub-sampling operations that take at least O(α3k5/2) per stream element in its current form. Improving this runtime would greatly improve the practicality of our algorithm for extremely large cardinality constraints. Finally, there has been recent interest in examining streaming algorithms for streams under “adversarial injection” [GKRS20]. In such streams, the optimal elements of the stream are randomly ordered, while adversarial elements can be injected between the optimal elements with no constraints. Despite the seemingly large power of the adversary, the 1/2 approximation barrier can still be broken in this model. It would be interesting to see if the work in this paper can be extended to such a setting.
Acknowledgments and Disclosure of Funding
The authors are indebted to Mohammad Shadravan and Morteza Monemizadeh for their insightful discussions that no doubt improved this work. The first author is supported by a VMWare Fellowship and the Natural Sciences and Engineering Research Council of Canada. The second and fourth authors are supported by NSF CCF-1954927, and the second author is additionally supported by a David and Lucile Packard Fellowship.

Review summaries:
The paper studies the submodular maximization problem with a cardinality constraint in the random stream model where the algorithm makes a single pass over a random permutation of the elements. The main contribution of the paper is an algorithm for monotone functions with a nearly-optimal 1-1/e-eps approximation and O(k/eps) memory. The algorithm also extends to non-monotone functions via sub-sampling, giving a 1/e-eps approximation  using the same memory requirement. On the hardness side, the paper shows an unconditional hardness result showing that an approximation of 1+1/e is best possible for any single-pass random stream algorithm, even if the algorithm is allowed unbounded computation time.

This paper considers cardinality constrained submodular maximization, both monotone and non-monotone, in the random streaming setting. In the random streaming setting the universe is received in a uniformly random permutation, as opposed to the adversarial setting where the universe could be received in any order.  In the random streaming setting, better approximation guarantees are possible compared to the adversarial setting (where 1/2 is the best possible). An algorithm developed by [ASS19] was shown to give a $1-1/e-\epsilon$ guarantee for cardinality constrained monotone submodular maximization, but has memory exponential in $\epsilon$ making it impractical. This paper introduces a streaming algorithm that gives the $1-1/e-\epsilon$ needing only $O(k/\epsilon)$ memory. They also prove $1-1/e$ is the best possible. Further, they introduce a streaming algorithm for the non-monotone version of the problem that gives a $1/e$ approximation guarantee also in $O(k/\epsilon)$ memory.  The algorithms are analyzed empirically, and shown to be practical.

This work studies cardinality-constrained submodular maximization in a one-pass streaming model (with a random ordering). The main results are: - A $(1-1/e-\varepsilon)$-approximation algorithm for monotone functions that   uses $O(k/\varepsilon)$ memory, where $k$ is the cardinality constraint. - A $1/e$-approximation algorithm for non-monotone submodular functions that   also uses $O(k / \varepsilon)$ memory. - A new hardness result which shows that any   $O(1-1/e+\varepsilon)$-approximation algorithm requires $\Omega(n)$ memory.  The algorithm for monotone functions in this paper improves on the recent work of [Agrawal-Shadravan-Stein, ITCS 2019] by removing an exponential dependency on $\varepsilon$ in the space complexity. Similarly, they close the previously best-known streaming hardness gap of $7/8$ to $(1-1/e+\varepsilon)$, which was also proven in [Agrawal-Shadravan-Stein, ITCS 2019]. Lastly, the authors provide a strong set of experiments that demonstrates their streaming algorithm is very competitive with an offline greedy algorithm.

This paper studies the problem of maximizing a submodular function. For monotone submodular functions subject to a cardinality constraint, the paper gives a $(1-1/e-\epsilon)$-approximation. The space requirement is $O(k/\epsilon)$ where $k$ is the cardinality constraint. This is in contrast to a previous algorithm of Agrawal et al. which gave an algorithm with the same approximation ratio but with an exponential dependence on $\epsilon$. Hence, the new algorithm obtains an exponential improvement on the dependence on $\epsilon$. The new algorithm is also straightforward to implement. For the case of non-monotone submodular maximization subject to a cardinality constraint of size $k$, the authors gives an algorithm that achieves a $(1/e - \epsilon)$-approximation with space complexity $O(k / \epsilon)$.  The authors also prove a $(1-1/e+\epsilon)$ hardness result for monotone submodular maximization. This improves upon the previous best hardness result of $0.7$.  Finally, the authors show some experimental results and it is apparent that their algorithm performs quite well when compared to offline greedy.