WorksComputer Science
Nearly-Linear Query Algorithm for Submodular Maximization subject to a Matroid Constraint
Abstract
We consider monotone submodular maximization subject to a matroid constraint. The seminal continuous greedy algorithm of Calinescu, Chekuri, Pál, and Vondrák~[SICOMP'11] achieves the tight approximation of . Since then, a line of works by Badanidiyuru and Vondrák~[SODA'14], Buchbinder, Feldman, and Schwartz~[SODA'15 & MOR'17], Kobayashi and Terao~[ICALP'24], Buchbinder and Feldman~[FOCS'24 & SICOMP'25], and Buchbinder and Feldman~[STOC'25] has developed efficient -approximation algorithms for this problem. We present a combinatorial randomized -approximation algorithm that requires independence-oracle and value-oracle queries, where is the number of elements in the matroid. This is the first -approximation algorithm with both independence-oracle and value-oracle query complexities nearly-linear in and polynomial in . To achieve this, we develop a new local search algorithm, which we call protected local search, based on the potential function of Buchbinder and Feldman~[FOCS'24 & SICOMP'25].
Introduction
Submodular maximization is a fundamental and well-studied problem in theoretical computer science and combinatorial optimization. In particular, the problem of maximizing a nonnegative monotone submodular function subject to a matroid constraint is one of the most extensively investigated settings.
The study of submodular maximization was initiated by a seminal work of Fisher, Nemhauser, and Wolsey in the 1970’s [18, 11, 17]. They showed that, for monotone submodular maximization, the natural greedy algorithm achieves a -approximation for a cardinality constraint and a -approximation for a matroid constraint. They [17] also showed that, for any constant , achieving a -approximation requires exponentially many value-oracle queries, even under a cardinality constraint. Thus, the factor is optimal for a cardinality constraint.
To obtain an optimal -approximation algorithm for a matroid constraint, Calinescu, Chekuri, Pál, and Vondrák [6] developed a new framework based on continuous optimization and a rounding technique. Their algorithm first obtains a -approximate solution to the problem of maximizing the multilinear extension of , a natural continuous extension of , via the continuous greedy algorithm, and then rounds it to an integral solution via pipage rounding [1]. Consequently, their algorithm achieves the optimal -approximation. Note that, although their algorithm runs in polynomial time, its running time is very high.
Since submodular maximization has a number of applications, providing efficient approximation algorithms is a fundamental task both in theory and practice. Thus, it has received considerable attention to develop fast submodular maximization algorithms that achieve an approximation close to the optimal factor, typically with an approximation factor of .
In submodular maximization subject to a matroid constraint, it is standard to assume that the objective function is accessed through a value oracle and that the family of independent sets is accessed through an independence oracle. In this setting, the efficiency of an algorithm is usually measured by the number of queries it makes to these oracles.
Badanidiyuru and Vondrák [5] presented a fast algorithm that achieves an almost optimal approximation factor , for any , for a matroid constraint. Their algorithm uses value-oracle queries and independence-oracle queries1, where is the number of elements in the matroid and is the rank of the matroid. Their algorithm combines a fast implementation of the continuous greedy algorithm, which uses value and independence oracle queries, with the swap rounding of Chekuri, Vondrák, and Zenklusen [8], which rounds the resulting convex combination of bases using independence oracle queries.
Buchbinder, Feldman, and Schwartz [4] developed another fast implementation of the continuous greedy algorithm, which exhibits a trade-off between the numbers of value and independence oracle queries. In particular, they obtained a -approximation algorithm using value oracle queries and independence oracle queries. As in the algorithm of Badanidiyuru–Vondrák, the term in the independence query complexity is due to swap rounding.
Kobayashi and Terao [15] improved the independence query complexity of the swap rounding of Chekuri, Vondrák, and Zenklusen [8] to . Combined with the algorithm of Buchbinder, Feldman, and Schwartz, this yields a -approximation algorithm using value and independence oracle queries.
In another line of work, Filmus and Ward [12] presented the first combinatorial -approximation algorithm, which requires no rounding. Their algorithm is based on non-oblivious local search, i.e., local search guided by an auxiliary potential function instead of , which is estimated by sampling and thus makes the algorithm randomized.
All of the above -approximation algorithms for a matroid constraint are randomized. In a breakthrough work, Buchbinder and Feldman [2] presented the first deterministic -approximation algorithm, which is based on the non-oblivious local search and uses value oracle queries and independence oracle queries. With randomization, these query complexities can be reduced to and , respectively.
Subsequently, Buchbinder and Feldman [3] introduced the extended multilinear extension, which enables deterministic implementations of both the fractional maximization step and the rounding step of the continuous greedy framework. As a by-product, they obtained a randomized -approximation algorithm using value oracle queries and independence oracle queries, which is nearly-linear in when . We note that, unlike the algorithms of [5, 4, 15], the value query complexities of these algorithms depend exponentially on .
Buchbinder and Feldman [2] posed, as an open question, whether the query complexity can be further improved to be nearly-linear in for all values of , rather than only for as in [3].
Our Results
Table 1 summarizes the best known complexities of -approximation algorithms for monotone submodular maximization subject to a matroid constraint, together with our new results. We develop a new local search algorithm, which we call protected local search, based on the potential function of Buchbinder and Feldman [2]. Our main result is the following theorem.
| Reference | Value queries | Independence queries | Type |
| Calinescu, Chekuri, Pál and Vondrák [6] | R | ||
| Filmus and Ward [12] | R | ||
| Badanidiyuru and Vondrák [5] | R | ||
| Buchbinder, Feldman, and Schwartz [4] | R | ||
| Kobayashi and Terao [15] | R | ||
| Buchbinder and Feldman [2] | D | ||
| Buchbinder and Feldman [2] | R | ||
| Buchbinder and Feldman [3] | R | ||
| Theorem 2 | D | ||
| Theorem 1 | R |
Table 1. Oracle-query complexities for maximizing a nonnegative monotone submodular function subject to a general matroid constraint. Here, D and R denote deterministic and randomized algorithms, respectively. Note that the notation hides polylogarithmic factors in , and the notation additionally hides polynomial factors in .
Theorem 1. For any , there is a randomized algorithm that achieves a -approximation for maximizing a monotone submodular function subject to a matroid constraint and uses value and independence oracle queries.
This is the first -approximation algorithm with both independence-oracle and value-oracle query complexities nearly-linear in and polynomial in . In particular, this resolves the open question posed by Buchbinder and Feldman [2].
Our algorithm can also be derandomized at the cost of an exponential dependence on in the value-oracle query complexity.
Theorem 2. For any , there is a deterministic algorithm that achieves a -approximation for maximizing a monotone submodular function subject to a matroid constraint and uses value-oracle queries and independence-oracle queries.
Additional Related Work
Buchbinder and Feldman [3] also gave a deterministic algorithm that computes a value with using value-oracle and independence-oracle queries. Unlike our algorithm, however, it only estimates the optimal value and does not output a feasible solution.
Recently, faster algorithms based on the continuous greedy framework have been developed for several important classes of matroids. Specifically, -approximation algorithms using nearly-linear value-oracle queries and arithmetic operations are known for graphic and partition matroids [10] and for laminar and transversal matroids [14].
Ganz Rozenman, Kulik, Schwartz, and Singh [13] proposed a different approach based on a stochastic Poisson process, which requires neither discretization nor rounding. For partition matroids, their approach yields a -approximation algorithm using value oracle queries, which is linear in .
Preliminaries
Basic Notation. Let denote the set of non-negative real numbers. Throughout this paper, let be a finite set and let denote its cardinality. For a set and an element , we will often write and . For a positive integer , let . For a set function , a set , and an element , we write . Note that if .
We assume without loss of generality that . We say that an event happens with high probability (w.h.p.) if it happens with probability at least , where is an arbitrarily large constant that affects only the constant factors in the query complexity.
Submodular Functions. Let be a set function on a finite ground set of size . The function is submodular if for any two subsets . The function is monotone if for any subsets . In this paper, we only consider monotone submodular functions. For such a function, holds for any and ; we refer to this inequality simply as submodularity.
Matroids. A pair of a finite set and a non-empty set family is called a matroid if the following properties are satisfied.
(Downward closure property) if and , then .
(Augmentation property) if and , then there exists such that .
A set is called independent if and dependent otherwise. The rank of is defined as the size of a largest independent set. In addition, for a subset , the rank of is defined as the size of a largest independent set contained in . Inclusion-wise maximal independent sets are called bases. Note that every basis has the same size. Throughout this paper, denotes the rank of . Before running the algorithm, we remove all loops of , i.e., elements with . Hence, we assume without loss of generality that has no loops.
Problem. We consider the problem of maximizing a monotone submodular function subject to a matroid , that is, . We denote by an optimal solution.
Oracles. When we consider the submodular maximization problem, we assume that the submodular function is given as a value oracle, which takes as input any subset and outputs . We also assume that we access a matroid through an oracle. Given a subset , an independence oracle outputs whether or not.
Basic Facts on Submodular Functions
We use the following basic inequalities for submodular functions.
Fact 3 (From [2 Lemmas 2.2 and 2.3 in the journal version]). Let be a submodular function.
(a) If , then .
(b) For all , .
Binary Search Technique
Nguyen [16] and Chakrabarty, Lee, Sidford, Singla, and Wong [CLS$^{+}$19] independently presented the so-called binary search technique, which is useful for improving the query complexity of matroid problems.
Lemma 4 (Binary Search Technique [16 CLS$^{+}$19]). Let be a matroid. Let , , and . If there exists an element such that , then such an element can be found using independence oracle queries.
The idea behind Lemma 4 is to perform binary search on . We skip the proof in this paper.
The Lifted Matroid and Potential Function of Buchbinder and Feldman
In this subsection, we describe the lifted matroid and the potential function, which were used in the non-oblivious local search algorithm of Buchbinder and Feldman [2], and present some of their useful properties. Our algorithm also performs local search on this lifted matroid, guided by the same potential function, but it updates the solution in an entirely different way, as we explain in Section 3.
Throughout the rest of this paper, we set , so that and . We use the following coefficients of Buchbinder and Feldman [2]:
We also write . Here, we have (see Fact 7).
Lifted Matroid. We also use the lifted matroid construction of Buchbinder and Feldman [2]. Let . The element is called the copy of with color . We use for elements of and for elements of . For and , let
Let , where if and only if contains at most one copy of each element of and . An independence oracle query to can be answered using at most one independence oracle query to , since a set containing two copies of the same element does not belong to . Note that for every , and that for every and . The following lemma guarantees that the lifting preserves the matroid structure.
Lemma 5 (From [2 Lemma 3.5 in the journal version]). is a matroid, and it has the same rank as .
Our algorithm runs on the lifted matroid instead of : it maintains a basis of and finally outputs , which is a basis of since and .
Potential Function. We also use the potential function of Buchbinder and Feldman [2],2 which is defined for every as
The following property of was proved.
Lemma 6 (From [2 Lemma 3.4 in the journal version]). The function is non-negative, monotone, and submodular.
In the analysis, we also use the auxiliary function , defined by
Since for every and each function is monotone, we have
We use the following properties of the coefficients . Here, recall that .
Fact 7.
(a) for .
(b) For every , . We also have .
(c) .
(d) and . In particular, .
We defer the proof of Fact 7 to Appendix A.1. Next, we describe two basic properties of the potential function .
Observation 8. For and , .
Observation 9. For every , we have . For every and , we have .
We defer the proofs of Observations 8 and 9 to Appendix A.1.
Comparison Inequality
In this subsection, we derive a bound on the potential function , which is the key inequality in the analyses of both the algorithm of Buchbinder and Feldman [2] and our algorithm. We remark that a special case of Corollary 11 also plays an important role in their analysis (see Section 3).
Lemma 10.
(a) For every ,
(b) For every ,
We defer the proof of Lemma 10 to Appendix A.2. Adding the two inequalities of Lemma 10 yields the following.
Corollary 11. For every and every ,
where and
Estimating
Our algorithm needs to evaluate . By Observation 8, is a sum of terms, each of which can be computed using two value-oracle queries; hence, can be computed exactly using value-oracle queries (see Lemma 12). Our deterministic algorithm (Theorem 2) uses this exact computation. To improve the dependence on from exponential to polynomial, our randomized algorithm instead estimates by sampling (see Lemma 13).
Lemma 12 (Exact computation). For any and , the value can be computed deterministically using value oracle queries.
Proof. Let . By Observation 8, is determined by the values and for the sets that contain .
Lemma 13. There is a randomized algorithm Estimate which, given and , uses value oracle queries and w.h.p. outputs such that
Since each call uses fresh randomness, this holds even if is chosen depending on the outcomes of previous calls.
Roughly speaking, the procedure Estimate draws independent random samples, computes a value for each sample using value oracle queries, and outputs the average of the computed values. We defer the proof of Lemma 13 to Appendix A.3.
We call an estimate good if it satisfies the inequalities in Lemma 13.
Technical Overview: Comparison with the Local Search of Buchbinder and Feldman [2]
In this section, we first explain the analysis of the local search of Buchbinder and Feldman in terms of Corollary 11, and then outline how our algorithm uses the same corollary in its analysis. Corollary 11 states that, for every and every ,
where and .
The Analysis of Local Search of Buchbinder and Feldman [2]. Roughly speaking, they compute a set by local search, and their analysis essentially applies the inequality in Corollary 11 with . In this case, we have . Moreover, the inequality satisfied by the set obtained by local search [BF25a, Inequality (3.4)] implies that .3 Combining these bounds and dividing by , we obtain . Since by Fact 7(d), this yields a -approximation.
However, their local search for finding a set satisfying [BF25a, Inequality (3.4)] uses queries, or queries with randomization, which is not nearly-linear in when is large.
The Analysis of Our Protected Local Search. Our protected local search performs phases, each of which is a single pass over decreasing thresholds in which every element is processed at most once: is swapped in for an element of the current basis only if removing costs less than about , and otherwise is protected, i.e., kept in the basis until the end of the phase; see Algorithm 1 for details.
Fix a single phase, and let and be the bases at the beginning and the end of this phase, respectively. Let be the increase in during this phase. We show that and (Lemma 17). To prove the second inequality, we apply Corollary 11 to the sets and at the end of the phase. Since and is monotone, we have , and hence it suffices to upper-bound . For the upper bound on , see the paragraph Plan of the Proof of Lemma 17 in § 5.
Lemma 17 means that if , then is a -approximate solution; otherwise, the phase increases by more than . Since for every phase and for every basis of (by Observation 9), the total increase of over phases is at most . Hence, for , some phase satisfies since , and its starting basis yields a -approximation. Our algorithm returns the best among the starting bases of the phases.
Our Protected Local Search Algorithm
Parameters
We first construct a basis of greedily using independence queries, and compute using value queries. Since we assume that has no loops, we have . If , then by monotonicity, and Fact 3(b) gives for every , where we simply return .
The parameters in our algorithm are listed in Table 2. The thresholds are for , where is the largest with . Note that . Since by Fact 7(d) and for , the number of thresholds is . By Observation 9, we have for every and .
| Symbol | Value | Role |
| number of colors | ||
| upper limit for thresholds | ||
| lower limit for thresholds | ||
| , | thresholds, in decreasing order | |
| number of phases |
Table 2. Parameters of the algorithm.
Algorithm 1 Phase()
Input: a basis of
; ; mark every as unprocessed Throughout: , , , .
for do
for each unprocessed , in arbitrary order do
if then continue ▷ stays unprocessed
while and do ▷ processing of
if then
else
an element of such that ▷ by the binary search technique (Lemma 4)
if then
▷ protect
else
; ▷ exchange for
break
mark as processed
return
One Phase
Our algorithm consists of phases, each of which is described in Algorithm 1. A phase starts from a basis of and maintains the following sets.
A. The elements that stay in the current basis until the end of the phase; never shrinks. An element enters in one of two ways: it is protected if it is added to in Line 11, and it is inserted if it is added to in Line 13.
. The elements of that have not been deleted. never grows.
. The current basis.
. The set on which gains are evaluated.
The sets and may intersect, since a protected element belongs to both. For the current sets, we write
We call the gain of also when , and the loss of also when . We write and for the estimates returned by Estimate and Estimate, respectively.
Algorithm 2 Protected local search
Construct a basis of ; compute
if then return
set the parameters as in Table 2
▷ every element of the initial basis gets color 1
for do
return , where
In words, for each threshold, the phase scans the elements that are still unprocessed. An element whose estimated gain is below the threshold is skipped, and it is scanned again at the next threshold. Otherwise, the element is processed: as long as and is independent, the phase sets if , and otherwise picks an element such that . The phase protects if the estimated loss exceeds , and otherwise it exchanges for and stops. Afterwards, is marked as processed and is not examined again in this phase.
The following lemma plays a crucial role in the analysis of our algorithm.
Observation 14 (Monotonicity of and ). During a phase, only grows and only shrinks. Hence, by submodularity of (Lemma 6), the gain of each can only decrease, and the loss of each can only increase.
The Whole Algorithm
The whole algorithm is described in Algorithm 2. It first constructs a basis of , computes , and sets the parameters as in Table 2. It then assigns color 1 to every element of , which yields a basis of , and runs phases starting from , where each phase takes the basis produced by the previous phase as its input. Finally, it returns the best projected basis with respect to .
Invariants and Query Complexity of One Phase
In this subsection, we show some invariants maintained during a phase and then bound the number of oracle queries used in a phase. Both the invariants and the bound hold regardless of whether the estimates are good.
Lemma 15 (Invariants). Throughout a phase, , , is a basis of , and . Moreover, and only grow and only shrinks, and each iteration of the while loop adds a new element to . In particular, the body of the while loop is executed at most times in total during a phase.
Proof. The sets and change only in iterations of the while loop, and the invariants hold at the beginning of the phase, where and . We show that each iteration maintains them. Consider an iteration processing ; by the loop condition, and .
We first show that the element is well-defined and satisfies . If , then , because and . Now suppose that . It remains to show that an element as in Line 9 always exists. To prove this, we use the augmentation property of the matroid : by repeatedly adding elements of to , we obtain a basis of with . Since and , we have for some , and because . Hence satisfies , and thus an element as in Line 9 always exists.
We next consider the update.
If is protected (Line 11), then becomes , which is independent. Since , none of , , and changes.
If is exchanged for (Line 13), then , and becomes . This is a basis of that contains the new set . The set becomes , and becomes .
If is exchanged for , then moves from to , so and do not change, and is independent.
In all cases, and still hold, and do not shrink, and does not grow. Finally, every iteration adds an element not in (namely, or ) to . Since has at most elements, there are at most iterations.
Lemma 16 (Query complexity of one phase). makes calls to . Moreover, uses value-oracle queries and independence-oracle queries.
Proof. We first count the value-oracle queries, which are used only in the calls to . For each of the thresholds, the gain of each unprocessed element is estimated once, so the number of gain estimates is at most . A loss is estimated once per iteration of the while loop, so by Lemma 15 the number of loss estimates is at most . Hence, calls times. By Lemma 13, each call uses value-oracle queries, and thus the number of value-oracle queries is .
We next count the independence-oracle queries. Recall that each independence-oracle query to is answered by at most one independence-oracle query to . Independence-oracle queries are used only to check the loop condition and to find in Line 9.
Each check of whether either leads to an iteration of the while loop, which happens at most times by Lemma 15, or ends the processing of , which happens at most once for each , i.e., at most times.
Line 9 is executed at most once per iteration, i.e., at most times. We apply Lemma 4 to with , , and . A desired element exists by the proof of Lemma 15, and , so each execution uses queries.
Hence, the number of independence-oracle queries is .
Analysis of One Phase
Throughout this section, we consider a single phase, and we assume that every estimate made during it is good.
Lemma 17 (Phase lemma). Let and be the starting and ending bases of a phase in which all estimates are good, and let . Then and
Notation. For a processed element , let be the threshold at which it is processed. Let be the set of elements inserted by exchanges (Line 13) during the phase, and let be the set of protected (Line 11) elements. For , let be the element deleted from in its exchange, and let
where and are evaluated immediately before that exchange. Unless stated otherwise, , , , , and refer to the end of the phase.
Plan of the Proof of Lemma 17. We apply Corollary 11 to the sets and at the end of the phase. Since and is monotone, we have , and hence it suffices to upper-bound . We first collect basic properties of a phase: Claim 18 bounds the gain of each element in terms of the thresholds, and Claim 19 shows that each exchange increases by at least an -fraction of the gain of the inserted element, which in particular implies . Next, we upper-bound by Claim 20: each exchange changes by at most while increasing by at least (Claim 19), and hence . Finally, we upper-bound by Claims 21, 22, and 23. Claim 22 is the heart of the analysis; it plays the role of the approximate local optimality [2 Inequality (3.4)] in the analysis of Buchbinder and Feldman [2], and bounds the total gain of any independent set by the sum of the thresholds at which the elements of entered . These thresholds are bounded by the losses of the protected elements (Claim 21) and by for the inserted elements (Claim 20), which yields Claim 23.
Using Observation 14, we first show that the gain of each element is bounded in terms of the thresholds.
Claim 18. If is processed at threshold , then throughout its processing. Moreover, every element that is unprocessed at the end of the phase satisfies at the end of the phase.
Proof. While is processed, can change only at an exchange in Line 13, after which the processing of immediately ends. Indeed, a protection adds an element of to , and hence does not change . Hence, does not change during the processing of . The lower bound follows from , where the second inequality holds because was not skipped in Line 4. For the upper bound, if , then it follows from (see Section 4.1). Otherwise, was skipped in Line 4 at the previous threshold , i.e., held at that time. Hence, at that time, , and by Observation 14, has not increased since then. Therefore, in both cases, holds throughout the processing of .
Let be an element that is unprocessed at the end of the phase. Then, was skipped in Line 4 at the last threshold , i.e., held at that time. Hence, at that time, , and by Observation 14, has not increased since then. Therefore, at the end of the phase.
For , let be the increase of caused by the exchange that inserts (Line 13), i.e., , where denotes the basis just before the exchange. Recall that .
Claim 19.
(a) In each iteration of the while loop during the processing of , if at that time, then is chosen in Line 9, and is protected (Line 11) in that iteration. Consequently, just before each exchange in Line 13, we have and .
(b) For every , we have and . Moreover,
(c) .
Proof. (a) Suppose that in an iteration of the while loop during the processing of ; then by Line 9. Since and by the loop condition, we have . Thus, , and hence
where the first inequality follows from the submodularity of (Lemma 6), and the last inequality follows from Claim 18. Therefore, , and hence the test in Line 10 succeeds for , and is protected in Line 11. Consequently, an exchange is performed only in an iteration with ; since is chosen from in Line 9, we also have .
(b) Let , let , and let be the basis just before the exchange that inserts . Since the exchange is performed during the processing of at threshold , Claim 18 gives . Since the exchange is performed only when the test in Line 10 fails, we have , and hence . Since , we have
Since and by (a), we have ; moreover, . By the submodularity of , we obtain and , and hence . Finally, , which is positive since .
(c) A protection (Line 11) adds an element of to , and hence does not change . Thus, changes only through exchanges, and since each is inserted by exactly one exchange, we have . Since for every by (b), we have .
The next claim upper-bounds by tracking its change during the phase: each exchange changes it by at most , while increasing by at least by Claim 19(b). The same argument also bounds , since . Recall that is the threshold at which is processed.
Claim 20. At the end of the phase, both and are .
Proof. By Claim 19, , so . Since by Claim 19(b), this gives .
To show , we track during the phase. At the beginning of the phase, since and hence . The protections (Line 11) change neither nor , since they only add an element of to and . Thus, changes only through exchanges. Consider an exchange that inserts and deletes , and let and denote the sets just before it; the exchange replaces by and by . By (1) and the submodularity of , we have
where the last inequality follows from Claim 19(b). Hence, each exchange increases by at most . Since each is inserted by exactly one exchange, we obtain at the end of the phase.
Using Observation 14, we show that every protected element stays in and keeps a large loss.
Claim 21. Every protected element belongs to the final . Moreover, if was protected at threshold , then for the final .
Proof. Let . When is protected (Line 11), belongs to and is added to . Since an element is deleted from only if it belongs to , and stays in , the element is never deleted; hence belongs to the final .
Next, suppose that was protected at threshold . At that time, we have . Since does not decrease afterwards (Observation 14), we obtain for the final .
The next claim is the heart of the analysis. It plays the role of the approximate local optimality [2 Inequality (3.4)] in the analysis of Buchbinder and Feldman, and is the main tool for upperbounding .
Claim 22. Let be the thresholds at which the elements of the final entered , listed in order of entry, and set for . Then, at the end of the phase, every satisfies
The proof of Claim 22 compares the order in which the elements of are processed with the order in which elements enter . Let be the -th processed element of , and consider the moment when its processing ends. At this moment, each of is spanned by , and hence , i.e., the -th element to enter did so no later than this moment. Since thresholds decrease over time, this gives . On the other hand, Claim 18 gives at the end of the phase. Combining these two inequalities and summing over yields the inequality of Claim 22.
Proof of Claim 22. We say that is spanned by if or . The processing of an element ends only when the loop condition fails (i.e., is spanned by ) or after an exchange (Line 13) that inserts it into , so every processed element is spanned by at the moment its processing ends. It remains spanned afterwards, because only grows.
Let be the elements of that are processed during the phase (possibly ), in the order in which they are processed. Fix . When the processing of ends, the set is independent (as ) and all of its elements are spanned by . Since is independent, if at that moment, then the augmentation property gives some () with , which contradicts that is spanned by . Hence, when the processing of ends. Since never shrinks, the -th element to enter did so no later than the end of the processing of . Since thresholds never increase over time, . Therefore, at the end of the phase, , where the first inequality holds since while is processed (Claim 18) and does not increase afterwards (Observation 14).
Let be the remaining elements of , which are unprocessed, in arbitrary order; note that since . For each , Claim 18 gives at the end of the phase, where the last inequality holds since (every threshold is at least ). Combining these bounds and using for every , we obtain
Using Claim 22, we obtain the following inequality, which is used to upper-bound .
Claim 23. At the end of the phase,
Proof. For each , we have , and hence Claim 22 with gives
@bibliography Each element of entered either as a protected element , at a threshold of at most by Claim 21, or as an inserted element , at threshold . The remaining values are equal to , and they sum to at most . Hence,
where the last inequality holds since by Claim 21 and for every by the monotonicity of . Combining this with the first inequality, we have, for every ,
Since the right-hand side does not depend on , summing this inequality over and dividing by yields the claim.
We now prove Lemma 17 using the claims established above.
Proof of Lemma 17. We have by Claim 19(c). We apply Corollary 11 to the final sets (recall that ) and . In the notation of this section, . By Claims 20 and 23,
By Lemma 10(a) and , we have . Plugging these bounds into Corollary 11 and dividing by , we obtain
By Fact 7(d), we have and . Together with , this gives
Dividing by , we obtain . Finally, and monotonicity of give . Therefore, we obtain
Proof of the Main Theorem
In this section, we present the approximation guarantee and the query complexity of Algorithm 2 (Theorem 24), which implies Theorem 1.
Theorem 24. Algorithm 2 returns a basis of such that, w.h.p., . It uses value oracle queries and independence oracle queries.
Proof. Since maps bases of to bases of , the output is a basis of .
Probability. By Lemma 16, regardless of the outcomes of the estimates, the algorithm calls Estimate times. By Lemma 13, each call is good w.h.p., even conditioned on the previous calls. Hence, by the union bound over the calls, w.h.p. all estimates are good. In the rest of the proof, we assume this. Approximation Guarantee. Let , which is non-negative by Lemma 17. We have
where the last inequality follows from Observation 9 and . Since , some phase satisfies . By Lemma 17 applied to this phase,
Since the algorithm returns the best starting basis, the output also satisfies this bound.
Query Complexity. By Lemma 16 and , the phases use value oracle queries and independence oracle queries in total. The preprocessing uses value and independence oracle queries, and choosing the best starting basis uses value oracle queries.
Deterministic Algorithm.
We obtain Theorem 2 by replacing every call Estimate in Algorithm 2 with the exact computation of in Lemma 12; all other steps are deterministic. Since exact values are always good, the proof of Theorem 24 applies without the probability argument, and the number of independence oracle queries does not change. Each of the calls to Estimate now uses value oracle queries, and hence the total number of value oracle queries is .
Declaration of Generative AI Use. The main ideas behind our protected local search algorithm and its analysis were developed largely with the assistance of GPT-6 Astra (OpenAI). We also used GPT-6 Astra (OpenAI), Claude Opus 5.5, and Claude Fable 5.1 (Anthropic) to assist in drafting the manuscript and improving its language and presentation. We carefully verified and revised the proofs and take full responsibility for the paper.
Omitted Proofs
In this appendix, we restate the lemmas whose proofs were omitted from the main body, and provide their proofs.
Omitted Proofs in sec:potential
Fact 7.
(a) for .
(b) For every , . We also have .
(c) .
(d) and . In particular, .
Proof of Fact 7. (a) .
(b) There are sets of size in the sum, and . Hence, the sum is . For the second identity, there are sets of size in the sum, and . Hence, the sum equals , which is as shown above.
(c) There are sets of size in the sum. Since , we have , where the last inequality uses . Summing over gives the claim.
(d) For every , we have . The first inequality gives , and the second gives .
Observation 8. For and , .
Proof of Lemma 8. By the definition of ,
We consider the value . If , then , and hence the term is zero. If , then , and hence . Combining these yields the claim.
Observation 9. For every , we have . For every and , we have .
Proof of Observation 9. The first inequality holds since
where the inequality follows from and (by and the monotonicity of ), and the equality follows from Fact 7(c). For the second inequality, let . Then
where the first inequality follows from the submodularity of (Lemma 6), the first equality follows from Observation 8 and , the second equality follows from Fact 7(b), and the last inequality follows from .
Omitted Proofs in Section 2.4: Comparison Inequality
Lemma 10.
(a) For every , .
(b) For every , .
Proof of Lemma 10. (a) We have
where the first equality follows from Observation 8 and for and , the second equality follows by exchanging the order of summation, and the inequality follows from Fact 3(a) with and , since . Here, both and hold because contains at most one copy of each element.
The right-hand side of the inequality (2) plus equals
The first and third sums together equal . For the second sum, the pairs with correspond one-to-one to the pairs with via , and hence
Therefore, the right-hand side of the inequality (2) plus equals with
Setting , we obtain
By Fact 7(a), the coefficient vanishes for . For , the coefficient is negative. For , the coefficient is , which completes the proof of (a).
(b) Fix and . We have
where the equality follows from Observation 8. For the inequality, if , then , and hence it holds with equality. If , then for every , and hence the right-hand side is 0, while the left-hand side is non-negative by the monotonicity of (Lemma 6). We also have
where the first inequality follows from Fact 3(b), and the second follows from the monotonicity of . Combining the two inequalities above, for each ,
Summing this inequality over and dividing by , we obtain
where the first equality holds since each appears exactly times in the double sum, once for each , and the second equality follows from Fact 7(b) and the definition of .
Omitted Proofs in Section 2.5: Estimating
Lemma 13. There is a randomized algorithm which, given and , uses value oracle queries and w.h.p. outputs such that . Since each call uses fresh randomness, this holds even if is chosen depending on the outcomes of previous calls.
To prove Lemma 13, we first show the following lemma.
Lemma 25 (Sampler). Let and . Choose uniformly at random, then choose uniformly at random among the subsets of of size that contain , and let
Then, and .
Proof. Given , the set is uniformly distributed over the sets of size containing , and . Hence, each set is chosen with probability . Since for every , we obtain
where the last equality follows from Observation 8.
Let . Every sampled contains , so , and submodularity gives . On the other hand, with probability , and then . Since , this gives , and hence .
We use the following standard Chernoff bound.
Algorithm 3 Estimate
Input: and
draw independent samples of in Lemma 25
return
Fact 26 (Chernoff bound; see, e.g., [9 Theorem 1.1]). Let be independent random variables taking values in , and let . Then, for ,
Proof of Lemma 13. We show that Algorithm 3 satisfies the conditions of Lemma 13. Let . If , then with probability 1 and the output is 0. Otherwise, by Lemma 25, each sample satisfies and . Hence, Fact 26 with , , and shows that the average of the samples satisfies with probability at least , which is w.h.p. by the choice of . In this case, the output satisfies and . Each sample uses two value oracle queries, and . Since , the number of value oracle queries is .
References
- [1]Alexander A Ageev and Maxim I Sviridenko. Pipage rounding: A new method of constructing algorithms with proven performance guarantee. Journal of Combinatorial Optimization, 8:307–328, 2004.DOI
- [2]Niv Buchbinder and Moran Feldman. Deterministic algorithm and faster algorithm for submodular maximization subject to a matroid constraint. SIAM Journal on Computing, pages FOCS24–85, 2025. Preliminary version in FOCS’24.
- [3]Niv Buchbinder and Moran Feldman. Extending the extension: Deterministic algorithm for non-monotone submodular maximization. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing (STOC 2025), pages 1130–1141, 2025.arxiv.org/abs/2409.14325
- [4]Niv Buchbinder, Moran Feldman, and Roy Schwartz. Comparing apples and oranges: Query trade-off in submodular maximization. Mathematics of Operations Research, 42(2):308–329, 2017. Preliminary version in SODA’15.DOI
- [5]Ashwinkumar Badanidiyuru and Jan Vondrák. Fast algorithms for maximizing submodular functions. In Proceedings of the 25th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2014), pages 1497–1514, 2014.
- [6]Gruia Calinescu, Chandra Chekuri, Martin Pál, and Jan Vondrák. Maximizing a monotone submodular function subject to a matroid constraint. SIAM Journal on Computing, 40(6):1740–1766, 2011.DOI
- [8]Chandra Chekuri, Jan Vondrák, and Rico Zenklusen. Dependent randomized rounding via exchange properties of combinatorial structures. In Proceedings of the 51st Annual Symposium on Foundations of Computer Science (FOCS 2010), pages 575–584, 2010.DOI
- [9]Devdatt P Dubhashi and Alessandro Panconesi. Concentration of measure for the analysis of randomized algorithms. Cambridge University Press, 2009.DOI
- [10]Alina Ene and Huy L. Nguyễn. Towards nearly-linear time algorithms for submodular maximization with a matroid constraint. In Proceedings of the 46th International Colloquium on Automata, Languages, and Programming (ICALP 2019), volume 132, pages 54:1–54:14, 2019. arXiv version is arXiv:1811.07464.arxiv.org/abs/1811.07464
- [11]ML Fisher, GL Nemhauser, and LA Wolsey. An analysis of approximations for maximizing submodular set functions–II. Mathematical Programming Studies, 8:73–87, 1978.DOI
- [12]Yuval Filmus and Justin Ward. Monotone submodular maximization over a matroid via non-oblivious local search. SIAM Journal on Computing, 43(2):514–542, 2014.
- [13]Amit Ganz Rozenman, Ariel Kulik, Roy Schwartz, and Mohit Singh. A Poisson process for submodular maximization. In Proceedings of the 58th Annual ACM Symposium on Theory of Computing (STOC 2026), pages 2152–2163, 2026.
- [14]Monika Henzinger, Paul Liu, Jan Vondrák, and Da Wei Zheng. Faster submodular maximization for several classes of matroids. In Proceedings of the 50th International Colloquium on Automata, Languages, and Programming (ICALP 2023), volume 261, pages 74:1–74:18, 2023.arxiv.org/abs/2305.00122
- [15]Yusuke Kobayashi and Tatsuya Terao. Subquadratic submodular maximization with a general matroid constraint. In Proceedings of the 51st International Colloquium on Automata, Languages, and Programming (ICALP 2024), volume 297, pages 100:1–100:19, 2024.arxiv.org/abs/2405.00359
- [16]Huy L Nguyễn. A note on Cunningham’s algorithm for matroid intersection. arXiv preprint arXiv:1904.04129, 2019.arxiv.org/abs/1904.04129
- [17]George L Nemhauser and Laurence A Wolsey. Best algorithms for approximating the maximum of a submodular set function. Mathematics of operations research, 3(3):177–188, 1978.DOI
- [18]George L Nemhauser, Laurence A Wolsey, and Marshall L Fisher. An analysis of approximations for maximizing submodular set functions–I. Mathematical Programming, 14:265–294, 1978.DOI