Fixed-Parameter Tractable Submodular Maximization over a Matroid
Abstract
In this paper, we design fixed-parameter tractable (FPT) algorithms for (non-monotone) submodular maximization subject to a matroid constraint, where the matroid rank is treated as a fixed parameter that is independent of the total number of elements . We provide two FPT algorithms: one for the offline setting and another for the random-order streaming setting. Our streaming algorithm achieves a approximation using memory, while our offline algorithm obtains a approximation with runtime and memory. Both approximation factors are near-optimal in their respective settings, given existing hardness results. In particular, our offline algorithm demonstrates that – unlike in the polynomial-time regime – there is essentially no separation between monotone and non-monotone submodular maximization under a matroid constraint in the FPT framework.
Keywords and phrases:
Submodular maximization, matroids, parameterized complexity, streaming algorithmsFunding:
Shamisa Nematollahi: Partially supported by the French Agence Nationale de la Recherche (ANR) under grant ANR-21-CE48-0016 (project COMCOPT).Copyright and License:
2012 ACM Subject Classification:
Theory of computation Design and analysis of algorithmsEditor:
Shubhangi SarafSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Submodular maximization under a matroid constraint is a fundamental problem in combinatorial optimization, where we are given111We assume that the submodular function is given by a value oracle that outputs for input , and the matroid is given by a membership oracle that answers whether for input . a submodular function and a matroid with rank , and our task is to find a set of elements that maximizes the function value . For this problem, there is a well-known gap between monotone (i.e., non-decreasing) and non-monotone submodular functions: For monotone submodular functions, the optimal polynomial-time algorithm achieves a approximation to the optimal solution [8], whereas for non-monotone submodular functions, no polynomial-time algorithm can obtain a approximation [17, 12], even for the special case of the cardinality constraint [25], where the matroid simply consists of all subsets of with size at most .
One of the most important paradigms in theoretical computer science for overcoming the limitations of polynomial-time algorithms is parameterized complexity, which treats a specific component of the problem as a parameter that is fixed at a small value. In the context of matroid-constrained submodular maximization, it is natural to assume that the matroid rank is a small parameter222For example, in data summarization [23], given a large image dataset, an algorithm needs to choose a representative subset of images that is small enough to fit the screen of our smartphones. and design fixed-parameter tractable (FPT) algorithms, i.e., algorithms with runtime , where can be any finite function.
For the special case of the cardinality constraint, [26] designed an FPT algorithm that guarantees a approximation for non-monotone submodular functions, showing a substantial advantage of FPT algorithms over polynomial-time algorithms. On the hardness side, essentially the only known query complexity lower bound that applies to FPT algorithms is from the classic work of [24]. They proved that any algorithm that achieves a better-than- approximation requires queries to the value oracle, a result that holds for both monotone and non-monotone submodular maximization with the cardinality constraint. These results seem to suggest that the gap between monotone and non-monotone submodular maximization (at least for the cardinality constraint) could be narrowed further, or perhaps even closed, in the FPT regime. This brings us to the question:
For matroid/cardinality-constrained non-monotone submodular maximization, what is the best possible approximation ratio that can be achieved by FPT algorithms333The special case of this question for the cardinality constraint was posed by [26].? Is there a separation between monotone and non-monotone submodular maximization under a matroid/cardinality constraint in the FPT framework?
In this paper, we reveal a surprising answer to this question: There is essentially no separation between monotone and non-monotone submodular maximization under a matroid constraint in the FPT regime. Specifically, we design a nearly -approximation FPT algorithm (Algorithm 3) for general (non-monotone) submodular maximization subject to a matroid constraint.
Theorem 1 (Restatement of Theorem 28).
There is an FPT algorithm that achieves a approximation for maximizing any non-negative submodular function under a matroid constraint, with runtime and memory for any .
The bedrock of our -approximation FPT algorithm is a subroutine (Subroutine 2) that can be simplified into a random-order semi-streaming algorithm (Algorithm 1), and it has significant implications for the streaming setting as well. Briefly, a random-order streaming algorithm makes a single pass over elements of in a uniformly random order. During the pass, the algorithm maintains a subset of visited elements in a memory buffer of bounded size, and it is allowed to make unlimited queries to the value oracle of the function and the membership oracle of the matroid for any subset of elements stored in its memory. In the literature, there is particular interest in streaming algorithms that use memory, which are known as semi-streaming algorithms.
Our random-order semi-streaming algorithm (Algorithm 1) achieves a nearly approximation. (We note that a nearly approximation is known to be achievable by a streaming algorithm with memory, for the more general setting of matroid intersection constraints and adversarial-order streams [15].) This matches the lower bound established by [26], which asserts that any random-order streaming algorithm exceeding approximation must use memory, even for the special case of the cardinality constraint.
Theorem 2 (Restatement of Theorem 16).
There is a random-order semi-streaming algorithm that achieves a approximation for maximizing any non-negative submodular function under a matroid constraint, using memory for any .
In comparison, the previous best random-order semi-streaming algorithm for maximizing monotone submodular functions under a matroid constraint achieves a approximation [27]. For non-monotone functions, the best known semi-streaming algorithm obtains a approximation [14], though this algorithm applies to the more restrictive adversarial-order streaming setting. We highlight that the algorithms of [27] and [14] run in polynomial time, whereas our algorithm runs in FPT time.
1.1 Overview of our approach
Deferring a more detailed exposition to the main sections, we provide an overview of our algorithms and techniques. As mentioned previously, the core of our -approximation algorithm (Algorithm 3) is Subroutine 2, which can be simplified into a -approximation semi-streaming algorithm (Algorithm 1). We call this subroutine continuous greedy filtering. It is inspired by a filtering technique developed by [26] for cardinality-constrained non-monotone submodular maximization, and a fast continuous greedy algorithm designed by [4] for matroid-constrained monotone submodular maximization.
Continuous greedy filtering
The initial phase of this subroutine maintains a fractional solution over epochs. In each epoch , the subroutine constructs an incremental sequence of integral solutions through selection steps. At each step , it samples a small subset of elements. Among the elements that can be added to , it selects the element that maximizes the marginal value relative to the current fractional solution (a “weighted average” of the integral solutions ). The integral solution is then updated to be .
In the second phase, the subroutine uses the integral solutions constructed in the first phase as a filter to select a subset of elements from . Specifically, for each element , is included in if it can be added to and its marginal value with respect to exceeds that of element , for some and . A minor detail is that the subroutine rounds the marginal values of and to the closest power of before comparing them. This detail will keep the subroutine’s memory usage nearly linear in the matroid rank .
This subroutine achieves a key property: We partition the optimal solution into two sets and . Then, the subroutine guarantees that there is a feasible subset of that is a approximation to the partial optimal solution .
-approximation: a recursive approach
Our -approximation algorithm applies the continuous greedy filtering subroutine recursively on refined instances. Specifically, after the first invocation of the subroutine on the input instance , if the value of is negligible, then by submodularity, must account for almost all the optimal value. In this case, because of the aforementioned property, our algorithm can find a -approximate solution through an exhaustive search over all subsets of . If otherwise, our algorithm enumerates all subsets of to identify (the algorithm will encounter in some iteration of the enumeration, even though it does not know what is), and then, it recursively applies the above process to a refined instance , where the matroid is obtained by contracting the original matroid by the set (see Definition 9), and the function is defined by . The high-level intuition is that, after sufficiently many recursions, we will eventually reach the first case, where the value of (the analogue of in the refined instance) is negligible.
-approximation semi-streaming algorithm: single-epoch filtering
Our random-order semi-streaming algorithm simplifies continuous greedy filtering by performing a single-epoch greedy procedure to construct an integral solution in the first fraction of the random stream, followed by a similar filtering phase in the remaining stream. The final solution is obtained by enumerating all subsets of elements selected during these two phases and choosing the best one. In the main body of the paper, we will first present this simpler algorithm and its analysis.
Comparison to [26]
Briefly, [26] first designed a -approximation random-order streaming algorithm with quadratic memory for cardinality-constrained non-monotone submodular maximization, based on the filtering technique. They then identified cases where their streaming algorithm only achieves a approximation, and introduced an offline postprocessing procedure to handle those cases and improve the approximation ratio. Their analysis of this procedure relies on a factor-revealing program to balance different cases. To better leverage this factor-revealing program, they extended their postprocessing procedure to a recursive one, which led to a -approximation FPT algorithm.
Our semi-streaming algorithm is a generalization of their streaming algorithm to the matroid constraint, with improved memory usage. Compared to their -approximation FPT algorithm, the two main novelties of our -approximation algorithm, as highlighted above, are (i) the combination of the filtering technique and the continuous greedy algorithm, which enables our subroutine to achieve the aforementioned key property under the matroid constraint, and (ii) a natural recursive procedure that applies the subroutine repeatedly to refine the problem instance. This differs significantly from the recursive procedure of [26], which is used only to postprocess an output produced once by their streaming algorithm.
1.2 Additional related work
FPT submodular maximization
The parameterized complexity of submodular maximization was first studied by [28], who provided FPT approximation schemes for maximizing -separable monotone submodular functions under the cardinality constraint, assuming that both the cardinality constraint and are fixed parameters. If the cardinality constraint is the only parameter, without further assumptions, even FPT algorithms cannot obtain a better-than- approximation for monotone submodular functions, both in terms of query complexity [24] and computational complexity under the Gap-Exponential Time Hypothesis [11, 22]. For non-monotone submodular maximization under the cardinality constraint, [26] gave a -approximation FPT algorithm, while the current best polynomial-time algorithm achieves a approximation [6], which also applies to the matroid constraint.
Streaming submodular maximization
In the random-order streaming setting, [1] designed a nearly -approximation semi-streaming algorithm for monotone submodular maximization subject to a cardinality constraint, which was later simplified by [21] to reduce the memory size. Moreover, under the cardinality constraint, [26] designed a quadratic-memory streaming algorithm that achieves a approximation and a approximation for symmetric and asymmetric submodular maximization respectively. Under the matroid constraint, [27] gave a -approximation semi-streaming algorithm for monotone submodular maximization. All these random-order streaming algorithms (and ours) also apply to the (similar but incomparable) secretary with shortlists model [1].
In the adversarial-order streaming setting, [3] designed a nearly -approximation semi-streaming algorithm for cardinality-constrained monotone submodular maximization, which was later improved by [20] to achieve a linear memory size. On the hardness side, [19] showed that any streaming algorithm for monotone submodular maximization that achieves an approximation better than under a cardinality constraint must use memory, while attaining an approximation better than under a partition matroid constraint requires memory. Later, [16] proved that any streaming algorithm achieving a better-than- approximation for cardinality-constrained monotone submodular maximization requires memory. More recently, [2] designed a nearly -approximation semi-streaming algorithm for cardinality-constrained non-monotone submodular maximization, which is also an FPT algorithm (although not explicitly stated in their paper). Furthermore, matroid-constrained submodular maximization in the adversarial-order streaming setting was first studied by [9], who provided a -approximation semi-streaming algorithm for monotone functions. This was recently improved to a approximation by [14], who also gave a approximation for non-monotone functions. Finally, we mention that [14] developed a multi-pass nearly -approximation semi-streaming algorithm for matroid-constrained monotone submodular maximization, which also builds on the continuous greedy algorithm of [4]. However, their approach is very different from ours.
2 Preliminaries
2.1 Submodular functions and matroids
We first introduce submodular functions, matroids, and their associated concepts and properties. Given a ground set and a non-negative discrete function , for any , we let denote the marginal value of with respect to , i.e., .
Definition 3 (submodular function).
A non-negative function is submodular, if it satisfies that for any and any .
For any vector , we use the notation to refer to a random set such that each element of appears in independently with probability , and we define the multi-linear extension of a submodular function as follows.
Definition 4 (multi-linear extension).
The multi-linear extension of a submodular function is given by
Moreover, for any such that , we let denote the marginal value of with respect to , i.e., .
We are interested in the problem of maximizing a non-negative submodular function subject to a matroid constraint. A matroid is a set system that satisfies certain independence structure.
Definition 5 (matroid).
A set system is a matroid444In the literature, a matroid is often represented as a pair , where is the ground set and is the family of independent sets. For simplicity, we refer to the matroid simply as throughout this paper. if the following conditions hold:
-
i.
.
-
ii.
If , then for all .
-
iii.
If and , then there exists such that .
Given a matroid, we define its rank, bases, restriction and contraction as follows.
Definition 6 (rank).
Given a matroid , the rank of is .
Definition 7 (base).
Given a matroid , we say that a set is a base of , if for all .
Definition 8 (restriction).
Given a matroid and a set , we define the restriction of to as . It is well-known that the restriction is a matroid.
Definition 9 (contraction).
Given a matroid and a set , we let denote the contraction of by , which is given by . It is well-known that the contraction is a matroid, and its membership oracle can be efficiently evaluated using the membership oracle of .
In matroid-constrained submodular maximization, an algorithm ALG is given a non-negative submodular function and a matroid , and its task is to find a feasible set that maximizes . Throughout the paper, we denote the optimal solution by , i.e., (and we reserve for the Big-O notation to avoid confusion). We say that ALG achieves an approximation with , if its solution set satisfies that , where the expectation is taken over the randomness of ALG (and the arrival order of the elements, in case ALG is a random-order streaming algorithm, which we will introduce shortly). Moreover, we assume that the matroid rank is a fixed parameter that does not depend on the total number of elements (and hence, 555If , then an FPT algorithm with runtime can simply enumerate all subsets of , and a streaming algorithm with memory can simply store all elements of , rendering the problem trivial.), and we are interested in fixed-parameter tractable (FPT) algorithms, i.e., algorithms with runtime , where can be any finite function.
2.2 Random-order streaming model
Besides the standard offline setting (where all elements in the ground set are presented to the algorithm from the outset), we are also interested in the random-order streaming setting, where elements in arrive in a uniformly random order as a data stream.
In this setting, an algorithm has a memory buffer of a limited size (which is for semi-streaming algorithms). Each time when a new element arrives, the algorithm decides how to update its memory buffer, i.e., whether to store the new element, remove some previously stored elements, or modify other stored information. At any point, the algorithm can make any number of queries to the value oracle of the submodular function and the membership oracle of the matroid, provided that the input for the query is a subset of elements stored in its memory. At the end of the stream, the algorithm outputs a subset of elements from its memory that satisfies the matroid constraint.
2.3 Other useful notions and lemmata
We use the notations and to represent the indicator vectors for any set and for any element respectively, and let denote the all-zero vector. Moreover, we define a rounding operator that will be the key to reducing the memory usage of our algorithms.
Definition 10 (rounding operator).
Given any finite non-empty set of real numbers , we use the notation to denote the rounding operator that maps any real number to its greatest lower bound in , or to the smallest number in if no lower bound exists, i.e., if , and otherwise.
Then, we present two base exchange lemmas for matroids and two sampling lemmas for non-negative submodular functions.
Lemma 11 ([18, 29]).
Given two bases and of a matroid , and a partition , there exists a partition such that and are both bases of .
Lemma 12 ([5]).
Given two bases and of a matroid , there exists a bijection such that for all , is a base of .
Lemma 13 ([13, Lemma 2.2]).
Given a non-negative submodular function and a set , if is a random subset of such that every element of appears in with probability exactly (not necessarily independently), then we have that .
Lemma 14 ([7, Lemma 2.2]).
Given a non-negative submodular function and a set , if is a random subset of such that every element of appears in with probability at most (not necessarily independently), then we have that .
Finally, we state a lemma that follows from standard rounding schemes [8, 10] for matroid-constrained submodular maximization.
Lemma 15.
Given a matroid , a submodular function , and its multi-linear extension , for any such that for all , there exists such that and .
3 A -approximation random-order streaming algorithm
In this section, we present our semi-streaming algorithm, Greedy-Filtering (Algorithm 1), which achieves a approximation using memory for any submodular function and any matroid with rank . Algorithm 1 operates in three phases.
Phase 1: Estimating the highest singleton value
Algorithm 1 first identifies the element with the highest singleton value in the initial fraction of the random stream , and sets to be times the value of this element. It treats as an upper bound on the value of the most valuable element in . If fails to upper bound this value, we can show that w.h.p., only a few of the most valuable elements contribute non-negligibly to the optimal solution. Hence, to address this, throughout the stream, Algorithm 1 also maintains a set of the top elements with highest singleton values among the elements that have appeared.
Phase 2: Greedily constructing a solution set
Then, Algorithm 1 divides the second fraction of the stream into windows of equal sizes, and greedily constructs a feasible solution set as follows: For each , among all elements in the -th window that can be added to the current solution set without violating the matroid constraint, Algorithm 1 identifies the element with the highest marginal value with respect to , and updates . If no element in can be added to without violating the matroid constraint (or all elements in that can be added have negative marginal values with respect to ), the algorithm sets to be , which acts as a dummy element with zero marginal value with respect to .
Phase 3: Filtering the remaining stream
Algorithm 1 filters elements in the rest of the stream, keeping only a subset of them: For each remaining element , Algorithm 1 adds element to if, for some , element has a strictly higher marginal value with respect to solution set than element . Notably, when comparing the marginal values of and , Algorithm 1 first applies the rounding operator defined in Definition 10 with respect to a set of geometrically increasing numbers, upper bounded by . As we will show in the analysis, this coarse comparison of marginal values, based on the rounding operator, is crucial for the algorithm to achieve approximation while keeping the memory cost nearly linear in the matroid rank w.h.p. In the algorithm, we also set a hard memory limit at Line 17.
Finally, Algorithm 1 finds the most valuable subset of that satisfies the matroid constraint through an exhaustive search and returns it as the final solution. The approximation guarantee of Algorithm 1, along with its memory cost, is formally stated in Theorem 16.
Theorem 16.
Given any input submodular function , matroid with rank , and parameter , Algorithm 1 achieves a approximation using memory, where .
The memory bound follows from a simple calculation: Throughout the data stream, Algorithm 1 only needs to maintain three sets of elements (note that it can infer from ). By the construction of and , we have that and . Moreover, the break condition at Line 17 of Algorithm 1 ensures that , since . Hence, the total memory cost is .
Next, we prove the approximation guarantee in three main steps: First, we show that unless (in which case we prove that the most valuable and feasible subset of is a approximation of the optimal solution), w.h.p., the value in Algorithm 1 is an upper bound on the value of the most valuable element in . Then, we show that not many elements pass the filter in the third phase of Algorithm 1, meaning that w.h.p., the break condition at Line 17 is never met. Finally, in the regular case where caps the value of the most valuable element and only a few elements pass the filter, we prove that w.h.p., the most valuable and feasible subset of is almost a approximation of the optimal solution. We implement these three steps in the following three subsections.
3.1 The simple case:
We first analyze the simple case where . We note that the set in Algorithm 1 eventually consists of the top elements in with the highest singleton values (and we will only consider this final version of in the analysis). In Lemma 17, we show that Algorithm 1 achieves a approximation in this case.
Lemma 17.
If , Algorithm 1 obtains a approximation.
The proof is provided in the full version.
Given Lemma 17, we can now focus on the cases where . Under this assumption, we show that w.h.p., the value in Algorithm 1 is an upper bound on . Specifically, we define the set (note that if there are multiple elements with the same singleton value, could be a random set because of the random stream, but is always deterministic). In Lemma 18, we show that w.h.p., at least one element of appears in the first fraction of the random stream , which implies that , assuming .
Lemma 18.
Let denote the event that there exists some element of that appears in , i.e., the first fraction of the random stream . Then, we have that . Moreover, if , then conditioned on event , it holds that .
The proof is provided in the full version.
3.2 The unlikely case:
Recall that the set in Algorithm 1 consists of elements that pass the filter in the third phase (throughout the analysis, we will only consider the final version of ). In Lemma 19, we show that w.h.p., , which implies that the break condition at Line 17 of Algorithm 1 is unlikely to be reached.
Lemma 19.
Let denote the event that . Then, .
Now we introduce several key concepts that will play important roles in the proof of Lemma 19. First, we notice that in Algorithm 1, each element chosen in the second phase acts as a selector in the third phase: for each element in the third phase of Algorithm 1, the algorithm will include in set if it satisfies the selection condition posed by , namely, if and (we say that an element is selected by the selector if it satisfies this condition). For each , we let denote the set of elements selected by among all elements appearing after the -th window in the second phase of Algorithm 1, i.e.,
| (1) |
(recall that is the set of elements in the first fraction of the stream, and for each , is the set of elements in the -th window during the second phase of Algorithm 1).
We order the selectors according to their indices: , and for each , we define
| (2) |
We say that a selector is ineffective if there is an earlier selector for some such that (otherwise we call an effective selector). In Claim 20, we show that, as the name suggests, any element that is selected by an ineffective selector would have already been selected by an earlier selector for some , which implies that .
Claim 20.
Suppose that is an ineffective selector, i.e., there exists some such that . Then, any element that satisfies the selection condition of , i.e., and , also satisfies the selection condition of , i.e., and . In particular, this implies that .
Proof.
We establish the first part of the claim by showing that implies , and implies .
First, since is a matroid and , the condition that implies the condition that .
Moreover, because is a submodular function and , it holds that , which implies that , by monotonicity of the rounding operator (Definition 10). Hence, the condition that implies that . Since we assume that , it follows that .
Next, we prove the second part of the claim: . Recall that every element appears after the -th window and satisfies the selection condition of , which implies that element also appears after the -th window (because ) and satisfies the selection condition of (because of the first part of the claim). It follows that every element belongs to . Hence, we have that , since and . Finally, follows from and .
Now observe that the set in Algorithm 1 is a subset of . Hence, to upper bound , it suffices to upper bound . If we could prove that for each , holds w.h.p., conditioned on being an effective selector, then Lemma 19 would follow immediately. Indeed, Claim 20 states that for every ineffective selector , and thus, we have that . Notice that there can be at most effective selectors because of the rounding operator (specifically, any two distinct effective selectors and must satisfy that , and there are only distinct values in the range of ). Therefore, if holds for every effective selector , then it would follow that .
However, there is a caveat to the above argument: does not always hold w.h.p., conditioned on being an effective selector. It is possible to construct instances where always holds, conditioned on being an effective selector. Fortunately, if this is the case, we can show that the probability that is an effective selector is negligible. We formalize this intuition in Lemma 21. The proof of Lemma 21 is provided in the full version.
Lemma 21.
For each , let denote the number of effective selectors among the first selectors , and let . Then, for all , we have that
| (3) |
We are ready to complete the proof of Lemma 19.
Proof of Lemma 19.
First, following the notations in Lemma 21, we upper bound the probability as follows,
| (4) |
Moreover, we notice that the total number of effective selectors is at most , because any two distinct effective selectors and must satisfy that (and there are only distinct values in the range of ). Thus, Ineq. (3.2) implies that . The proof finishes by noticing that the set in Algorithm 1 is a subset of .
3.3 The regular case: and
Now we consider the regular case where and . To analyze this case, we first establish two simple claims. Claim 22 shows that w.h.p., the value of the optimal solution does not decrease significantly, when combined with any subset of elements in a small fraction of the random stream .
Claim 22.
For any , let be a random subset of such that every element of appears in with probability at most (not necessarily independently). Then, with probability at least , it holds for all that .
Proof.
We define such that for all . Because is a non-negative submodular function, it follows that is also non-negative and submodular. Moreover, we define . Since is a subset of and each element of appears in with probability at most , it follows that each element of appears in with probability at most . Hence, by Lemma 14, we have that , which is equivalent to . By rearranging, we obtain that . Then, by applying Markov’s inequality to the random variable (note that this random variable is non-negative because ), we have that
Thus, holds with probability at least , which implies the claim.
Claim 23 bounds the error incurred by the rounding operator . The proof is provided in the full version.
Claim 23.
Given with and , for any two real numbers and , if , then we have that .
Next, we denote by the set of elements that appear in the third phase of Algorithm 1, i.e., . Recall that denotes the solution set returned by Algorithm 1, and denotes the optimal solution. In Lemma 24, we show that is almost a approximation of , conditioned on three high-probability events in the regular case.
Lemma 24.
Proof sketch.
To highlight the main idea, we make the simplifying assumption that both the set constructed in the second phase of Algorithm 1 and the optimal solution are bases of matroid . We further assume that all elements in the optimal solution arrive in the third phase of Algorithm 1 (in reality, we expect a random fraction of them to appear in the third phase, which, by Lemma 13, accounts for fraction of the optimal value in expectation).
First, we partition the optimal solution into two sets: , where and . That is, contains the optimal elements that are included in by Algorithm 1, and consists of those that are not included in (note that conditioned on the high-probability event defined in Lemma 19, these elements were not added to because they did not satisfy the filter condition at Line 14 of Algorithm 1, not because of the break condition at Line 17). By Lemma 11, we can find a partition such that and are also bases. Moreover, because both and are bases, by Lemma 12, there exists a bijection such that for all , substituting element in with element yields a new base. In particular, this implies that element could be added to set without violating the matroid constraint. Despite this, element was not selected by the selector (since otherwise it would have been included in ). Thus, it must hold that (barring the rounding error incurred by the rounding operator , which can be handled by Claim 23). Hence, we can derive that
| (By telescoping sum) | |||||
| (By submodularity) | |||||
| (Since is a bijection) | |||||
| (5) | |||||
Then, we consider the following two solution sets: and . Recall that both and are bases, and thus, they are feasible solutions. Moreover, both and are subsets of , and hence, they are candidate solutions in the final exhaustive search of Algorithm 1. Now we lower bound the sum of the solution values of and , as follows,
(By Ineq. (3.3))
(By submodularity and )
(Since )
4 Interlude: continuous greedy filtering
In this section, we present Continuous-Greedy-Filtering (Subroutine 2), a subroutine that will serve as a building block of our final -approximation offline algorithm. Subroutine 2 combines the techniques used in our streaming algorithm (Algorithm 1) with a fast continuous greedy algorithm introduced by [4]. It operates in three phases.
Phase 1: Computing the highest singleton value
Phase 2: Constructing a fractional solution using the continuous greedy algorithm
Then, Subroutine 2 uses the continuous greedy algorithm to construct a fractional solution from subsampled sets: It runs for epochs. In each epoch , it builds a new integral solution from scratch in steps. In each step , it samples a small subset of elements . Among the elements in that can be added to the current integral solution without violating the matroid constraint, Subroutine 2 identifies the element with the highest “marginal value” (as specified at Line 11) with respect to the current fractional solution. If such an element exists and its marginal value is non-negative, Subroutine 2 includes it in the current integral solution and adds an fraction of it to the current fractional solution.
Phase 3: Filtering all elements in
Finally, Subroutine 2 filters all elements in , selecting a subset from them: For each element , it adds element to if, for some step of some epoch in the second phase, (i) element can be added to the integral solution at that step without violating the matroid constraint, and (ii) it has a strictly higher marginal value than element with respect to the fractional solution at that step (or has a strictly positive marginal value in case does not exist). Here, the marginal values are also compared after applying the rounding operator with some well-chosen discretization , in order to keep the memory usage nearly linear in the matroid rank w.h.p. In the subroutine, we also impose a hard memory limit at Line 22. At the end of Subroutine 2, it returns the set , along with the union of all the integral solutions constructed during the second phase.
Now we let denote any optimal solution, and define and (i.e., contains the optimal elements that are selected in the third phase of Subroutine 2, and consists of those that are not selected). In Theorem 25, we show that Subroutine 2 satisfies a property that is crucial for proving the approximation guarantee of our final algorithm.
Theorem 25.
To prove Theorem 25, we assume w.l.o.g. that the matroid rank is non-zero, as the statement holds trivially if (we include this edge case in Theorem 25 because our final algorithm might invoke Subroutine 2 on a matroid with rank zero). We first establish Lemma 26, which shows that w.h.p., the break condition at Line 22 of Subroutine 2 is never reached. The proof of Lemma 26 relies on techniques similar to those developed in the proof of Lemma 19, which we defer to the full version.
Lemma 26.
Let denote the event that . Then, we have that .
Then, in Lemma 27, we show that conditioned on event and another high-probability event , the fractional solution constructed in Subroutine 2 is a nearly approximation of .
Lemma 27.
We defer the proof of Lemma 27 to the full version and provide a simplified proof sketch.
Proof sketch.
To illustrate the main idea, we make the simplifying assumption that the integral solution sets constructed in Subroutine 2 for all , and the optimal solution are all bases of matroid .
Recall that the optimal solution is split into and , where contains the optimal elements that are included in by Subroutine 2, and consists of those that are not included in (note that conditioned on the high-probability event defined in Lemma 26, these elements were not added to because they did not satisfy the filter condition at Line 20 of Subroutine 2, not because of the break condition at Line 22). Given the partition , for each , we can find a partition such that and are also bases. Moreover, because both and are bases, by Lemma 12, there exists a bijection such that for all , replacing element in with element results in a new base. In particular, this implies that element could be added to set without violating the matroid constraint. Despite this, element did not satisfy the selection condition at Line 20 corresponding to (since otherwise it would have been included in ). This implies that
| (6) |
(ignoring the error incurred by the rounding operator , which can be addressed by Claim 23). Now we derive that
| (7) | |||||
| (By telescoping sum) | |||||
| (By the if condition at Line 10) | |||||
| (By Ineq. (6)) | |||||
| (By submodularity) | |||||
| (8) | |||||
By Definition 4, represents the additional value gained by increasing the probability of element appearing in the random set by , and thus, . Combining this with Ineq. (7), we obtain that
| (By submodularity) | |||||
| (By submodularity) | |||||
| (By Definition 4) | |||||
| (9) | |||||
where the last inequality follows because conditioned on event in the statement of Lemma 27, the random set (which is always a subset of in Subroutine 2) satisfies that .
Proof of Theorem 25.
We assume w.l.o.g. that the matroid rank is non-zero. First, we show that the event defined in Lemma 27 occurs w.h.p. Notice that in Subroutine 2, for any and , the probability that an element appears in the subsampled set is . By a union bound, the probability that element appears in is at most . Therefore, it follows from Claim 22 that event occurs with probability at least . Then, combining this with Lemma 26 through a union bound, the probability that both events and occur is at least . Thus, by Lemma 27, it holds with probability at least that . This implies Theorem 25 by Lemma 15, because and .
On a separate note, Subroutine 2 itself does not guarantee a better-than- approximation. This is because Subroutine 2 can be interpreted as an -memory random-order streaming algorithm (by estimating the highest singleton value as in Algorithm 1 and replacing the subsampled sets with small segments of the random stream), and the hardness result by [26] asserts that such random-order streaming algorithms cannot exceed approximation.
5 A -approximation offline algorithm
In this section, we present our final algorithm (Algorithm 3) that achieves a nearly approximation by recursively applying Continuous-Greedy-Filtering (Subroutine 2) to progressively refined instances. Specifically, Algorithm 3 performs a recursive process consisting of levels.
Initial phase
We initiate the first call to Algorithm 3 by setting , , and . We denote the optimal solution to the input instance by . At the root level , Algorithm 3 first invokes Subroutine 2 with parameter on the input instance , which returns two sets and . Then, Algorithm 3 enumerate all subsets of in the for loop at Line 9. Crucially, there will be an iteration of this loop where (all other iterations will be irrelevant to the analysis). Within this particular iteration (as well as in all other iterations), Algorithm 3 makes a recursive call to itself by setting and . These sets will be accumulated throughout the recursion.
Recursion phase
At each internal recursion level , Algorithm 3 receives the accumulated sets and from the previous levels. It first constructs a refined instance , where the matroid is the contraction of the original matroid by the accumulated set , and the non-negative submodular function is constructed by evaluating the original function on the union of the accumulated set and the input set to . We define . Next, Algorithm 3 calls Subroutine 2 with parameter on the instance , which returns two sets and . Then, Algorithm 3 enumerates all subsets of . Crucially, there will be an iteration of this loop where (all other iterations will be irrelevant to the analysis). In this particular iteration (as well as in all other iterations), Algorithm 3 makes a recursive call to itself, passing the updated accumulated sets and as arguments.
It is important to keep in mind that, in the recursion tree of Algorithm 3 (illustrated in Figure 1), there is a unique root-to-leaf path such that for each , the -th call to Algorithm 3 along the path (corresponding to the -th node in the path) is invoked by the iterate (from the for loop at Line 9) during the -th call, where . We will focus on this particular path when we prove the approximation guarantee of Algorithm 3.
Return phase
At the leaf level , Algorithm 3 first calls Subroutine 2 on a refined instance (constructed similarly to the instances in the previous levels), which returns two sets and . Then, it conducts an exhaustive search to find the most valuable subset of that belongs to matroid , and returns to the previous level. Then, at each level , among all solution sets returned by the recursive calls, Algorithm 3 identifies and returns the most valuable one to the previous level.
Time and space complexity
Now we analyze the time and space complexity of Algorithm 3 (assuming that we set , , and in the initial call). We first observe that at each level , the sets and , which are outputs of Subroutine 2 with parameter , have sizes (because is either the union of solution sets constructed in the second phase of Subroutine 2 or an empty set) and (because of the break condition at Line 22 of Subroutine 2). From this, we observe the following:
-
(i)
At each leaf node of the recursion tree of Algorithm 3, the accumulated set has size (because each set has size at most ), and the accumulated set has size (because ).
-
(ii)
Each non-leaf node of the recursion tree has at most child nodes (because each set has size ), which implies that the total number of leaves is , since the recursion tree has levels in total.
Then, we notice that the runtime of each call to Subroutine 2 at each node is , where the factor accounts for the exact computation of the multi-linear extension (which, if desired, can be replaced by polynomial-time estimation using standard Monte-Carlo sampling). Moreover, the exhaustive search step at each leaf node takes time, since . Hence, summing the runtime over all nodes, we obtain that the total runtime is . For the space complexity, we assume that Algorithm 3 traverses the recursion tree in depth-first order. We notice that at any node in any level of the recursion tree, Algorithm 3 only needs to store the sets for all from its ancestor nodes and itself, and among , the set has the largest size, which is . Therefore, the space complexity is .
Next, in Theorem 28, we show that Algorithm 3 achieves a nearly approximation. At a high level, the argument is as follows: Consider the specific path in the recursion tree of Algorithm 3, as illustrated in Figure 1, but with depth for arbitrarily small . Suppose that for all , the marginal value of the set with respect to is at least fraction of the optimal value, i.e., at least . Then, the union , which is a candidate solution in the exhaustive search step at the leaf node, must capture the entire optimal value. On the other hand, if for any , the marginal value of the set with respect to is less than fraction of the optimal value, then by submodularity, the set should account for the majority of the optimal value. We can show that (using Theorem 28) w.h.p., the union of the set and a subset of the first output of Subroutine 2 during the -th call along the path, which is a candidate solution in the exhaustive search step, is a nearly approximation to . The complete proof is provided in the full version.
Theorem 28.
Given any input submodular function , matroid with rank , and parameter such that , by setting , , and , Algorithm 3 obtains a approximation with runtime and memory.
References
- [1] Shipra Agrawal, Mohammad Shadravan, and Cliff Stein. Submodular secretary problem with shortlists. In 10th Innovations in Theoretical Computer Science Conference (ITCS 2019). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.ITCS.2019.1.
- [2] Naor Alaluf, Alina Ene, Moran Feldman, Huy L Nguyen, and Andrew Suh. An optimal streaming algorithm for submodular maximization with a cardinality constraint. Mathematics of Operations Research, 47(4), 2022. doi:10.1287/moor.2021.1224.
- [3] Ashwinkumar Badanidiyuru, Baharan Mirzasoleiman, Amin Karbasi, and Andreas Krause. Streaming submodular maximization: Massive data summarization on the fly. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, 2014. doi:10.1145/2623330.2623637.
- [4] Ashwinkumar Badanidiyuru and Jan Vondrák. Fast algorithms for maximizing submodular functions. In Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms. SIAM, 2014. doi:10.1137/1.9781611973402.110.
- [5] Richard A Brualdi. Comments on bases in dependence structures. Bulletin of the Australian Mathematical Society, 1(2), 1969. doi:10.1017/S000497270004140X.
- [6] Niv Buchbinder and Moran Feldman. Constrained submodular maximization via new bounds for dr-submodular functions. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, 2024. doi:10.1145/3618260.3649630.
- [7] Niv Buchbinder, Moran Feldman, Joseph Naor, and Roy Schwartz. Submodular maximization with cardinality constraints. In Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms. SIAM, 2014. doi:10.1137/1.9781611973402.106.
- [8] Gruia Calinescu, Chandra Chekuri, Martin Pal, and Jan Vondrák. Maximizing a monotone submodular function subject to a matroid constraint. SIAM Journal on Computing, 40(6), 2011. doi:10.1137/080733991.
- [9] Amit Chakrabarti and Sagar Kale. Submodular maximization meets streaming: matchings, matroids, and more. Mathematical Programming, 154, 2015. doi:10.1007/s10107-015-0900-7.
- [10] Chandra Chekuri, Jan Vondrák, and Rico Zenklusen. Dependent randomized rounding via exchange properties of combinatorial structures. In 2010 IEEE 51st Annual Symposium on Foundations of Computer Science. IEEE, 2010. doi:10.1109/FOCS.2010.60.
- [11] Vincent Cohen-Addad, Anupam Gupta, Amit Kumar, Euiwoong Lee, and Jason Li. Tight fpt approximations for k-median and k-means. In 46th International Colloquium on Automata, Languages, and Programming (ICALP 2019). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.ICALP.2019.42.
- [12] Shahar Dobzinski and Jan Vondrák. From query complexity to computational complexity. In Proceedings of the forty-fourth annual ACM symposium on Theory of computing, 2012. doi:10.1145/2213977.2214076.
- [13] Uriel Feige, Vahab S Mirrokni, and Jan Vondrák. Maximizing non-monotone submodular functions. SIAM Journal on Computing, 40(4), 2011. doi:10.1137/090779346.
- [14] Moran Feldman, Paul Liu, Ashkan Norouzi-Fard, Ola Svensson, and Rico Zenklusen. Streaming submodular maximization under matroid constraints. Mathematics of Operations Research, 2025. doi:10.1287/moor.2023.0276.
- [15] Moran Feldman, Ashkan Norouzi-Fard, Ola Svensson, and Rico Zenklusen. Submodular Maximization Subject to Matroid Intersection on the Fly. In 30th Annual European Symposium on Algorithms (ESA 2022). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ESA.2022.52.
- [16] Moran Feldman, Ashkan Norouzi-Fard, Ola Svensson, and Rico Zenklusen. The one-way communication complexity of submodular maximization with applications to streaming and robustness. Journal of the ACM, 70(4), 2023. doi:10.1145/3588564.
- [17] Shayan Oveis Gharan and Jan Vondrák. Submodular maximization by simulated annealing. In Proceedings of the twenty-second annual ACM-SIAM symposium on Discrete Algorithms. SIAM, 2011. doi:10.1137/1.9781611973082.83.
- [18] Curtis Greene. A multiple exchange property for bases. Proceedings of the American Mathematical Society, 39(1), 1973. doi:10.1090/S0002-9939-1973-0311494-8.
- [19] Chien Chung Huang, Naonori Kakimura, Simon Mauras, and Yuichi Yoshida. Approximability of monotone submodular function maximization under cardinality and matroid constraints in the streaming model. SIAM Journal on Discrete Mathematics, 2022. doi:10.1137/20M1357317.
- [20] Ehsan Kazemi, Marko Mitrovic, Morteza Zadimoghaddam, Silvio Lattanzi, and Amin Karbasi. Submodular streaming in all its glory: Tight approximation, minimum memory and low adaptive complexity. In International Conference on Machine Learning. PMLR, 2019. URL: https://proceedings.mlr.press/v97/kazemi19a.html.
- [21] Paul Liu, Aviad Rubinstein, Jan Vondrák, and Junyao Zhao. Cardinality constrained submodular maximization for random streams. Advances in Neural Information Processing Systems, 34, 2021. URL: https://proceedings.neurips.cc/paper_files/paper/2021/file/333222170ab9edca4785c39f55221fe7-Paper.pdf.
- [22] Pasin Manurangsi. Tight running time lower bounds for strong inapproximability of maximum k-coverage, unique set cover and related problems (via t-wise agreement testing theorem). In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms. SIAM, 2020. doi:10.1137/1.9781611975994.5.
- [23] Baharan Mirzasoleiman, Stefanie Jegelka, and Andreas Krause. Streaming non-monotone submodular maximization: Personalized video summarization on the fly. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018. doi:10.1609/aaai.v32i1.11529.
- [24] George L Nemhauser and Laurence A Wolsey. Best algorithms for approximating the maximum of a submodular set function. Mathematics of operations research, 3(3), 1978. doi:10.1287/moor.3.3.177.
- [25] Benjamin Qi. On maximizing sums of non-monotone submodular and linear functions. Algorithmica, 86(4), 2024. doi:10.1007/s00453-023-01183-3.
- [26] Aviad Rubinstein and Junyao Zhao. Maximizing non-monotone submodular functions over small subsets: Beyond 1/2-approximation. In 49th International Colloquium on Automata, Languages, and Programming (ICALP 2022). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ICALP.2022.106.
- [27] Mohammad Shadravan. Improved submodular secretary problem with shortlists. arXiv preprint arXiv:2010.01901, 2020. arXiv:2010.01901.
- [28] Piotr Skowron. FPT approximation schemes for maximizing submodular functions. Information and Computation, 257, 2017. doi:10.1016/j.ic.2017.10.002.
- [29] Douglas R Woodall. An exchange theorem for bases of matroids. Journal of Combinatorial Theory, Series B, 16(3), 1974. doi:10.1016/0095-8956(74)90067-7.
