Majorisation-minimisation algorithms for minimising the difference between lattice submodular functions

TL;DR

This paper introduces majorisation-minimisation algorithms for optimizing the difference between lattice submodular functions, ensuring monotonic convergence to local minima and broad applicability.

Contribution

It develops novel algorithms analogous to existing routines for lattice submodular functions and extends hardness results to a wider class of functions.

Findings

Algorithms guarantee monotonic decrease in objective

Convergence to local minima is proven

Many functions can be expressed as differences of submodular functions

Abstract

We consider the problem of minimising functions represented as a difference of lattice submodular functions. We propose analogues to the SupSub, SubSup and ModMod routines for lattice submodular functions. We show that our majorisation-minimisation algorithms produce iterates that monotonically decrease, and that we converge to a local minimum. We also extend additive hardness results, and show that a broad range of functions can be expressed as the difference of submodular functions.

Equations

$$f(A)+f(B)\ge f(A\cup B)+f(A\cap B).$$

$$f(x)+f(y)\ge f(\min (x,y))+f(\max (x,y))$$

$$f(A\cup e)-f(A)\ge f(B\cup e)-f(B).$$

$$f(x+c{e}_j)-f(x)\ge f(y+c{e}_j)-f(y).$$

$$v(x)=f(x)-g(x)$$

$$f_{\downarrow }(\rho )={\int }_0^{1}f(\theta ({\rho }_1,t),\dots ,\theta ({\rho }_n,t))dt.$$

$$f_{\downarrow }(\rho )=f(0)+\sum _{i=1}^{r}t(s)(f(y(s))-f(y(s-1)))$$

$$\sum _{i=1}^n\sum _{y_i=1}^{x_i}{w}_i(y_i)\le f(x_1,\dots ,x_n),$$

$$\sum _{i=1}^n\sum _{y_i=1}^{k_i-1}{w}_i(y_i)=f(k_1-1,\dots ,k_n-1).$$

$$u_1(1)=-1,u_1(2)=1,$$

$$\underset{w}{\max }⟨w,\rho ⟩=f_{\downarrow }(\rho )-f(0),$$

$$0=p_0<p_1<\dots <p_r=(k_1-1,\dots ,k_n-1).$$

$$h_{f,y}(i,j)=w_i(j).$$

$$h_{f,y}(x)=\sum _{i=1}^n\sum _{j=1}^{x_i}{h}_{f,y}(i,j)=\sum _{i=1}^n\sum _{j=1}^{x_i}{w}_i(j).$$

$$h_{f,y}(p_i)=f(p_i).$$

$$h_{f,y}(y)=f(y).$$

$$h_{f,y}(x)\le f(x)$$

$$\lambda \le \underset{x,i}{\max }\left(f(x+2e_i)-2f(x+e_i)+f(x)\right).$$

$$f(Y)$$

$$(a_1,\dots ,a_n)$$

$$(b_1,\dots ,b_n)$$

$$f(y)$$

$$f(\max (x,y))-f(x)$$

$$=\sum _{i=1}^n{\rho }_{b_i,e_i}(x+\sum _{j=1}^{i-1}{b}_j{e}_j),$$

$$\sum _{i=1}^n{\rho }_{b_i,e_i}(x+\sum _{j=1}^{i-1}{b}_j{e}_j)\le \sum _{i=1}^n{\rho }_{b_i,e_i}(x)=\sum _{i=1}^{n}f(x+b_i{e}_i)-f(x).$$

$$f(\max (x,y))-f(y)$$

$$=\sum _{i=1}^n{\rho }_{a_i,e_i}(y+\sum _{j=1}^i{a}_j{e}_j-a_i{e}_i)$$

$$\ge {\rho }_{a_i,e_i}(\max (x,y)-a_i{e}_i)=\sum _{i=1}^n[f(\max (x,y))-f(\max (x,y)-a_i)].$$

$$f(x)-f(\min (x,y))$$

$$=\sum _{i=1}^n{\rho }_{a_i,e_i}(y+\sum _{j=1}^i{a}_j{e}_j-a_i{e}_i)$$

Full text

1 Introduction

In discrete optimisation, many objectives are expressible as submodular minimisation or maximisation problems. This is useful, as submodular functions can be minimised in strongly polynomial time [9], and have strong constant approximation factors under a variety of constraints for maximisation [11] [4]. Applications for these problems have included medical imaging [8], document summarisation [12] and online advertising [1].

We refer to $V=\{1,\ldots,n\}$ as the ground set, and a function $f:2^{V}\rightarrow\mathbb{R}$ is then called submodular if the following inequality holds for all $A,B\subseteq V$:

[TABLE]

We note that a subset $A$ can also be represented as a $0-1$ vector $x$, where a component takes on the value $1$ if the element is present in the subset $A$. In this way our inequality can be written as

[TABLE]

for all $x,y\in\{0,1\}^{n}$. A popular and often-studied application of submodular optimisation which we shall use as our running example is that of sensor placement. Suppose we wish to detect the level of air pollution in a town. We have a finite set of locations that we can install air pollution sensors in, but we are constrained by some budget. Knowing the geography of our town, we wish to select the set of locations such that the information we receive is maximised. As shown in [16], this problem is submodular.

In the classic $0-1$ case, this corresponds to only having one type of sensor. However, we can suppose that we have a number of different types of sensors available, each with a strength level that can be parameterised by an integer variable $x\in\{0,\ldots,k\}$. Lattice submodularity is then determined by satisfying Equation $(2)$, but for all $x,y\in\{0,\ldots,k\}^{V}$. Note that in general, we can allow $k$ to be different for different elements.

Submodular functions in the set case also lend themselves to a useful diminishing returns property, which is often considered as an equivalent definition.

Definition 1.1** (Diminishing returns property).**

A submodular set function can also be defined by the following. For any $A\subset B\subset V$ and $e\notin A$, we have

[TABLE]

However, for lattice functions we unfortunately do not get that for free [17], so we define a proper subclass known as DR-submodular functions as follows:

Definition 1.2** (DR-Submodular).**

Let $f$ be a lattice submodular function on $\prod_{i}\{0,\ldots,k\}^{V}$. Then $f$ is called a DR-submodular function if for all $x,y\in\prod_{i}\{0,\ldots,k\}^{V}$ with $x\leq y$ componentwise, $c>0$ and basis vector $e_{j}$, we have

[TABLE]

As shown in [2], many typical objectives we come across are in fact DR-submodular, so it makes sense to consider this subclass. The specific problem of optimising DR-submodular functions has been studied before [3] [17]. Across these papers, the problem of maximisation has been studied in monotone and non-monotone settings across a variety of constraints.

In this paper, we will carry out our majorisation-minimisation algorithm by discretising the lattice submodular functions, giving us submodular functions on some lattice. In [6], the authors showed that DR-submodular functions on a lattice can be reduced to the set function submodular case, where the ground set will be smaller. Due to this, we do not consider the specific DR subclass here, as it would be more efficient to carry out this reduction and then use the work of [10].

To motivate the problem of considering the difference of submodular functions, we turn back to the sensor information problem. Here, we may wish to also factor in the costs of sensors also. As is typical in real-world applications, we expect to get a bulk discount if we buy many sensors. Additionally, we may expect that for any one sensor, as the sensor gets stronger the unit price increases slower. This leads us to the diminishing returns property for submodularity. Specifically, if we obtain information $f(x)$, and spend $c(x)$ to get that information, for some sensor placement $x$, we wish to minimise $f(x)-\lambda c(x)$, for some tradeoff parameter $\lambda$. This formulation also applies to any other problem of optimising a submodular function with some cost.

In the set function case, this problem was considered by [10], who proposed several different majorisation minimisation techniques. Here, we will use the work of [2] to come up with our algorithm, who worked on discretised versions of continuous submodular function, hence lattice submodular functions. We will derive majorisation-minimisation algorithms on the difference $v(x)=f(x)-g(x)$. It can be considered the extension to the lattice case of the SupSub procedure in [10], originally introduced in [14], as well as the SubSup and ModMod procedures. In fact by discretising continuous functions, we can also consider it an extension to the continuous domain much like [2]. We will show that we converge to a local minimum of the function, and consider the class of functions we can represent as the difference of submodular functions.

1.1 Outline

We begin by discussing some preliminaries Section $2$. We consider the theory of continuous and lattice submodular functions, and show how subgradients are obtained. We show modular and tight lower and upper bounds, along with a decomposition that allows us to utilise the theory of DR-submodular functions effectively. Section $3$ presents and discusses the three algorithms, along with a discussion of a stopping criterion. In Section $4$, we discuss complexity, deriving the functions $f,g$ for the representation $v(x)=f(x)-g(x)$, along with other theoretical issues. We conclude with a brief discussion in Section $5$.

2 Preliminaries

We are considering the problem of minimising the difference between lattice submodular functions. In particular, we seek to minimise

[TABLE]

where $f,g$ are lattice submodular. For our algorithms, our plan will be to in fact use an extension of the functions $f$ that was defined in [2]. While doing this, we will also give the main ingredient for computing the lower bound.

2.1 An Extension

Our extension will be from the set $\prod_{i}\{0,\ldots,k_{i}-1\}=\prod_{i}\mathcal{X}_{i}$ to the product of measures of $\mathcal{X}_{i}$. The motivation for this can be thought of as follows. In the Lovasz extension, the value $x\in[0,1]$ taken on by a component can be thought of as the probability that an element $x$ is included in a set. Similarly, we will extend here to probability mass functions over the domain $\{0,\ldots,k_{i}-1\}$.

We note that any PMF on this domain can be represented by its reverse cumulative probability density function $\rho_{i}(x_{i})=\mu_{i}(x_{i})+\ldots+\mu_{i}(k_{i}-1)=F_{\mu_{i}}(x_{i})$. We then see that $\rho_{i}(0)=1$ always, and the only constraint on it is that its elements are non-decreasing, and all belong to $[0,1]$. As in [2], we denote this set of vectors as $[0,1]^{k_{i}-1}_{\downarrow}$.

Next, we think of this set of vectors just defined, and note that if we mark the locations of $\rho_{i}(x_{i})$, we will divide the number line into $k_{i}$ segments. This induces a map $\theta(\rho_{i},t)$ from $\mathbb{R}$ to ${0,\ldots,k_{i}-1}$ with $\theta(\rho_{i},t)=k_{i}-1$ if $t\leq\rho_{i}(k_{i}-1)$, $\theta(\rho_{i},t)=x_{i}$ if $t\in(\rho_{i}(x_{i+1},\rho_{i}(x_{i})]$ for $x_{i}\in{1,\ldots,k_{i}-2}$, and $\theta(\rho_{i},t)=0$ for $t\geq\rho_{i}(1)$.

Our extension is then thus defined, for a submodular function $f$

[TABLE]

For a more thorough exposition, see [2]. We now detail how the extension is evaluated using a greedy algorithm.

2.2 A lower bound

We now give the greedy algorithm from [2].

Theorem 2.1**.**

Consider the extension of $f_{\downarrow}(\rho)$ of a submodular function $f$. Order all values of $\rho$ in decreasing order, breaking ties arbitrarily but ensuring that all components for a given $\rho_{i}$ are in the correct order. Assume the value at position $s$ is equal to $t(s)$ and corresponds to $\rho_{i(s)}(j(s))$. Then we have the following expression for $f_{\downarrow}$

[TABLE]

which we write in the form $f_{\downarrow}(\rho)=f(0)+\sum_{i=1}^{n}\sum_{x_{i}=1}^{k_{i}-1}w_{i}(x_{i})\rho_{i}(x_{i})$, where $w_{i}(x_{i})$ corresponds to the difference in value between two function evaluations whose arguments differ by a single basis vector.

In this section, we will first remind ourselves of the different characterisations of the base polyhedron, how the greedy algorithm is used to construct extreme points for one of these characterisations, and how subgradients are computed. Using this, we will compute a lower bound that will be used for our algorithm.

We remind ourselves first of the characterisation of the base polyhedron as given initially in [2]:

Definition 2.1** (Base Polyhedron).**

Let $f(x_{1},\ldots,x_{n})$ be a discrete submodular function WLOG with $f(0,0,\ldots,0)=0$, in each argument from [math] to the integer $k_{i}-1$ respectively. Then the submodular polyhedron can be defined by arguments $w_{i}\in\prod_{i}\mathbb{R}^{k_{i}-1}$ such that for all $(x_{1},\ldots,x_{n})$:

[TABLE]

[TABLE]

As mentioned in [2], this polyhedron is in fact not a polyhedron, and is unbounded, if there is any $k_{i}>2$. This can be made explicit in the following example.

Example 2.1** (Base Polyhedron Unbounded).**

Let $k_{i}=3$ for some $i$. Then for that $i$, we can add to $w_{i}$ any $u_{i}$ such that

[TABLE]

and we see this won’t violate any of the equations in the definition. This argument extends straightforwardly to any $k_{i}>2$.

Because of this, they instead define the base polyhedron as the convex hull of outputs of a greedy algorithm. The following result shows that the base polyhedron still behaves in the same way:

Lemma 2.1**.**

Let $f$ be some submodular function. Then for any $\rho\in\prod_{i}\mathbb{R}_{\downarrow}^{k_{i}-1}$ we have that

[TABLE]

where we take the max over either characterisation of the base polyhedron.

We see that as long as we take a $w$ compatible with the ordering $\rho$, we will get a subgradient for the function $f_{\downarrow}(\rho)$. Restricting to the $\rho$ that will give us points in the domain of our original submodular function $f$, we get an element of the subdifferential of $f$.

Now we can construct a lower bound. First, we construct a set $A$ with $r$ elements, each of which corresponds to an increment of one of the $n$ basis vectors. There are $k_{i}-1$ copies of the increment of element $i$. Note that such a set $A$ corresponds to a chain defined by

[TABLE]

Take a permutation of $A$ denoted by $\sigma$ and form its corresponding chain $\mathcal{C}_{\sigma}$. Ensure $\sigma$ is such that the chain $p_{i}$ contains $z$, something we define now.

Definition 2.2** (Chain containing an element).**

Let $p_{i}$ be a chain as defined in Equation (12). We say the chain contains $x$, for some vector $x=(x_{1},\ldots,x_{n})$, if we have $p_{x_{1}+\ldots+x_{n}}=x$.

Note that any chain that contains a vector $y$ is compatible with the ordering of the $\rho$ that corresponds to $y$. In particular, we’ll take the chain $C_{\sigma}$ where we increment the first element to $y_{1}$, then the second to $y_{2}$ and so on. After it reaches $y$, we let it have any behaviour. Then we can form $w$ by taking differences of successive elements of the chain.

Now we can form the function corresponding to the lower bound by making $w$ as described earlier. This will be denoted by

[TABLE]

To extend this definition to an entire point $x=(x_{1},x_{2},\ldots,x_{n})$ we can do the following:

[TABLE]

Now note that for each $p_{i}$ in the chain, we have that

[TABLE]

In particular, note that as $y$ is contained in this chain, we have that

[TABLE]

Then due to the fact that this is a subgradient, we have that

[TABLE]

for all $x$. This is parameterised by $y,\sigma$ and is tight at $y$.

2.3 Upper Bound

In [10], an upper bound was derived for a submodular set function. This can be extended, but it does require DR-submodularity. We show now how to get around that as follows if we know one particular quantity:

Lemma 2.2**.**

Let $f$ be a lattice submodular function. Then $f$ can be represented as the sum of a modular function $g$ and a DR-submodular function $h$.

Proof.

Let $\lambda$ be the largest second difference of the function $f$ that violates the DR property, or at least an upper bound of it. Because of submodularity, we know the difference will be a second difference entirely within one basis element. Namely, take:

[TABLE]

Then let $g=\lambda(x_{1}^{2}+\ldots+x_{n}^{2})$. This will give us $h=f-g$ DR-submodular as required. ∎

Computing the exact tight value of $\lambda$ is often hard, but there are some cases where it will be easier to derive upper bounds:

If the function $f$ is the discretisation of a continuous function, we can compute the largest positive eigenvalue, or an upper bound of it, via a number of eigenvalue algorithms. 2. 2.

If the function $f$ is also $L^{\natural}$-convex (or midpoint convex), the function is convex-extensible [13], and so proceed similarly to above. 3. 3.

If the function $f$ is a quadratic program, with $f(x)=x^{T}Ax+b^{T}x+c$, then we have that $\lambda$ is the maximum positive diagonal element of $A$ (or [math] if none exist).

The idea now here is that we will let $f=g+h$, and then derive a modular and tight upper bound for $h$, thus giving our modular and tight upper bound for $f$ as $g$ is already modular. The aim for that is to generalise the bounds found in [10], given as

[TABLE]

In this section, we assume that $f$ is a lattice submodular function given on the product of sets $\{0,\ldots,k_{i}-1\}$. The extension of these bounds is given in the following lemma:

Lemma 2.3**.**

Let $f$ be a DR-submodular function as described. Let $m(x)=\max(x,0)$ with $m$ extending its arguments to vectors componentwise. Let $x,y$ be vectors in $\prod_{i}\{0,\ldots,k_{i}\}$. Let

[TABLE]

Then we have the following:

[TABLE]

where $e_{i}$ are the usual basis vectors.

Proof.

We first show the following bounds:

[TABLE]

The proof proceeds similarly to the derivation in [10], but with unions and intersections replaced with mins and maxes respectively. We start with the second statement. Take an arbitrary $x,y$ with $a_{i},b_{i}$ as before. Then note we have

[TABLE]

where we take $a_{0},e_{0}=0$. Here $\rho_{a,b}(c)$ denotes the marginal return on adding the value $a$ in the basis vector $b$ when the function already has argument $c$. Using the DR-submodular property, we then see

[TABLE]

Similarly, we’ll now consider the following expression:

[TABLE]

Subtracting these two gives us the required result. We now proceed to the first statement. We get the first inequality similarly to just how we proceeded:

[TABLE]

The second also coming easily:

[TABLE]

And again we subtract to get the first bounds that we wanted. To get to the required result, simply apply DR-submodularity to the final term of the first bound and the second term of the second bound. ∎

We note that these bounds are separable. Additionally, we see that these bounds are tight at $x$, namely equality is achieved with $y=x$. This result also applies as written for continuous submodular functions, where the vectors $x,y$ instead belong to $[0,1]^{n}$ WLOG.

3 Three algorithms

We describe the integer lattice majorisation-minimisation algorithms here, in Algorithms $1,2,3$. In Algorithm $1$, note that at every step we are minimising a lattice submodular function, which as shown in [2] to get this to arbitrary precision we have complexity $\mathcal{O}((\frac{2GBn}{\varepsilon})^{3}\log(\frac{2GBn}{\varepsilon}))$, for a continuous submodular function defined on $[0,B]^{n}$ with Lipschitz constant $G$ (note that the author minimises a discretised version of the continuous function). For Algorithm $2$, we are instead maximising, for which we have an approximation factor of $1/3$ [7] and runs in $\mathcal{O}(kn)$ calls. For Algorithm $3$, we are at each point minimising a modular function, which can be done easily in $\mathcal{O}(k^{\prime})$ function evaluations, where we have $k^{\prime}=\sum_{i}k_{i}$, by evaluating each separated function at every point and taking the $n$ minima. Additionally, we note that Algorithms $2,3$ will require in principle an upper bound on the quantity $\lambda$ as described in Lemma $2.2$.

We note that we have quite easily:

[TABLE]

the second to last equality coming from the demonstrated tightness of our bounds. However, we note that the sequence may not strictly decrease, and we seek a convergence condition. For the upper bound, we can simply say try both of them, and if neither strictly decreases the function, we’re done. For the lower bound, there are many permutations we can change and we want some sort of a stopping criterion.

Lemma 3.1**.**

If we choose $\mathcal{O}(n)$ permutations each with different increments directly before and after $x_{t}$, and attempt to decrease with both upper bounds and we are not successful, then we have reached a local minimum.

Proof.

Proof is functionally identical to the set function case as in [10], except instead of saying we consider all $g(X\cup j),g(X\setminus j)$, we just consider all $g(x+e_{i}),g(x-e_{i})$ where $e_{i}$ are basis vectors. ∎

4 Theoretical Analysis

We note that we don’t get any multiplicative approximation guarantees, as the hardness results are inherited from the set function case. However, we would like to extend the additive hardness results of [10]. While following their proof will rely on $f$ being DR-submodular, we recall we can write $f=g+h$ for $g$ modular and $h$ DR-submodular via Lemma $2.2$.

So now we act just on the DR-submodular function. This requires an extension of the decomposition from [5] which we give in a slightly weaker form:

Lemma 4.1**.**

Let $f$ be any DR-submodular function with $f(0)=0$. It can be decomposed into a modular function $g$ plus a monotone function $h$ with $h(0)=0$.

Proof.

We first construct the modular function $g$, then show that the function $h=f-g$ is monotone, and takes the value [math] at [math]. For any input $y$ we form:

[TABLE]

for $0<j\leq y_{k}$ for each $k$. We note this decays to the modular function in [5] if we restrict all $y_{k}$ to $\{0,1\}$. This function is clearly modular. Additionally, it is clear that $h=f-g$ has $h(0)=0$. To show that it is monotone:

[TABLE]

Note that in the first equation, there will be one extra term subtracted, $\frac{m_{i,k_{i}+1}}{k_{i}+1}$. We claim the right hand side of the first equation here is greater than the second, as:

[TABLE]

We then split up the second term to get:

[TABLE]

and use the DR property to bound each individual term by $f(k+e_{i})-f(k)$, giving us our result. ∎

Using this, we now have the following combining the two decompositions:

Theorem 4.1**.**

Let $f$ be a lattice submodular function with $f(0)=0$. Then $f$ can be represented as the sum of a modular function $g$ and a monotone submodular function $h$, with $h(0)=0$.

This will allow us to get additive bounds similar to [10]:

Lemma 4.2**.**

Consider the problem of minimising $f(x)-g(x)$. Apply our decomposition to instead have $v(x)=f^{\prime}(x)-g^{\prime}(x)+k(x)$. Here $k$ is modular, and $f,g$ are monotone. Then we have:

[TABLE]

Proof.

We have:

[TABLE]

by monotonicity of $g^{\prime}$. Next, we continue from the previous line:

[TABLE]

∎

The nested optimisation problem here in the second bound is non-trivial, but for our purposes it doesn’t actually need to be solved. All we need to see is that by setting $y$ to zero, we can eliminate this term and thus by the monotonicity of $f^{\prime},g^{\prime}$, we will always get that this second bound is less than zero.

We also prove some other results that show this algorithm can be broadly applied. The first results shows that we can efficiently minimise many functions using this approach:

Lemma 4.3**.**

Let $v(x)$ be any function on the lattice $\{0,\ldots,k_{i}-1\}$. Then $v$ can be written as the difference of two submodular functions.

Proof.

Let $g$ be any strictly submodular function on the same lattice, that is, one with all second differences over pairs $i\neq j$ strictly less than zero. We shall denote by $m$ the minimum absolute value of the second differences over all pairs $i\neq j$ and $x$, that is:

[TABLE]

As all second differences of $g$ are less than zero as its submodular, note for any other difference $m^{\prime}$ we have $\frac{m^{\prime}}{m}\leq-1$. We shall additionally define $n$ to be the maximum absolute value of the second difference of $v$ under the same constraint:

[TABLE]

We can now form the function $f$:

[TABLE]

We claim that $f$ is submodular, which will give our result, as a submodular function scaled by a constant is submodular. To do this, take any of the second differences over pairs $i\neq j$ of the function $f$. Denote the second difference as $D_{i,j}(f)(x)$. We find:

[TABLE]

as required. ∎

Of course, $n,m$ is in general hard to find, so another question that may be asked regarding this problem is how difficult it is to find the functions $f,g$ corresponding to some $v$. That is answered with this result, extending [10]:

Lemma 4.4**.**

Suppose that we know $n$, or a lower bound on $n$ as in the previous lemma. Then given a function $v$, we can construct submodular functions $f,g$ such that $v(x)=f(x)-g(x)$.

Proof.

Consider the submodular function on $\prod_{i}\{0,\ldots,k_{i}-1\}$:

[TABLE]

We can clearly verify here that $g$ is strictly submodular, and we have $m=-4$. Thus if we know a lower bound on $n$ we can form $f$ in the manner of Lemma $4.3$ as required. ∎

Note that the choice of $g$ in the proof above is not special, it simply needs to be submodular and we need to know its $m$. Thus depending on the particular problem $v(x)$, different choices of $g$ may give nice or meaningful decompositions.

To do complexity analysis, we will be working on an $\epsilon$-approximate version of the algorithm, introduced in [15]. This means that we will only proceed to step $t+1$ if we have $v(x^{t+1})\leq(1+\epsilon)v(x^{t})$. The reason we do this comes from [10], as we know this problem for set functions is PLS-complete. We now consider the complexity of this procedure. The complexity in minimising the lattice version can be found from a lemma whose statement and proof can be adapted directly from [10]:

Lemma 4.5**.**

The $\epsilon$-approximate version of each algorithm has a worst case complexity of $\mathcal{O}(\frac{\log(|M|/|m|)}{\epsilon}T)$, where $T$ is the complexity of the iterative step, $M=f^{\prime}(0)-g^{\prime}(k_{max})$ and $m=v(x^{1})$.

We also note that as described earlier, the ModMod procedure has the lowest complexity at each iteration.

4.1 Constrained Optimisation

For the SubSup procedure, we are minimising a submodular function with some constraint at every iteration. However, we know that this is hard, and also hard to approximate [18] for the set function case, and so will be for ours also. Therefore this algorithm is not suitable for using constraints.

We know that for some simple constraints such as cardinality, knapsack and polymatroid, the submodular maximisation problem has been studied on the integer lattice for monotone functions [17]. So at least for some subclasses, we can use the SupSub procedure to optimise under constraints.

While to the best of our knowledge no-one has explicitly written algorithms for modular minimisation on the integer lattice, we know it is easy and can be done exactly at least for cardinality constraints, where we can just enumerate all marginal gains and take the lowest in each variable. We will then take the $B$ lowest, where our cardinality constraint says $x(V)\leq B$.

In the set function case, we can optimise easily and exactly over a variety of other constraints [10]. However, here our separability also gives us linearity, something we lose on our lattice as we separate to arbitrary discrete functions. It is worth looking into more of these constrained optimisation problems.

5 Conclusion

In [10], the authors studied the problem of minimising the difference between two submodular set functions. We have extended this to the case of general lattice submodular functions, without the DR requirement. Additionally, we note that via discretisation, our method can be applied to continuous functions also.

In performing the majorisation-minimisation technique, we extended an earlier bound from [10] for the upper bound, which is valid for DR-submodular functions, and used a decomposition for submodular functions into DR-submodular functions plus a modular function to take advantage of it. For the lower bound, we used the method of computing the subgradient as in [2]. The result of this greedy algorithm gives us our lower bound, and did not require $f$ to be DR-submodular.

After that we formally stated our algorithms, performed some complexity analysis, and analysed other theoretical properties of it. One clear extension on this work would be finding an alternative lower bound that can be used on continuous functions, as our upper bound can already be used in this context.