Diversity of Solutions: An Exploration Through the Lens of Fixed-Parameter Tractability Theory

TL;DR

This paper introduces a fixed-parameter tractability approach to generating diverse collections of solutions for combinatorial problems, providing a systematic framework that automatically adapts existing algorithms with polynomial dependence on diversity.

Contribution

It develops a novel algorithmic framework that transforms standard dynamic programming algorithms into ones capable of producing diverse solutions efficiently.

Findings

Framework automatically converts algorithms for diverse solutions

Polynomial dependence on the diversity parameter

Applicable to a wide range of combinatorial problems

Abstract

When modeling an application of practical relevance as an instance of a combinatorial problem X, we are often interested not merely in finding one optimal solution for that instance, but in finding a sufficiently diverse collection of good solutions. In this work we initiate a systematic study of diversity from the point of view of fixed-parameter tractability theory. First, we consider an intuitive notion of diversity of a collection of solutions which suits a large variety of combinatorial problems of practical interest. We then present an algorithmic framework which --automatically-- converts a tree-decomposition-based dynamic programming algorithm for a given combinatorial problem X into a dynamic programming algorithm for the diverse version of X. Surprisingly, our algorithm has a polynomial dependence on the diversity parameter.

Equations

$$\mathrm{HamDist}(S,S^{\prime })=|S\backslash S^{\prime }|+|S^{\prime }\backslash S|.$$

$$\mathrm{Div}(S_1,\dots ,S_r)=\sum _{1\le i<j\le r}\mathrm{HamDist}(S_i,S_j).$$

$${\mathrm{Div}}^d({\mathcal{P}}_1,\dots ,{\mathcal{P}}_r)=\{$$

$$\mathrm{Div}(X_1,\dots ,X_r)\ge d\}.$$

$$\mathrm{Div}(S_1,\dots ,S_r)=\sum _{1\le i<j\le r}\mathrm{HamDist}(S_i,S_j).$$

$$\mathrm{HamDist}(S,S^{\prime })=\sum _{v\in V}\gamma (S,S^{\prime },v),$$

$$\begin{array}[]{ll}\mathrm{Div}(S_{1},\ldots,S_{r})&=\sum_{1\leq i<j\leq r}\sum_{v\in V}\gamma(S_{i},S_{j},v)\\ \\ &=\sum_{v\in V}|\{\ell\;:\;v\in S_{\ell}\}|\cdot|\{\ell\;:\;v\notin S_{\ell}\}|.\end{array}$$

$$I(S_1,\dots ,S_r,v)=|\{\ell :v\in S_{\ell }\}|\cdot |\{\ell :v\notin S_{\ell }\}|,$$

$$\mathrm{Div}(S_1,\dots ,S_r)=\sum _{v\in V}I(S_1,\dots ,S_r,v).$$

$${\mathcal{I}}_t=\{((S_1,s_1),\dots ,(S_r,s_r),\ell )\mid \ell \in \left[0,d\right],\forall i\in \left[1,r\right],S_i\subseteq X_t,s_i\in \left[0,k\right]\}.$$

$$\mathcal{O}(2^r\cdot (2^{w+1}\cdot (k+1){)}^{a\cdot r}\cdot d^a\cdot w\cdot r\cdot n),$$

$$\mathrm{Size}(\mathfrak{C},G,\mathcal{D})=\max \{|{\mathrm{Process}}_{\mathfrak{C},G,\mathcal{D}}(t)|\mid t\in V(\mathcal{D})\}.$$

$$\mathcal{O}\left(\sum _{t\in V(T)}|{\mathrm{Process}}_{\mathfrak{C},G,\mathcal{D}}(t)|+\tau (\mathfrak{C},G,\mathcal{D})\right).$$

$$\beta :V(\mathrm{subtree}(T,t))\to \{0,1{\}}^{\ast }$$

$$(\beta (t^{\prime }),\beta (t_1),\dots ,\beta (t_{\delta (t)}))\in {\mathrm{Process}}_{\mathfrak{C},G,\mathcal{D}}(t)$$

$$S_{\rho }(G,\mathcal{D},\alpha )=\{v\mid \exists t\in V(T_{\mathcal{D}}),\rho (v,\alpha (t))=1\}$$

$$\mathcal{O}(d^a\cdot |V(T)|\cdot \prod _{i=1}^r\mathrm{Size}({\mathfrak{C}}_i,G,\mathcal{D})+\sum _{i=1}^r\tau ({\mathfrak{C}}_i,G,\mathcal{D})),$$

$$I(w_1,\dots ,w_r,v)=I({\hat{\rho }}_1(w_1),\dots ,{\hat{\rho }}_r(w_r),v).$$

$$\begin{array}[]{l}\{((w_{1},\ldots,w_{r},\ell),(w_{1}^{1},\ldots,w_{r}^{1},\ell^{1}),\ldots,(w_{1}^{\delta(t)},\ldots,w_{r}^{\delta(t)},\ell^{\delta(t)}))\mid\\ \quad\forall i\in[1,r],(w_{i},w_{i}^{1},\ldots,w_{i}^{\delta(t)})\in\mathrm{Process}_{\mathfrak{C}_{i},G,\mathcal{D}}(t),\\ \quad s=\sum_{i\in[1,\delta(t)]}\ell^{i}+\sum_{v\in\mathrm{forg}(t)}I(w_{1},\ldots,w_{r},v),\ell=\min\{s,d\}\}.\end{array}$$

$$\beta (q)=\min \{d,\sum _{t\in V(\mathcal{D})}\sum _{v\in \mathrm{forg}(t)}I({\alpha }_1(t),\dots ,{\alpha }_r(t),v)\}\ge d.$$

$$(G,S_{{\rho }_1}(G,\mathcal{D},{\alpha }_1),\dots ,S_{{\rho }_r}(G,\mathcal{D},{\alpha }_r))$$

$$\mathcal{O}(d^{\delta (t)}\cdot |V(T)|\cdot \prod _{i=1}^r\mathrm{Size}({\mathfrak{C}}_i,G,\mathcal{D})+\sum _{i=1}^r\tau ({\mathfrak{C}}_i,G,\mathcal{D})).$$

$${\mathrm{Accept}}_{\mathfrak{C},G,\mathcal{D}}$$

$${\mathrm{Process}}_{\mathfrak{C},G,\mathcal{D}}(t)$$

$$E(G[X_t\setminus S])=\varnothing ,$$

$$\forall i\in \left[1,\delta (t)\right]:S^i\cap X_t=S\cap X_{t_i},$$

$$s=|\mathrm{forg}(t)\cap S|+{\sum }_{t=1}^{\delta (t)}{s}^i\}$$

$$\mathcal{O}(d\cdot |V(G)|\cdot (2^{k+2}\cdot (k+1){)}^r+|V(G)|\cdot 2^{k+1}\cdot (k+1)\cdot k).$$

$$X\in \mathrm{sol}(I,k^{\prime })\iff F\subseteq X\text{mbox}and$$

$$X\setminus (F\cup A^{\prime \prime })\in \mathrm{sol}(I^{\prime },k^{\prime }-|F\cup A^{\prime \prime }|).$$

$$X^{\prime }\in \mathrm{sol}(I^{\prime },k^{\prime })\iff X\cup A^{\prime \prime }\in \mathrm{sol}({\mathsf{rec}}_I(I^{\prime },A^{\prime }),k^{\prime }+|A^{\prime \prime }|).$$

$$\mathrm{Div}(S_1^{\ast },\dots ,S_r^{\ast })\ge \mathrm{Div}(\mathcal{S})-(r-1){\sum }_{i=1}^r|A_i|.$$

$$\mathrm{Div}({\mathcal{S}}^{\prime })$$

Full text

Keywords: Diversity, Combinatorial Optimization, Dynamic Programming.

1 Introduction

In a typical combinatorial optimization problem, we are given a large space of potential solutions and an objective function. The task is to find a solution that maximizes or minimizes the objective function. In many situations of practical relevance, however, it does not really help to get just one optimal solution; it would be much better to have a small, but sufficiently diverse collection of sufficiently good solutions. Given such a small list of good solutions, we can select one which is best for our purpose, perhaps by taking into account external factors—such as aesthetical, political, or environmental—which are difficult or even impossible to formalize. An early, illustrative example is the problem of generating floor plans for evaluation by an architect [19].

Solution diversity is already a fundamental concept in many computational tasks. Take, for instance, a web search. Here, we do not want to find the one website that ‘optimally fits’ the search term, neither a ranking of a small number of ‘best fits’, but what is desirable is a diverse set of websites that fit the search term reasonably well.

Another advantage of considering a set of diverse solutions is that some of these solutions may find some use in contexts which are not specified à priori. For instance, in cutting problems [24], which are widely studied in the field of operations research, we are given a piece of material of standard size and a prescribed set of shapes. The goal is to cut the material into pieces of the specified shapes in such a way that the amount of leftover material is minimized. In this setting, a minimum-size leftover may be viewed as a solution. A set of sufficiently diverse solutions would give the user the opportunity to choose a suitable leftover that could be used later in the fabrication of pieces whose shapes have not been specified in the input of the program.

The notion of diversity has also been applied to solution sets of various types of combinatorial problems. For instance, the works [20] and [25, 26] seek to find solution sets to mixed-integer programming problems and constraint satisfaction problems, respectively, that are diverse. In other words, the solutions are far apart from each other in some mathematical notion of distance. We refer to [32] for a timely overview of the subject.

From a complexity-theoretic perspective, there are two immediate barriers to this approach. The first is that most combinatorial problems are already NP-hard when asking only for a single solution. The second is that the very basic Maximum Diversity problem, which given a set of $n$ elements in a metric space and an integer $k<n$, asks for a size-$k$ subset of the elements such that the sum of the pairwise distances is maximized, is NP-hard as well [28]. The theory of fixed-parameter tractability [14] provides a powerful framework to overcome these barriers. The key goal is to identify a secondary numerical measure of the inputs to an (NP-hard) computational problem, called the parameter, and to provide algorithms in whose runtime the combinatorial explosion is restricted to the parameter $k$. More formally, a problem is fixed-parameter tractable (FPT), if it can be solved in time $f(k)\cdot n^{c}$, where $f$ is a computable function, $n$ the input size, and $c$ a fixed constant. On instances where the parameter value is relatively small, FPT-algorithms are efficient. In an application context, we are naturally concerned with finding small diverse sets of solutions since the aim is to provide the user with a few alternatives that can then be compared manually. Therefore, the number of requested solutions is an ideal candidate for parameterization.

In this work, we propose to study the notion of solution diversity from the perspective of fixed-parameter tractability theory. We demonstrate the theoretical feasibility of this paradigm by showing that diverse variants of a large class of parameterized problems admits FPT-algorithms. Specifically, we consider vertex-problems on graphs, which are sets of pairs $(G,S)$ of a graph $G$ and a subset $S$ of its vertices that satisfies some property. For instance, in the Vertex Cover problem, we require the set $S$ to be a vertex cover of $G$ (i.e., $S$ has to contain at least one endpoint of each edge of $G$). One consequence of our main result which we discuss below in more detail is that the diverse variant of Vertex Cover, asking for $r$ solutions, is FPT when parameterized by solution size plus $r$.

Before we proceed, we would like to point out promising future applications of the Diverse FPT paradigm in AI. The Vertex Cover problem itself naturally models conflict-resolution: the entities are the vertices of the graph, and a conflict is represented by an edge. Now, a vertex cover of the resulting graph is a set of entities whose removal makes the model conflict-free. An example of a potential use of Diverse Vertex Cover in a planning scenario is given in [5]. In general, in planning and scheduling problems, a large amount of side information is lost or intentionally omitted in the modeling process. Some side information could make the model too complex to be solved, and other information may even be impossible to model. Offering the user a small number of good solutions to a more easily computable ‘base model’, among which they can handpick their favorite solution is a feasible alternative.

A Formal Notion of Diversity

We choose a very natural and general measure as our notion of diversity among solutions. Given two subsets $S$ and $S^{\prime}$ of a set $V$ the Hamming distance between $S$ and $S^{\prime}$ is the number

[TABLE]

We define the diversity of a list $S_{1},\ldots,S_{r}$ of subsets of $V$ to be

[TABLE]

We can now define the diverse version of vertex-problems:

Definition 1** (Diverse Problem).**

Let $\mathcal{P}_{1},\ldots,\mathcal{P}_{r}$ be vertex-problems, and let $d\in\mathbb{N}$. We let

[TABLE]

Intuitively, given vertex-problems $\mathcal{P}_{1},\ldots,\mathcal{P}_{r}$ and a graph $G$, we want to find subsets $S_{1},\ldots,S_{r}$ of vertices of $G$ such that for each $i\in\{1,\ldots,r\}$, $S_{i}$ is a solution for problem $\mathcal{P}_{i}$ on input $G$, and such that the list $S_{1},\ldots,S_{r}$ has diversity at least $d$. If all vertex-problems $\mathcal{P}_{1},\ldots,\mathcal{P}_{r}$ are the same problem $\mathcal{P}$, then we write $\mathrm{Div}^{d}_{r}(\mathcal{P})$ as a shortcut to $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$.

Diversity and Dynamic Programming

The treewidth of a graph is a structural parameter that quantifies how close the graph is to being a forest (i.e., a graph without cycles). The popularity of this parameter stems from the fact that many problems that are NP-complete on general graphs can be solved in polynomial time on graphs of constant treewidth. In particular, a celebrated theorem due to Courcelle  (see [11]) states that any problem expressible in the monadic second-order logic of graphs can be solved in polynomial time on graphs of constant treewidth. Besides this metatheorem, the notion of treewidth has found applications in several branches of Artificial Intelligence such as Answer Set Programs [6], checking the consistency of certain relational algebras in Qualitative Spacial Reasoning [7], compiling Bayesian networks [10], determining the winners of multi-winner voting systems [36], analyzing the dynamics of stochastic social networks [3], and solving constraint satisfaction problems [27]. A large number of these algorithms are in fact FPT-algorithms when treewidth is the parameter. Typically, such algorithms are dynamic programming algorithms which operate on a tree-decomposition in a bottom-up fashion by computing data from the leaves to the root.

Dynamic Programming Core Model

We introduce a formalism for dynamic programming based on a tree decomposition, which we call the Dynamic Programming Core model. This notion captures a large variety of dynamic programming algorithms on tree decompositions. We use the model to derive our main result (Theorem 10) which is a framework to efficiently—and automatically—transform treewidth-based dynamic programming algorithms for vertex-problems into algorithms for the diverse versions of these problems. More precisely, we show that if $\mathcal{P}_{1},\ldots,\mathcal{P}_{r}$ are vertex-problems where, for each $i\in\{1,\ldots,r\}$, $\mathcal{P}_{i}$ can be solved in time $f_{i}(t)\cdot n^{\mathcal{O}(1)}$, then $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$ can be solved in time $\left(\prod_{i=1}^{r}f_{i}(t)\right)\cdot n^{\mathcal{O}(1)}$. In particular, if a vertex-problem $\mathcal{P}$ can be solved in time $f(t)\cdot n^{\mathcal{O}(1)}$, then its diverse version $\mathrm{Div}_{r}^{d}(\mathcal{P})$ can be solved in time ${f(t)}^{r}\cdot n^{\mathcal{O}(1)}$. The surprising aspect of this result is that the running time depends only polynomially on $d$ (which is at most $r^{2}n$), while a naïve dynamic programming algorithm would have a runtime of $d^{\mathcal{O}(r^{2})}\cdot f(t)^{r}\cdot n^{\mathcal{O}(1)}$.

Discussion of the Diversity Measure

Various measures of diversity have been used, studied, and compared in different areas of computer science. We choose the sum of the Hamming distances over all pairs of elements for this work. This measure is commonly used for population diversity in genetic algorithms [18, 35]. Nonetheless, we would like to point out that it has some weaknesses. For instance, taking many copies of two disjoint solutions yields a relatively high diversity value, and such a solution set is not ‘diverse’ from an intuitive point of view. We refer to [5] for a more detailed discussion. Another natural measure using the Hamming distance is the minimum Hamming distance over all pairs in a set, as it is done e.g. in [25, 26]. We would like to point out that a straightforward adaptation of our algorithmic framework would result in a running time of $d^{\mathcal{O}(r^{2})}\cdot f(t)^{r}\cdot n^{\mathcal{O}(1)}$, where $d$ is the diversity, $r$ the number of solutions, and $t$ the treewidth. This remains FPT only when the diversity $d$ is an additional component of the parameter, or when $d$ is naturally upper bounded by $t$ and $r$. Consider for instance Diverse Vertex Cover, asking for vertex covers of size at most $k$. In any nontrivial instance, $t$ is at most $k$, and the Hamming distance between two solutions is at most $2k$, therefore we may assume that $d\leq 2k$. This implies that Diverse Vertex Cover can be solved in time $2^{\mathcal{O}(r^{2}\log k)+kr}\cdot n^{\mathcal{O}(1)}$ using the minimum Hamming distance as a diversity measure.

Related Work

The above-mentioned Maximum Diversity problem has applications in the generation of diverse query results, see e.g. [21, 1]. Besides mixed integer programming [20, 13, 31], binary integer linear programming [22, 34] and constraint programming [25, 26], diverse solution sets have been considered in SAT solving [30], recommender systems [2], routing problems [33], answer set programming [15], and decision support systems [29, 23].

2 Preliminaries

For positive integers $a$ and $b$, with $a<b$, we use $\left[a,b\right]$ to denote the set $\{a,a+1,\ldots,b\}$. We use $V(G)$ and $E(G)$, respectively, to denote the vertex and edge sets of a graph $G$. For a tree $T$ rooted at $q$ we use $T_{t}$ to denote the subtree of $T$ rooted at a vertex $t\in V(T)$. A rooted tree decomposition of a graph $G$ is a tuple ${\cal D}=(T,q,{\cal X})$, where $T$ is a tree rooted at $q\in V(T)$ and ${\cal X}=\{X_{t}\mid t\in V(T)\}$ is a collection of subsets of $V(G)$ such that:

• •

$\bigcup_{t\in V(T)}X_{t}=V(G)$,

• •

for every edge $\{u,v\}\in E(G)$, there is a $t\in V(T)$ such that $\{u,v\}\subseteq X_{t}$, and

• •

for each $\{x,y,z\}\subseteq V(T)$ such that $z$ lies on the unique path between $x$ and $y$ in $T$, $X_{x}\cap X_{y}\subseteq X_{z}$.

We say that the vertices of $T$ are the nodes of ${\cal D}$ and that the sets in ${\cal X}$ are the bags of ${\cal D}$. Given a node $t\in V(T)$, we denote by $G_{t}$ the subgraph of $G$ induced by the set of vertices $\bigcup_{s\in V(T_{t})}X_{s}.$ The width of a tree decomposition ${\cal D}=(T,q,{\cal X})$ is defined as $\max_{t\in V(T)}|X_{t}|-1$. The treewidth of a graph $G$, denoted by ${\sf{tw}}(G)$, is the smallest integer $w$ such that there exists a rooted tree decomposition of $G$ of width at most $w$. The rooted path decomposition of a graph is a rooted tree decomposition ${\cal D}=(T,q,{\cal X})$ such that $T$ is a path and $q$ is a vertex of degree $1$. The pathwidth of a graph $G$, denoted by ${\sf{pw}}(G)$, is the smallest integer $w$ such that there exists a rooted path decomposition of $G$ of width at most $w$. Note that in a rooted path decomposition, every node has at most one child.

For convenience we will always assume that the bag associated to the root of a rooted tree decomposition is empty. For a node $t\in{}V(T)$ we use $\delta_{\mathcal{D}}(t)$, or $\delta(t)$ when $\mathcal{D}$ is clear from the context, to denote the number of children of $t$ in the tree $T$. For nodes $t$ and $t^{\prime}$ of $V(T)$ where $t^{\prime}$ is the parent of $t$ we use $\mathrm{forg}(t)={X}_{t}\setminus{X}_{t^{\prime}}$ to denote the set of vertices of $G$ which are forgotten at $t$. By convention, for the root $q$ of $T$, we let $\mathrm{forg}(q)=\emptyset$. For $t\in{}V(T)$ we denote by $\mathrm{new}(t)$ the set $X_{t}\setminus\bigcup_{i=1}^{\delta(t)}X_{t_{i}}$ where $t_{1},\ldots,t_{{\delta(t)}}$ are the children of $t$. Given a rooted tree decomposition $\mathcal{D}$ of a graph $G$ one can obtain, in linear time, a tree decomposition $(T,q,\mathcal{X})$ of $G$ of the same width as $\mathcal{D}$ such that for each $t\in V(T)$, $\delta(t)\leq 2$ and $|\mathrm{new}(t)|\leq 1$ [12]. From now on we assume that every rooted tree decomposition is of this kind.

3 A First Example: Diverse Vertex Cover

The main result of this paper is a general framework to automatically translate tree-decomposition-based dynamic programming algorithms for vertex-problems into algorithms for the diverse versions of these problems. We develop this framework in Section 4. In this section we illustrate the main techniques used in this conversion process by showing how to translate a tree-decomposition-based dynamic programming algorithm for the Vertex Cover problem into an algorithm for its diverse version Diverse Vertex Cover. Given a graph $G$ and three integers $k$, $r$, and $d$, the Diverse Vertex Cover problem asks whether one can find $r$ vertex covers in $G$, each of size at most $k$, such that their diversity is at least $d$. Our algorithm for this problem will run in $2^{\mathcal{O}{(kr)}}|V(G)|$ time.

3.1 Incremental Computation of Diversity

Recall that we defined the diversity of a list $S_{1},S_{2},\ldots,S_{r}$ of subsets of a set $V$ to be

[TABLE]

We will now describe a way to compute the diversity $\mathrm{Div}(S_{1},\ldots,S_{r})$ in an incremental fashion, by incorporating the influence of each element of $V$ in turn. For each element $v\in V$ and each pair of subsets $S,S^{\prime}$ of $V$, we define $\gamma(S,S^{\prime},v)$ to be $1$ if $v\in(S\setminus{}S^{\prime})\cup(S^{\prime}\setminus{}S)$, and to be [math] otherwise. Intuitively, $\gamma(S,S^{\prime},v)$ is $1$ if and only if the element $v$ contributes to the Hamming distance between $S$ and $S^{\prime}$. Given this definition we can rewrite $\mathrm{HamDist}(S,S^{\prime})$ as

[TABLE]

and the diversity of a list $S_{1},\ldots,S_{r}$ of subsets of $V$ as

[TABLE]

Now, if we define the influence of $v$ on the list $S_{1},\ldots,S_{r}$ as

[TABLE]

then we have that

[TABLE]

3.2 From Vertex Cover to Diverse Vertex Cover

We now solve Diverse Vertex Cover using dynamic programming over a tree decomposition of the input graph. An excellent exposition of tree-width-based dynamic programming algorithms can be found in [12, Chapter 7].

Let $(G,k,r,d)$ be an instance of Diverse Vertex Cover and let $\mathcal{D}=(T,q,\mathcal{X})$ be a rooted tree decomposition of $G$. For each node $t\in V(T)$, we define the set

[TABLE]

This set $\mathcal{I}_{t}$, $t\in V(T)$, is such that the partial solutions we will construct for the node $t$ will always be a subset of $\mathcal{I}_{t}$. Note that for each $t\in V(T)$, $|\mathcal{I}_{t}|\leq(2^{|X_{t}|}\cdot(k+1))^{r}\cdot(d+1)$. Now, our dynamic programming algorithm for Diverse Vertex Cover consists in constructing for each $t\in V(T)$ a subset $\mathcal{R}_{t}\subseteq\mathcal{I}_{t}$ as follows. Let $t$ be a node in $V(T)$ with children $t_{1},\ldots,t_{\delta(t)}$. We recall that, by convention, this set of children is of size [math], $1$, or $2$. We let $\mathcal{R}_{t}$ be the set of all tuples $((S_{1},s_{1}),\ldots,(S_{r},s_{r}),\ell)\in\mathcal{I}_{t}$ satisfying the following additional properties:

For each $j\in\left[1,r\right]$, $E(G[X_{t}\setminus S_{j}])=\emptyset$. 2. 2.

For each $i\in\left[1,\delta(t)\right]$ there exists a tuple $((S_{1}^{i},s_{1}^{i}),\ldots,(S_{r}^{i},s_{r}^{i}),\ell_{i})$ in $\mathcal{R}_{t_{i}}$ such that

1. (a)

$S_{j}\cap X_{t_{i}}=S_{j}^{i}\cap X_{t}$ for each $i\in\left[1,\delta(t)\right]$ and each $j\in\left[1,r\right]$, 2. (b)

For each $j\in\left[1,r\right]$, $s_{j}=|\mathrm{forg}(t)\cap S_{j}|+\sum_{i=1}^{\delta(t)}s_{j}^{i}$, 3. (c)

and $\ell=\min(d,m)$ where $m=\sum_{v\in\mathrm{forg}(t)}I(S_{1},\ldots,S_{r},v)+\sum_{i=1}^{\delta(t)}\ell_{i}.$

Lemma 2**.**

$(G,k,r,d)$* is a Yes-instance of Diverse Vertex Cover if and only if there is a tuple $((S_{1},s_{1}),\ldots,(S_{r},s_{r}),\ell)$ in $\mathcal{R}_{q}$ such that $\ell=d$.*

Proof.

Using induction, one can see that for each $t\in V(T)$, $\mathcal{R}_{t}$ is the set of every element of $\mathcal{I}_{t}$ such that, with $Y_{t}=X_{t}\setminus\mathrm{forg}(t)$, there exists $(\widehat{S}_{1},\ldots,\widehat{S}_{r})\in V(G_{t})^{r}$, that satisfies:

• •

for each $i\in\left[1,r\right]$, $\widehat{S}_{i}$ is a vertex cover of $G_{t}$,

• •

for each $i\in\left[1,r\right]$, $\widehat{S}_{i}\cap X_{t}=S_{i}$,

• •

for each $i\in\left[1,r\right]$, $|\widehat{S}_{i}\setminus Y_{t}|=s_{i}$, and

• •

$\min(d,\mathrm{Div}(\widehat{S}_{1}\setminus Y_{t},\ldots,\widehat{S}_{r}\setminus Y_{t}))=\ell$.

As the root $q$ of the tree decomposition $\mathcal{D}$ is such that $X_{q}=\emptyset$, we obtain that the elements in $\mathcal{R}_{q}$ are the elements $((\emptyset,s_{1}),\ldots,(\emptyset,s_{r}),\ell)$ of $\mathcal{I}_{q}$ such that there exists $(\widehat{S}_{1},\ldots,\widehat{S}_{r})\in V(G)^{r}$, that satisfy,

• •

for each $i\in\left[1,r\right]$, $\widehat{S}_{i}$ is a vertex cover of $G_{t}$,

• •

for each $i\in\left[1,r\right]$, $|\widehat{S}_{i}|=s_{i}\leq k$, and

• •

$\min(d,\mathrm{Div}(\widehat{S}_{1},\ldots,\widehat{S}_{r}))=\ell$.

As such, a tuple $(\widehat{S}_{1},\ldots,\widehat{S}_{r})$ of subsets of $V(G)$ is a solution of Diverse Vertex Cover if and only if $\ell\geq d$, the lemma follows. ∎

Theorem 3**.**

Given a graph $G$, integers $k,r,d$, and a rooted tree decomposition $\mathcal{D}=(T,q,\mathcal{X})$ of $G$ of width $w$, one can determine whether $(G,k,r,d)$ is a Yes-instance of Diverse Vertex Cover in time

[TABLE]

where $a=\max_{t\in V(T)}\delta(t)\leq 2$ and $n=|V(T)|$.

Proof.

Let us analyze the time needed to compute $\mathcal{R}_{q}$. We have that, for each $t\in V(\mathcal{D})$, $|\mathcal{I}_{t}|\leq(2^{\cdot|X_{t}|}\cdot(k+1))^{r}\cdot(d+1)$. Note that given $I_{1},\ldots,I_{\delta(t)}$ be elements of $\mathcal{R}_{t_{1}},\ldots,{\mathcal{R}_{t_{\delta(t)}}}$, there are at most $2^{|\mathrm{new}(t)|\cdot r}\leq 2^{r}$ ways to create an element $I$ of $\mathcal{R}_{t}$ by selecting, or not the (potential) new element of $X_{t}$ for each set $S_{i}$, $i\in\left[1,r\right]$. The remaining is indeed fixed by $I_{1},\ldots,I_{\delta(t)}$. Thus, $\mathcal{R}_{t}$ can be computed in time $\mathcal{O}(r\cdot|X_{t}|\cdot 2^{r}\cdot\prod_{i=1}^{\delta(t)}|\mathcal{R}_{t_{i}}|)$, where the factor $r\cdot|X_{t}|$ appears when verifying that the element we construct satisfy $\forall j\in\left[1,r\right],E(G[X_{j}\setminus S_{j}])=\emptyset$. As we need to compute $\mathcal{R}_{t}$ for each $t\in V(\mathcal{D})$ and that $|V(\mathcal{D})|=\mathcal{O}(n)$ and we can assume that $\delta(t)\leq 2$ for each $t\in V(\mathcal{D})$, the theorem follows. ∎

Remark 4**.**

Given a graph $G$ and a vertex cover $Z$ of $G$ of size $k$, one can find a rooted path decomposition $\mathcal{D}=(T,q,\mathcal{X})$ of $G$ of width $k$, in linear time.

This can be done by considering the bags $Z\cup\{v\}$ for each $v\in V(G)$ in any fixed order. Thus, from Theorem 3, we get the following corollary, which establishes an upper bound for the running time of our dynamic programming algorithm for Diverse Vertex Cover solely in terms of the size $k$ of the vertex cover, the number $r$ of requested solutions, and the diversity $d$.

Corollary 5**.**

Diverse Vertex Cover* can be solved on an input $(G,k,r,d)$ in time $\mathcal{O}((2^{k+2}\cdot(k+1))^{r}\cdot d\cdot k\cdot r\cdot|V(G)|).$*

4 Computing Diverse Solutions using the Dynamic Programming Core model

In this section, we show that the process illustrated in Section 3, of lifting a dynamic programming algorithm for a combinatorial problem to an algorithm for its diverse version, can be generalized to a much broader context. As a first step, we introduce the notion of dynamic programming core, a suitable formalization of the intuitive notion of tree-width based dynamic programming that satisfies three essential properties. First, this formalization is general enough to be applicable to a large class of combinatorial optimization problems. Second, this formalization is compatible with the notion of diversity, in the sense that the lifting of an algorithm for a problem to an algorithm for the diverse version of this problem can be done automatically, without requiring human ingenuity. Third, the resulting lifted algorithm is fast when compared with the original one. In particular, the running time of the resulting algorithm is polynomial on the diversity parameter. This is a highly desired property since this allows our framework to be applied in the context where the sizes of the considered solution sets are not bounded.

Below, we let $\mathcal{G}$ be the set of simple, undirected graphs whose vertex set is a finite subset of $\mathbb{N}$. We say that a subset $\mathcal{P}\subseteq\mathcal{G}$ is a graph problem. Intuitively, a dynamic programming algorithm working on tree decompositions may be understood as a procedure that takes a graph $G\in\mathcal{G}$ and a rooted tree decomposition $\mathcal{D}$ of $G$ as input, and constructs a certain amount of data for each node of $\mathcal{D}$. The data at node $t$ is constructed by induction on the height of $t$, and in general, this data is used to encode the existence of a partial solution on the graph induced by bags in the sub-tree of $\mathcal{D}$ rooted at $t$. In the below definition, this is captured in the relation $\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$. Such an algorithm accepts the input graph $G$ if the data associated with the root node contains a string belonging to a set of accepting strings, captured below in the set $\mathrm{Accept}_{\mathfrak{C},G,\mathcal{D}}$. We formalize this intuitive notion in the following concept of dynamic programming core.

Definition 6** (Dynamic Programming Core).**

A dynamic programming core is an algorithm $\mathfrak{C}$ that takes a graph $G\in\mathcal{G}$ and a rooted tree decomposition $\mathcal{D}$ of $G$ as input, and produces the following data.

• •

A finite set $\mathrm{Accept}_{\mathfrak{C},G,\mathcal{D}}\subseteq 2^{\{0,1\}^{*}}$.

• •

A finite set $\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)\subseteq\left(2^{\{0,1\}^{*}}\right)^{\delta(t)+1}$ for each $t\in V(\mathcal{D})$.

We let $\tau(\mathfrak{C},G,\mathcal{D})$ be the overall time necessary to construct the data associated with all nodes of $\mathcal{D}$. The size of $\mathfrak{C}$ on a pair $(G,\mathcal{D})$ is defined as

[TABLE]

Next, we define the notion of a witness for a dynamic programming core. Intuitively such witnesses are certificates of the existence of a solution.

Definition 7**.**

Let $\mathfrak{C}$ be a dynamic programming core, $G$ be a graph in $\mathcal{G}$, and $\mathcal{D}=(T,q,\mathcal{X})$ be a rooted tree decomposition of $G$. A $(\mathfrak{C},G,\mathcal{D})$-witness is a function $\alpha:V(T)\rightarrow\{0,1\}^{*}$ such that the following conditions are satisfied.

For each $t\in V(T)$, with children $t_{1},\ldots,t_{\delta(t)}$, $(\alpha(t),\alpha(t_{1}),\ldots,\alpha(t_{\delta(t)}))\in\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$. 2. 2.

$\alpha(q)\in\mathrm{Accept}_{\mathfrak{C}}$.

Using the notion of witness, we define formally what it means for a dynamic programming core to solve a combinatorial problem.

Definition 8**.**

We say that a dynamic programming core $\mathfrak{C}$ solves a problem $\mathcal{P}$ if for each graph $G\in\mathcal{G}$, and each rooted tree decomposition $\mathcal{D}$ of $G$, $G\in\mathcal{P}$ if and only if a $(\mathfrak{C},G,\mathcal{D})$-witness exists.

Theorem 9**.**

Let $\mathcal{P}$ be a graph problem and $\mathfrak{C}$ be a dynamic programming core that solves $\mathcal{P}$. Given a graph $G\in\mathcal{G}$ and a rooted tree decomposition $\mathcal{D}$ of $G$, one can determine whether $G\in\mathcal{P}$ in time

[TABLE]

Proof.

Given $\mathfrak{C}$, $G$, and $\mathcal{D}=(T,q,\mathcal{X})$, we construct the set $\mathrm{Accept}_{\mathfrak{C},G,\mathcal{D}}$ and the sets $\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$ for each $t\in V(\mathcal{D})$. By definition, this can be done in time $\tau(\mathfrak{C},G,\mathcal{D})$.

Given $t\in V(T)$ and $w\in\{0,1\}^{*}$, a $(\mathfrak{C},G,\mathcal{D},t,w)$-witness is a function

[TABLE]

such that for each $t^{\prime}\in V(\mathrm{subtree}(T,t))$, with children $t_{1},\ldots,t_{\delta(t)}$,

[TABLE]

and $\beta(t)=w$. Note that there exists a $(\mathfrak{C},G,\mathcal{D})$-witness if and only if there exists a $(\mathfrak{C},G,\mathcal{D},q,w)$-witness for some $w\in\{0,1\}^{*}$.

For each $t\in V(T)$, we define $\Pi(G,\mathcal{D},t)$ to be the set of every $w\in\{0,1\}^{*}$ such that there exists a $(\mathfrak{C},G,\mathcal{D},t,w)$-witness. Let $t\in V(T)$ and assume that we are able to construct $\Pi(G,\mathcal{D},t_{i})$ for every $i\in[1,\delta(t)]$ where $t_{1},\ldots,t_{\delta(t)}$ are the children of $t$. We can then construct $\Pi(G,\mathcal{D},t)$ as follows. For each $(w,w_{1},\ldots,w_{\delta(t)})\in\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$, we add $w$ to $\Pi(G,\mathcal{D},t)$ if for each $i\in[1,\delta(t)]$, $w_{i}\in\Pi(G,\mathcal{D},t_{i})$. It is easy to see that for each such $w$, there exists a $(\mathfrak{C},G,\mathcal{D},t,w)$-witness that is an extension of the $(\mathfrak{C},G,\mathcal{D},t_{i},w_{i})$-witness, $i\in[1,\delta(t)]$. Moreover if there exists a $(\mathfrak{C},G,\mathcal{D},t,w)$-witness $\beta$ for some $w\in\{0,1\}^{*}$, then, for each $i\in[1,\delta(t)]$, the restriction of $\beta$ to $\mathrm{subtree}(T,t_{i})$ is a $(\mathfrak{C},G,\mathcal{D},t_{i},w_{i})$-witness for some $w_{i}\in\{0,1\}^{*}$, and so, by induction hypothesis, $w_{i}\in\Pi(G,\mathcal{D},t_{i})$. This implies that our construction has correctly added $w$ to $\Pi(G,\mathcal{D},t)$. Thus $\Pi(G,\mathcal{D},t)$ is correctly constructed.

From Definition 8 we have that $G\in\mathcal{P}$ if and only if $\Pi(G,\mathcal{D},q)\not=\emptyset$. Note that the time needed to construct $\Pi(G,\mathcal{D},q)$ is $\mathcal{O}\left(\sum_{t\in V(T)}|\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\right)$. Therefore, the theorem follows. ∎

4.1 Dynamic Programming Cores for Vertex Problems

Let $\mathfrak{C}$ be a dynamic programming core. A $\mathfrak{C}$-vertex-membership function is a function $\rho:\mathbb{N}\times\{0,1\}^{*}\rightarrow\{0,1\}$ such that for each graph $G$, each rooted tree decomposition $\mathcal{D}=(T,q,\mathcal{X})$ of $G$ and each $(\mathfrak{C},G,\mathcal{D})$-witness $\alpha$, it holds that $\rho(v,\alpha(t))=\rho(v,\alpha(t^{\prime}))$ for each edge $(t,t^{\prime})\in E(T)$ and each vertex $v\in X_{t}\cap X_{t^{\prime}}$. Intuitively, if $G$ is a graph and $\mathcal{D}$ is a rooted tree decomposition of $G$, then a $\mathfrak{C}$-vertex-membership together with a $(\mathfrak{C},G,\mathcal{D})$-witness, provide an encoding of a subset of vertices of the graph. More precisely, we let

[TABLE]

be this encoded vertex set. Given a $\mathfrak{C}$-vertex-membership function $\rho$, we let $\hat{\rho}:\{0,1\}^{*}\rightarrow 2^{\mathbb{N}}$ be the function that sets $\hat{\rho}(w)=\{v\in\mathbb{N}\mid\rho(v,w)=1\}$ for each $w\in\{0,1\}^{*}$.

Let $\mathcal{P}$ be a vertex-problem, $\mathfrak{C}$ be a dynamic programming core, and $\rho$ be a $\mathfrak{C}$-vertex-membership function. We say that $(\mathfrak{C},\rho)$ solves $\mathcal{P}$ if for each graph $G\in\mathcal{G}$, each subset $S\subseteq V(G)$, and each rooted tree decomposition $\mathcal{D}$, $(G,S)\in\mathcal{P}$ if and only if there exists a $(\mathfrak{C},G,\mathcal{D})$-witness $\alpha$ such that $S=S_{\rho}(G,\mathcal{D},\alpha)$.

The following theorem is the main result of this section. It shows how to transform dynamic programming cores for problems $\mathcal{P}_{1},\dots,\mathcal{P}_{r}$ into a dynamic programming core for the problem $\mathrm{Div}^{d}(\mathcal{P}_{1},\dots,\mathcal{P}_{r})$.

Theorem 10**.**

Let $\mathcal{P}_{1},\ldots,\mathcal{P}_{r}$ be vertex-problems, let $(\mathfrak{C}_{i},\rho_{i})$ be a dynamic programming core for $\mathcal{P}_{i}$, and let $d$ be an integer. The problem $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$, on graph $G$ with rooted tree decomposition $\mathcal{D}=(T,q,\mathcal{X})$, can be solved in time

[TABLE]

where $a=\max_{t\in V(T)}\delta(t)\leq 2$.

Proof.

Let $w_{1},\ldots,w_{r}\in\{0,1\}^{*}$ and $v\in V(G)$. We extend the definition of diverse influence to $w_{1},\ldots,w_{r}$ such that

[TABLE]

Before proving Theorem 10, we state and prove the following technical lemma.

Lemma 11**.**

Let $G$ be a graph and $\mathcal{D}=(T,q,\mathcal{X})$ be a rooted tree decomposition of $G$. $(G,Z_{1},\ldots,Z_{r})$ belongs to $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$ if and only if there exist $\alpha_{1},\ldots,\alpha_{r}:V(T)\rightarrow\{0,1\}^{*}$ such that the following conditions are satisfied.

For each $i\in[1,r]$, $\alpha_{i}$ is a $(\mathfrak{C}_{i},G,\mathcal{D})$-witness and $Z_{i}=S_{\rho_{i}}(G,\mathcal{D},\alpha_{i})$. 2. 2.

$\sum_{t\in V(\mathcal{D})}\sum_{v\in\mathrm{forg}(t)}I(\alpha_{1}(t),\ldots,\alpha_{r}(t),v)\geq d$.

Proof.

First assume that $(G,Z_{1},\ldots,Z_{r})$ belongs to $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$. By Definition 1, for each $i\in[1,r]$, we have that $(G,Z_{i})\in\mathcal{P}_{i}$, and so, there exists a $(\mathfrak{C}_{i},G,\mathcal{D})$-witness $\alpha_{i}$ such that $Z_{i}=S_{\rho_{i}}(G,\mathcal{D},\alpha_{i})$. Thus Condition 1 is satisfied. Moreover, we have that for each $t\in V(\mathcal{D})\setminus\{q\}$ and each $v\in X_{t}$, $I(\alpha_{1}(t),\ldots,\alpha_{r}(t),v)=I(Z_{1},\ldots,Z_{r},v)$. Together with the fact that each vertex is in exactly one set $\mathrm{forg}(t)$, $t\in V(\mathcal{D})\setminus\{q\}$, and $\mathrm{Div}(Z_{1},\ldots,Z_{r})\geq d$ imply Condition 2.

Assume now that there exist $\alpha_{1},\ldots,\alpha_{r}:V(T)\rightarrow\{0,1\}^{*}$ that satisfy Conditions 1 and 2. Condition 1 implies that for each $i\in[1,r]$, $(G,Z_{i})\in\mathcal{P}_{i}$. Moreover, as for each $v\in V(G)$, there is exactly one node ${t\in V(\mathcal{D})\setminus\{q\}}$ such that $v\in\mathrm{forg}(t)$, by definition of a rooted tree decomposition, Condition 2 implies that $\mathrm{Div}(Z_{1},\ldots,Z_{r})\geq d$. Thus, $(G,Z_{1},\ldots,Z_{r})$ belongs to $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$. ∎

Now we are in a position to prove Theorem 10.

For each $i\in\{1,\ldots,r\}$, we start by constructing the data corresponding to the dynamic core $\mathfrak{C}_{i}$. The overall construction takes time $\sum_{i=1}^{r}\tau(\mathfrak{C}_{i},G,\mathcal{D})$.

Subsequently, we define a dynamic core $\mathfrak{C}$ for the problem $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$. Let $G\in\mathcal{G}$ and $\mathcal{D}=(T,q,\mathcal{X})$ be a rooted tree decomposition of $G$. The dynamic core $\mathfrak{C}$ produces the following data.

• •

$\mathrm{Accept}_{\mathfrak{C}}=\{(w_{1},\ldots,w_{r},d)\mid\forall i\in[1,r],w_{i}\in\mathrm{Accept}_{\mathfrak{C}_{i}}\}$.

• •

For each $t\in V(\mathcal{D})$, $\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)=$

[TABLE]

Let $\alpha$ be a $\mathfrak{C}$-witness of $(G,\mathcal{D})$, let $\alpha_{i}$ be the projection of $\alpha$ to its $i$-th coordinate, and let $\beta$ be the projection of $\alpha$ to its last coordinate. Then we have that $\alpha$ is a $(\mathfrak{C},G,\mathcal{D})$-witness for $(G,\mathcal{D})$ if and only if $\alpha_{i}$ is a $(\mathfrak{C}_{i},G,\mathcal{D})$-witness for $(G,\mathcal{D})$, and for $q$ being the root of $\mathcal{D}$,

[TABLE]

By Lemma 11, we have that this happens if and only if

[TABLE]

belongs to $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$.

Let now analyze the running time of this procedure. When constructing $\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)$ for some $t\in V(T)$, we need to combine every combination of elements of $\mathrm{Process}_{\mathfrak{C}_{i},G,\mathcal{D}}(t)$, $i\in\left[1,r\right]$ and of values of $\ell^{i}$, $i\in\left[1,{\delta(t)}\right]$. This can be done in time $\mathcal{O}(d^{\delta(t)}\cdot|V(T)|\cdot\prod_{i=1}^{r}\mathrm{Size}(\mathfrak{C}_{i},G,\mathcal{D}))$. Thus constructing the data associated to $\mathfrak{C}$, $G$, and $\mathcal{D}$ takes

[TABLE]

Moreover, as for every $t\in V(T)$, $|\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq d^{\delta(t)}\cdot\prod_{i=1}^{r}\mathrm{Size}(\mathfrak{C}_{i},G,\mathcal{D})$, then by Theorem 9, $\mathrm{Div}^{d}(\mathcal{P}_{1},\ldots,\mathcal{P}_{r})$ can be solved in time $\mathcal{O}(d^{a}\cdot|V(T)|\cdot\prod_{i=1}^{r}\mathrm{Size}(\mathfrak{C}_{i},G,\mathcal{D}))$ where $a=\max_{t\in V(T)}\delta(t)\leq 2$. The theorem follows. ∎

4.2 An Illustrative Application of Theorem 10

In this subsection we show how to apply Theorem 10 in the construction of an improved dynamic programming algorithm for Diverse Vertex Cover. The first thing to do is to describe a dynamic programming core $\mathfrak{C}_{\rm VC}$ for $k$-Vertex Cover. Given a graph $G$ and a rooted tree decomposition $\mathcal{D}=(T,q,\mathcal{X})$, this dynamic programming core $\mathfrak{C}_{\rm VC}$ produces:

[TABLE]

Provided the width of the decomposition is at most $k$, this can be done in time $\mathcal{O}((2^{k+1}\cdot(k+1))^{\delta(t)}\cdot k\cdot{\delta(t)})$ for each $t\in V(T)$, where the factor $k\cdot{\delta(t)}$ appears as we need the conditions $E(G[X_{t}\setminus S])=\emptyset$ and $\forall i\in\left[1,{\delta(t)}\right],S^{i}\cap X_{t}=S\cap X_{t_{i}}$ to be verified. It is easy to verify that $\mathfrak{C}_{\rm VC}$ is a dynamic programming core for the Vertex Cover problem. As described in Remark 4, we know that we can construct a rooted path decomposition of $G$ of width $k$. We are now considering this rooted path decomposition. Thus, for each $t\in V(T)$, $|\mathrm{Process}_{\mathfrak{C},G,\mathcal{D}}(t)|\leq 2\cdot 2^{k+1}\cdot(k+1)$. By Theorem 10, we obtain the following corollary, improving Corollary 5.

Corollary 12**.**

Diverse Vertex Cover* can be solved on an input $(G,k,r,d)$ in time*

[TABLE]

Note that we obtain a slightly better running time than for Corollary 5. This is due to the fact that verifying the properties $E(G[X_{t}\setminus S])=\emptyset$ and $\forall i\in\left[1,{\delta(t)}\right],S^{i}\cap X_{t}=S\cap X_{t_{i}}$ is done when constructing $\mathfrak{C}_{\rm VC}$ and not when constructing $\mathfrak{C}$. Note also that, formally, we need to construct $\mathfrak{C}_{\rm VC}$ $r$ times but as it is $r$ times the same, we do the operation only once.

5 Diversity in Kernelization

Another key concept in the field of parameterized complexity is that of a kernelization algorithm [17]. We have obtained some parallel results about the kernelization complexity of diverse problems as well that we want to briefly sketch in this section. A polynomial kernel of a parameterized problem is a polynomial-time algorithm that given any instance either solves it or constructs in polynomial time an equivalent222 Meaning that the constructed instance is a Yes-instance if and only if the original instance was. instance whose size is polynomial in the parameter. It is known that a parameterized problem is FPT if and only if it has a (not necessarily polynomial) kernel, and a natural step after proving a parameterized problem to be FPT is to decide whether or not it has a polynomial kernel.

We show that the diverse variants of several basic problems parameterized by the number of requested solutions plus solution size admit polynomial kernels as well. This is done via a variant of the recently introduced notion of loss-less kernels [9] which are a special class of kernelizations that - very roughly speaking - for each but polynomially many bits of the input can either decide whether it has to be part of every solution or if it may be added to a solution without ‘destroying’ it.

For instance, consider the famous Buss kernel for Vertex Cover [8]: Given a graph $G$ and an integer $k$, we want to decide if $G$ has a vertex cover of size $k$. Each vertex of degree at least $k+1$ must be in each solution. Otherwise, we have to include its (at least) $k+1$ neighbors, exceeding the size constraint. On the other hand, each isolated (degree-[math]) vertex can be included in a vertex cover without destroying it, but it does not cover any edge. In the ‘non-diverse’ variant, we may remove these isolated vertices, and in the diverse variant, we have to keep some of them as they may be used to increase the diversity. However, polynomially (in $k$ and $r$) many such vertices suffice.

We now turn to the technical description of this framework. All problems that fall into our framework have to be subset minimization problems. In a subset minimization problem, one part of the input is a set, called the domain of the instance, and the objective is to find a minimum size subset of the domain that satisfies a certain property. For a subset minimization problem $\Pi$, and an instance $I$ of $\Pi$, we denote by $\mathcal{D}(I)$ the domain of $I$. E.g., in the Vertex Cover problem, an instance consists of a graph $G$ and an integer $k$ and the domain of the instance is $V(G)$. For an instance $(I,k)$ of a parameterized problem, we denote its domain by $\mathcal{D}(I)$.

The following definition is a technical requirement to adapt loss-less kernelization to the setting of diverse problems. Domain recovery algorithms will be used to reintroduce some elements of the domain that have been removed during the kernelization process, in a controlled manner.

Definition 13**.**

Let $\Pi$ be a subset minimization problem. A domain recovery algorithm takes as input two instances of $\Pi$, $I$ and $I^{\prime}$, with $\mathcal{D}(I^{\prime})\subseteq\mathcal{D}(I)$, and a set $S\subseteq\mathcal{D}(I)\setminus\mathcal{D}(I^{\prime})$ and outputs in polynomial time an instance $\mathsf{rec}_{I}(I^{\prime},S)$ on domain $\mathcal{D}(I^{\prime})\cup S$, such that $|\mathsf{rec}_{I}(I^{\prime},S)|\leq|I^{\prime}|+g(|S|)$ for some computable function $g$.

We give the definition of a loss-less kernel [9], tailored to our purposes as follows.333Due to technical reasons and at a potential cost of slightly increased kernel sizes, we do not keep track of the restricted items that are forbidden in any solution of size $k$. We use the following notation: For an instance $I$ of a subset minimization problem and an integer $k$, we denote by $\mathrm{sol}(I,k)$ the solutions of $I$ of size at most $k$.

Definition 14**.**

Let $\Pi$ be a parameterized subset minimization problem. A loss-less kernelization of $\Pi$ is a pair of a domain recovery algorithm and an algorithm that takes as input an instance $(I,k)\in\Sigma^{*}\times\mathbb{N}$ and either correctly concludes that $(I,k)$ is a No-instance, or outputs a tuple $(I^{\prime},F,A)$ with the following properties. $(I^{\prime},k-|F|)$ is an equivalent444I.e. $(I,k)$ is a Yes-instance if and only if $(I^{\prime},k-|F|)$ is. instance to $(I,k)$ and $(F,A)$ is a partition of $\mathcal{D}(I)\setminus\mathcal{D}(I^{\prime})$, and the following hold.

1. (i)

There is a computable function $f$ such that $|I^{\prime}|\leq f(k)$. 2. (ii)

For all $k^{\prime}\leq k$, for all $X\subseteq\mathcal{D}(I)$, the following holds. Let $A^{\prime\prime}:=X\cap A$. Then,

[TABLE] 3. (iii)

For all $k^{\prime}\leq k-|F|$, for all $X^{\prime}\subseteq\mathcal{D}(I^{\prime})$, and for all $A^{\prime\prime}\subseteq A^{\prime}\subseteq A$ we have that:

[TABLE]

We call $f(k)$ the size and $g(\cdot)$555Function $g$ is given implicitly in the domain recovery algorithm $\mathsf{rec}_{I}(I^{\prime},A^{\prime})$. the recovery cost of the loss-less kernel, $F$ the forced items and $A$ the allowed items.

We show that as a direct consequence of this definition, all elements in $A$ can be added to any solution to $(I,k)$ such that the resulting set remains a valid solution to $(I,k)$.

Theorem 15**.**

Let $\Pi$ be a parameterized subset minimization problem that admits a loss-less kernel of size $f(k)$ and recovery cost $g(\cdot)$. Then, Diverse $\Pi$ admits a kernel of size at most $f(k)+g(kr)$.

Proof.

Let $(I,k,r,d)$ be an instance of Diverse $\Pi$. Our algorithm works as follows. We apply the loss-less kernel to $(I,k)$ and obtain $(I^{\prime},F,A)$. Let $k^{\prime}:=k-|F|$. Then, we simply return $(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime},r,d)$ where $A^{*}=A$ if $|A|\leq kr$ and otherwise, $A^{*}$ is an arbitrary size-$kr$ subset of $A$. We now show that $(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime},r,d)$ is indeed an instance of Diverse $\Pi$ that is equivalent to $(I,k,r,d)$.

Suppose $(I,k,r,d)$ is a Yes-instance. Then, there is a tuple $\mathcal{S}=(S_{1},\ldots,S_{r})\in\mathcal{D}(I)^{r}$ such that for all $i\in[1,r]$, $S_{i}\in\mathrm{sol}(I,k)$ and $\mathrm{Div}(\mathcal{S})\geq d$.

Case 1 ($|A|\leq kr$). In this case, $A^{*}=A$. For all $i\in[1,r]$, let $A_{i}:=S_{i}\cap A$, $S_{i}^{\prime}:=S_{i}\setminus A_{i}$ and $S_{i}^{*}:=S_{i}^{\prime}\setminus F$. By Definition 14(ii), we have that $S_{i}^{*}\in\mathrm{sol}(I^{\prime},k-|F|-|A_{i}|)$. By Definition 14(iii), this implies that $S_{i}^{\prime}\in\mathrm{sol}(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime})$ (recall that $k^{\prime}=k-|F|$). Furthermore, since $F\subseteq S_{i}$ for all $i\in[1,r]$ by Definition 14(ii), we have that $\mathrm{Div}(S_{1}^{\prime},\ldots,S_{r}^{\prime})=\mathrm{Div}(\mathcal{S})\geq d$, and hence $(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime},r,d)$ is a Yes-instance in this case.

Case 2 ($|A|>kr$). In this case, $A^{*}$ is an arbitrary size-$kr$ subset of $A$. For all $i\in[1,r]$, let $A_{i}:=S_{i}\cap A$, $S_{i}^{*}:=S_{i}\setminus(F\cup A_{i})$. By Definition 14(ii) we have that $S_{i}^{*}\in\mathrm{sol}(I^{\prime},k^{\prime}-|A_{i}|)$. Furthermore, since removing an element from some $S_{i}$ can decrease the diversity of the resulting solution by at most $(r-1)$, and since $F\subseteq S_{i}$ for all $i\in[1,r]$ by Definition 14(ii), we have that

[TABLE]

We construct a tuple of solutions to $\mathsf{rec}_{I}(I^{\prime},A^{*})$ as follows. Let $(B_{1},\ldots,B_{r})$ a tuple of pairwise disjoint subsets of $A^{*}$ such that for all $i\in[1,r]$, $|B_{i}|=|A_{i}|$. Such a tuple exists since $\sum_{i=1}^{r}|A_{i}|\leq kr=|A^{*}|$. For $i\in[1,r]$, let $S_{i}^{\prime}:=S_{i}^{*}\cup B_{i}$ and $\mathcal{S}^{\prime}:=(S_{1}^{\prime},\ldots,S_{r}^{\prime})$. Let $i\in[1,r]$. Since $S_{i}^{*}\in\mathrm{sol}(I^{\prime},k^{\prime}-|A_{i}|)$, $|A_{i}|=|B_{i}|$ and $B_{i}\subseteq A^{*}$, we use Definition 14(iii) to conclude that $S_{i}^{\prime}\in\mathrm{sol}(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime})$.

Now, adding $B_{i}$ to $S_{i}^{*}$ increased the diversity of the resulting solution by $(r-1)\cdot|A_{i}|$, since no element of $B_{i}$ is added to any other solution. Hence,

[TABLE]

We have shown that $(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime},r,d)$ is a Yes-instance in this case as well.

For the other direction, suppose $(\mathsf{rec}_{I}(I^{\prime},A^{*}),k^{\prime},r,d)$ is a Yes-instance. Then, (ii) and (iii) of Definition 14 immediately imply that $(I,k,r,d)$ is a Yes-instance as well.

To bound the size of $\mathsf{rec}_{I}(I^{\prime},A^{*})$, we have that $|I^{\prime}|\leq f(k)$ by the definition of the (loss-less) kernel, and $|\mathsf{rec}_{I}(I^{\prime},A^{*})|\leq|I^{\prime}|+g(|A^{*}|)\leq f(k)+g(kr)$ by the definition of a domain recovery algorithm. ∎

We now exemplify the use of Theorem 15 by showing that several well-known kernels hold in the diverse setting as well, giving polynomial kernels in the parameterization solution size plus the number of requested solutions.

We briefly introduce these problems. In the $d$-Hitting Set problem, we are given a hypergraph $H$, each of whose hyperedges contains at most $d$ elements, and an integer $k$, and the goal is to find a set $S\subseteq V(H)$ of vertices of $H$ of size at most $k$ such that each hyperedge contains at least one element from $S$. In the Point Line Cover problem, we are given a set of points in the plane and an integer $k$, and we want to find a set of at most $k$ lines such that each point lies on at least one of the lines. A directed graph $D$ is called a tournament, if for each pair of vertices $u,v\in V(D)$, either the edge directed from $u$ to $v$ or the edge directed from $v$ to $u$ is contained in the set of arcs of $D$. In the Feedback Arc Set in Tournaments problem we are given a tournament and an integer $k$, and the goal is to find a set of at most $k$ arcs such that after removing this set, the resulting directed graph does not contain any directed cycles.

Theorem 16**.**

The following diverse subset minimization problems parameterized by $k+r$ admit polynomial kernels.

1. (i)

Diverse Vertex Cover*, on $\mathcal{O}(k(k+r))$ vertices.* 2. (ii)

Diverse $d$-Hitting Set* for fixed $d$, on $\mathcal{O}(k^{d}+kr)$ vertices.* 3. (iii)

Diverse Point Line Cover*, on $\mathcal{O}(k(k+r))$ points.* 4. (iv)

Diverse Feedback Arc Set in Tournaments*, on $\mathcal{O}(k(k+r))$ vertices.*

Proof.

(i)666This was also observed in [9]. The classical kernelization for Vertex Cover due to [8] consists of the following two reduction rules. Let $(G,k)$ be an instance of Vertex Cover. First, we remove isolated vertices from $G$; since they do not cover any edges of the graph, we do not need them to construct a vertex cover. To obtain the loss-less kernel, we put these vertices into the set $A$. Second, if there is a vertex of degree more than $k$, this vertex has to be included in any solution; otherwise we would have to include its more than $k$ neighbors, resulting in a vertex cover that exceeds the size bound. We add this vertex to $F$, remove it from $G$ and decrease the parameter value by $1$. This second reduction rule finishes the description of the kernel. It is not difficult to argue that after an exhaustive application of these two rules, the resulting kernelized instance $(G^{\prime},k^{\prime})$ is such that either $k^{\prime}<0$, in which case we are dealing with a No-instance, or $|V(G^{\prime})|=\mathcal{O}(k^{2})$. For the domain recovery algorithm, we can use a trivial algorithm that reintroduces some of the vertices in $A$ to the graph $G^{\prime}$.

We now argue that this is indeed a loss-less kernel. Consider Definition 14. Item (ii) follows immediately from the fact that each vertex cover of $G$ of size at most $k$ has to contain all vertices in $F$ and that each vertex in $A$ has no neighbors in $V(G^{\prime})$. The latter also implies (iii). The result now follows from Theorem 15.

(ii) We show that the kernel on $\mathcal{O}(k^{d})$ vertices presented in [12, Section 2.6.1] is a loss-less kernel. This kernel is essentially a generalization of the one presented in the proof of (i), so we will skip some of the details. It is based on the following reduction rule: If there are $k+1$ hyperedges $e_{1},\ldots,e_{k+1}$ with $Y:=\bigcap_{i=1}^{k+1}e_{i}$ such that for each $i\in[k+1]$, $e_{i}\setminus Y\neq\emptyset$, then any solution has to contain $Y$; otherwise, to hit the hyperedges $e_{1},\ldots,e_{k+1}$, we would have to include at least $k+1$ elements in the hitting set. Moreover, if $Y=\emptyset$, we can immediately conclude that we are dealing with a No-instance. If $Y$ is nonempty, then we add all elements of $Y$ to $F$ and decrease the parameter value by $|Y|$. The set $A$ consists of all vertices that are isolated (i.e. not contained in any hyperedge) after exhaustively applying the previous reduction rule. Following the same argumentation above (and using the same domain recovery algorithm), we can conclude that this procedure is a loss-less kernel on $\mathcal{O}(k^{d})$ vertices, and the result follows from Theorem 15.

(iii) Let $(P,k)$ be an instance of Point Line Cover. We consider the set of the lines defined by all pairs of points of $P$ as the domain of $(P,k)$, and we denote this set by $L(P)$. All solutions to $(P,k)$ can be considered a subset of $L(P)$. We obtain a kernel on $\mathcal{O}(k^{2})$ points as follows, cf. [12, Exercise 2.4]. The idea is again similar to the kernel presented in (i). If there are $k+1$ points on a line, then we have to include this line in any solution; we add such lines to the set $F$ and remove all points on them from $P$, and decrease the parameter value by $1$. We finally add to $A$ all lines that have no points on them. We can argue in the same way as above that this gives a kernel with at most $\mathcal{O}(k^{2})$ points and with Theorem 15, the result follows.

(iv) We observe that the kernel given in [12, Section 2.2.2] is a loss-less kernel. Its first reduction rule states that if there is an arc that is contained in at least $k+1$ triangles, then we reverse this arc and decrease the parameter value by $1$, and the second reduction rule states that any vertex that is not contained in a triangle can be removed. Any arc affected by the former rule will be put in the set $F$ and any arc affected by the latter rule will be put in the set $A$. We now describe the domain recovery algorithm. Let $(T,k)$ be the original instance and $(T^{\prime},k^{\prime})$ the kernelized instance, and let $(u,v)=a\in A$ be an arc. Then, we add $a$ to $T^{\prime}$ and to ensure that the resulting directed graph is a tournament, for any $x\in\{u,v\}\setminus V(T^{\prime})$, we add all arcs $(x,y)\in E(T)$ and $(y,x)\in E(T)$ to $T^{\prime}$. Since $a\in A$, we know that one of its endpoints was not contained in any triangle, and hence adding the endpoints of $a$ and all their incident arcs does not add any triangles to the tournament. ∎

We would like to remark that the crucial part to use loss-less kernels in the diverse setting was that any solution of size at most $k$ has to contain all vertices of $F$, and arbitrarily adding vertices from $A$ does not destroy a solution. In the ‘classical’ kernelization setting, to argue that a reduction rule is safe it is sufficient to show that the existence of a vertex cover in the original instance implies the existence of some vertex cover in the reduced instance and vice versa, see e.g., [16, 17]. This alone is usually not enough to argue that a reduction preserves diverse solutions.

6 Conclusion

In this work, we considered a formal notion of diversity of a set of solutions to combinatorial problems in the setting of parameterized algorithms. We showed how to emulate treewidth based dynamic programming algorithms in order to solve diverse problems in FPT time, with the number $r$ of requested solutions being an additional parameter.

This line of research is now wide open, with many natural questions to address. As all our results are of a positive nature, we ask: when can diversity be a source of hardness? Concretely, a natural target in parameterized complexity would be to identify a parameterized problem $\Pi$ that is FPT, however Diverse $\Pi$ being W[1]-hard when $r$ is an additional parameter. For positive results, an interesting research direction would be to generalize our framework for diverse problems to other well-studied width measures for graphs, as well as to other structures, such as matroids.

In this work, we considered the sum of all pairwise Hamming distances of a set as a measure of diversity. As pointed out, this measure has some weaknesses, and another widely used measure is the minimum Hamming distance. In this setting, we only obtain FPT-results when the diversity is bounded by a function of the treewidth and the number of solutions, but not in general. So, a natural follow-up question is whether or not we can obtain FPT-results under the minimum Hamming distance, even if the diversity is unbounded.

Acknowledgements.

M. Fellows and F. Rosamond acknowledge support from the Norwegian NFR Toppforsk Project, “Parameterized Complexity and Practical Computing” (PCPC) (no. 813299). M. Fellows, F. Rosamond, L. Jaffke, M. de Oliveira Oliveira, and G. Philip acknowledge support from the Bergen Research Foundation grant “Putting Algorithms Into Practice” (BFS, no. 810564). G. Philip acknowledges support from the Research Council of Norway grants “Parameterized Complexity for Practical Computing” (NFR, no. 274526d), “MULTIVAL”, and “CLASSIS”, and European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (ERC, no. 819416). T. Masařík acknowledges support from the European Research Council (ERC grant agreement no. 714704)   , and from Charles University’s grants GAUK 1514217 and SVV-2017-260452. He recently started a postdoc at Simon Fraser University, Canada. M. de Oliveira Oliveira acknowledges support from the Research Council of Norway (NFR, no. 288761). J. Baste acknowledges support from the German Research Foundation (DFG, no. 388217545).