A Deterministic Algorithm for Maximizing Submodular Functions
The problem of maximizing a non-negative submodular function was introduced by Feige, Mirrokni, and Vondrak [FOCS’07] who provided a deterministic local-search based algorithm that guarantees an approximation ratio of , as well as a randomized -approximation algorithm. An extensive line of research followed and various algorithms with improving approximation ratios were developed, all of them are randomized. Finally, Buchbinder et al. [FOCS’12] presented a randomized -approximation algorithm, which is the best possible.
This paper gives the first deterministic algorithm for maximizing a non-negative submodular function that achieves an approximation ratio better than . The approximation ratio of our algorithm is . Our algorithm is based on recursive composition of solutions obtained by the local search algorithm of Feige et al. We show that the approximation ratio can be guaranteed when the recursion depth is , and leave open the question of whether the approximation ratio improves as the recursion depth increases.
Let be a set function on a ground set of elements (). We say that is submodular if it exhibits decreasing marginal utilities. In other words, For every two sets and such that and element :
An equivalent definition is that for every two subsets and it holds that:
It is common to assume that is non-negative: that is, for every , .
Submodular functions arise in many combinatorial optimization scenarios. For example, given a graph , let the cut function of be the function that assigns every subset of the vertices the size of the cut . Observe that a cut function is submodular. Similarly, the objective function in classic problems such as SET-COVER is also submodular. The decreasing marginal utilities property also makes submodular functions a popular object of study in various economic settings, such as combinatorial auctions and influence maximization in social networks (see, e.g.,  and , respectively).
The formal study of approximation algorithms111In general representing a submodular function takes space that is exponential in . Therefore, we assume that is accessed via value queries: given , what is ? All the algorithms we mention make value queries and run in time . for submodular optimization problems has started back in 1978: Nemhauser, Wolsey and Fisher  showed that for monotone and non-negative submodular functions, a natural greedy algorithm gives a -approximation to monotone submodular maximization under a cardinality constraint.
However, the objective function of problems like is submodular but not necessarily monotone so the above algorithm does not guarantee any bounded approximation ratio. To handle this lacuna, Feige et al.  initiated the study of algorithms for maximizing non-negative submodular functions. They developed a local search algorithm that finds a set whose value is at least of the value of the maximum-value set. In addition, they presented a randomized -approximation. Their algorithms are complemented by the following hardness result: any algorithm that obtains a better approximation ratio than , must make exponentially (in ) many queries. This hardness result was later extended : unless , no polynomial time approximation algorithm exists.
Subsequent work led to improvements in the approximation ratio. Oveis Gharan and Vondrak showed a randomized -approximation algorithm . Feldman et al.  improved this to , again using a randomized algorithm. Finally, Buchbinder, Feldman, Naor and Schwartz  presented a randomized algorithm that achieves an approximation ratio of , which as mentioned above, is the best possible.
However, there was no progress at all regarding the approximation ratio achievable by deterministic algorithms, and prior to our work no deterministic algorithm was known to obtain a ratio better than . Indeed, this open question was recently mentioned, e.g., by . Our paper makes progress on this front:
For every there is a deterministic algorithm that provides a -approximation to unconstrained submodular maximization and makes value queries.
Our algorithm can be seen as a recursive composition of solutions obtained by the local search algorithm of . Here is a sketch of our algorithm (see the technical sections for a more accurate description):
Find a local maximum222 is a local maximum if and for all . .
Use an approximation algorithm to obtain with high value when is restricted to . 333We use the notation to denote the complement set of .
Use an approximation algorithm to obtain such that is high.
For the base case we use in Steps 2 and 3 the local search algorithm of . After obtaining an algorithm with an improved approximation ratio, this new algorithm can be used recursively in Steps 2 and 3. We will show that when the recursion depth is the approximation ratio is . The approximation ratio of the algorithm should in principle improve as the recursion depth increases, but we do not know how to analyze it. This is the main open question that this paper leaves.
2 A -Approximation Algorithm
In this section we prove that there exists a -approximation algorithm to the problem of maximizing a non-negative submodular function. To gain some intuition about our algorithm we will see how one can get a better than -approximation (Subsection 2.1). We will then give a formal description and analysis of our algorithm (Subsection 2.2 onwards).
2.1 Warm-Up: Improving over the -Approximation Factor
We now show that we can get an approximation ratio better than approximation. Let be a local maximum . Feige et al.  show that , which implies that either or provides a approximation (we let OPT denote the optimal solution). In fact, a slightly stronger inequality holds: .
Consider a scenario in which the local-maximum algorithm returns only a approximation. In that case we have and . We will show that two other sets, and have high value. For the first set, observe that (using submodularity for the first inequality, being a local maximum for the second, and for the third one):
Similarly . In other words:
There is a subset of with high value. In particular, the value is at least .
There is a superset of with high value. In particular, the value is at least .
Now we would like to (approximately) find these subsets. Observe that we actually have a (smaller) submodular maximization problem. To see this, let and be the submodular function for every . Observe that . In addition, we have already seen that , where is a maximum value set of .
We now run the local search algorithm on the the function and find a local maximum . By the properties of a local maximum we are guaranteed that
Notice that by our bounds for and it must be that or that . If one of them has higher value we already reach an approximation ratio better than . Hence, we assume that , then .
We now repeat a similar argument. Similarly to inequality (1),
This already establishes that the approximation ratio is better than , but we can do even better: find such that has high value. Combine and to sum the improvements, since submodularity implies that .
2.2 The Algorithm
We now present our main result: an improved deterministic algorithm for maximizing a submodular function. As discussed earlier, our algorithm will be based on repeatedly finding local maxima of different subsets and combining the result. However, we do not know how to find a local maximum with a polynomial number of value queries, thus we have to settle on approximate solutions:
Fix a function . is a of if for every :
There is an algorithm that gets as a input function , a set of elements and and returns a set that is . In addition, , where OPT is the set with the highest value. The algorithm makes value queries.
Feige et al  show how to start with a set and find a set that is a -approximate local maximum with value queries. Their algorithm guarantees that and that either or . This weaker guarantee suffices to our analysis, but it would be simpler to first obtain a set with via the deterministic algorithm of , and then obtain an approximate local maximum by running the algorithm of  with as the initial set.
We are now ready to present our recursive algorithm for unconstrained submodular maximization. The input is a submodular function defined on a set of elements , and a parameter that determines the recursion depth. We also assume some fixed accuracy parameter . The algorithm returns a set that will be proved to provide a high value.
Define : . Let .
If , , or then return .
Let , define : . Let .
Let , define : . Let .
Let . Moreover, the algorithm makes value queries in this case.
2.3 Proof of Theorem 2.3
We first analyze the running time of the algorithm. Let be the maximum number of queries makes on any submodular function that is defined on elements.
For every integer the number of queries used by is . As a corollary, for every integer the number of queries used by is .
Denote by the maximal number of queries makes on a submodular function with . In iterations where the algorithm stops at Step 2, the number of queries is at most . Else, we have that . The algorithm then recursively solves two subproblems, one on and the other on . Thus, can be bounded by:
Solving that recursion by induction on gives that . ∎
The next lemma bounds the approximation ratio when the recursion depth is (i.e., ). We note that using a larger value of should in principle yield an improved ratio, but currently we are unable to formally analyze this case. The next subsections are devoted to proving the lemma.
For every and for every submodular function with and :
2.4 Proof Overview
We introduce a function which represents a lower bound on the value of the solution that the algorithm outputs after rounds. Let be the set of all submodular functions.
Our result is based on the following lower bounds for . The proofs are in Subsection 2.5.
For every non negative :
Claim 2.8 (composition lemma).
Let be a submodular function, , and , and are the sets defined in the algorithm when we run . Then,
And in particular:
For every non negative we have:
Before proving these two claims, let us see why they let us derive our main bound on the quality of the solution (note that lemma 2.5 can be directly derived from this claim):
For every non negative , we have:
Let be a submodular function such that , and . We want to show that:
Let , be the sets defined by the algorithm when we run . Using the composition lemma we know that:
We use claim 2.9 to bound and get:
The algorithm compares to and returns the set with highest value. Therefore,
That is a maximum of two functions, both linear in , one is ascending and one is descending. The minimum of a maximum of two such functions is achieved at their intersection. I.e., when . Solving this equation gives us:
By the definition of and since ,
Let be a -local maximum. Therefore:
Also, submodularity of implies that
The next claim appeared in  in a slightly different form:
Let be a -local maximum, and a submodular function. Then .
2.5.2 Proof of Claim 2.7
Let be a submodular function, and be the local maximum found by the algorithm. Using theorem 2.2:
Also, note that the algorithm takes the set with highest value among , , and . Therefore, for every submodular :
Hence, by the definition of ,
2.5.3 Proof of Claim 2.8 (composition lemma)
Next, we give bounds on and :
The above and satisfy:
First, note that by the definition of , it is monotone in the following sense: if , and , then .
Consider the subproblems in which we attempt to find a maximum of and . By the definition of , we have:
To prove second part of the composition lemma, we use the following claim:
For every non-negative and every we have: .
In Step 2 the algorithm can choose to output . Therefore, . ∎
Using claim 2.13 we know that
Combining it with the first part of the composition lemma gives us:
2.5.4 Proof of Claim 2.9
Let be a submodular function such that , and . We will show that:
Let , be the sets defined by the algorithm when we run . Using the second part of the composition lemma we know that:
The value of the output of the algorithm is at least the maximum of , , and . Hence,
This is a maximum of two functions, both linear in , one is ascending and one is descending. The minimum of a maximum of two such functions is obtained when they intersect, i.e., when . Therefore . Since we have:
By the definition of , it follows that:
The proof that is similar, with the roles of and switched.
-  Niv Buchbinder, Moran Feldman, Joseph Naor, and Roy Schwartz. A tight linear time (1/2)-approximation for unconstrained submodular maximization. In Foundations of Computer Science (FOCS), 2012 IEEE 53rd Annual Symposium on, pages 649–658. IEEE, 2012.
-  Shahar Dobzinski and Jan Vondrak. On the hardness of welfare maximization in combinatorial auctions with submodular valuations. SODA, 2013.
-  Uriel Feige, Vahab S Mirrokni, and Jan Vondrak. Maximizing non-monotone submodular functions. SIAM Journal on Computing, 40(4):1133–1153, 2011.
-  Moran Feldman. Maximizing symmetric submodular functions. arXiv preprint arXiv:1409.5900, 2014.
-  Moran Feldman, Joseph Seffi Naor, and Roy Schwartz. Nonmonotone submodular maximization via a structural continuous greedy algorithm. In Automata, Languages and Programming, pages 342–353. Springer, 2011.
-  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, pages 1098–1116. SIAM, 2011.
-  David Kempe, Jon Kleinberg, and Éva Tardos. Maximizing the spread of influence through a social network. In Proceedings of the ninth ACM SIGKDD international conference on Knowledge discovery and data mining, pages 137–146. ACM, 2003.
-  Benny Lehmann, Daniel Lehmann, and Noam Nisan. Combinatorial auctions with decreasing marginal utilities. In Proceedings of the 3rd ACM conference on Electronic Commerce, pages 18–28. ACM, 2001.
-  George L Nemhauser, Laurence A Wolsey, and Marshall L Fisher. An analysis of approximations for maximizing submodular set functionsâi. Mathematical Programming, 14(1):265–294, 1978.