Abstract 1 Introduction 2 Preliminaries 3 A kernel with 𝟐𝒌 vertices for ENUM VERTEX COVER 4 Feedback Vertex Set 5 Final remarks References

Enumeration Kernels for Vertex Cover and Feedback Vertex Set

Marin Bougeret ORCID LIRMM, Université de Montpellier, Montpellier, France Guilherme C. M. Gomes ORCID LIRMM, Université de Montpellier, CNRS, Montpellier, France
Universidade Federal de Minas Gerais, Belo Horizonte, Brazil
Vinicius F. dos Santos ORCID Universidade Federal de Minas Gerais, Belo Horizonte, Brazil Ignasi Sau ORCID LIRMM, Université de Montpellier, CNRS, Montpellier, France
Abstract

Enumerative kernelization is a recent and promising area sitting at the intersection of parameterized complexity and enumeration algorithms. Its study began with the paper of Creignou et al. [Theory Comput. Syst., 2017], and development in the area has started to accelerate with the work of Golovach et al. [J. Comput. Syst. Sci., 2022]. The latter introduced polynomial-delay enumeration kernels and applied them in the study of structural parameterizations of the Matching Cut problem and some variants. Few other results, mostly on Longest Path and some generalizations of Matching Cut, have also been developed. However, little success has been seen in enumeration versions of Vertex Cover and Feedback Vertex Set, some of the most studied problems in kernelization. In this paper, we address this shortcoming. Our first result is a polynomial-delay enumeration kernel with 2k vertices for Enum Vertex Cover, where we wish to list all solutions with at most k vertices. This is obtained by developing a non-trivial lifting algorithm for the classical crown decomposition reduction rule, and directly improves upon the kernel with 𝒪(k2) vertices derived from the work of Creignou et al. Our other result is a polynomial-delay enumeration kernel with 𝒪(k3) vertices and edges for Enum Feedback Vertex Set; the proof is inspired by some ideas of Thomassé [TALG, 2010], but with a weaker bound on the kernel size due to difficulties in applying the q-expansion technique.

Keywords and phrases:
Kernelization, Enumeration, Vertex cover, Crown decomposition, Feedback vertex set
Funding:
Guilherme C. M. Gomes: Funded by the European Union, project PACKENUM, grant number 101109317. Views and opinions expressed are however those of the author only and do not necessarily reflect those of the European Union. Neither the European Union nor the granting authority can be held responsible for them.
Vinicius F. dos Santos: Supported by CNPq (Grants 312069/2021-9, 406036/2021-7, 404479/2023-5, and 308129/2025-3).
Ignasi Sau: French project ELIT (ANR-20-CE48-0008-01).
Copyright and License:
[Uncaptioned image] © Marin Bougeret, Guilherme C. M. Gomes, Vinicius F. dos Santos, and Ignasi Sau; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Parameterized complexity and exact algorithms
Related Version:
Full Version: https://arxiv.org/abs/2509.08475
Editors:
Akanksha Agrawal and Erik Jan van Leeuwen

1 Introduction

Enumeration problems are central objects in both practical and theoretical computer science, with the main example of the former being the branch-and-bound method [35] (and its relatives), universally used in integer programming solvers. Instead of answering a question in either the positive or the negative, in this class of problems the goal is to generate all witnesses, or solutions, that satisfy the given problem’s constraints, or decide that no solution exists; we denote by 𝖲𝗈𝗅(x) the solution set of an instance x of some fixed problem of interest. Typically, the number of solutions will be exponential in the input size n, and thus input-sensitive algorithms, whose running-times are only analyzed with respect to n, are not powerful enough tools to capture all nuances intrinsic to enumeration problems. In particular, input-polynomial algorithms, whose running times are of the form n𝒪(1), are inadequate models of efficient enumeration. Consequently, enumeration algorithms are usually analyzed in the output-sensitive context, i.e., their running times depend on both n and the size of the output. In this setting, a popular class of efficiently solvable enumeration problems are those that admit polynomial-delay [3, 23, 31] algorithms, where the running time between consecutive outputs must be bounded by 𝗉𝗈𝗅𝗒(n). These algorithms are unfeasible goals in many interesting cases, as enumeration problems for which the existence of a single solution is an 𝖭𝖯-hard problem trivially do not admit such algorithms unless 𝖯=𝖭𝖯.

Orthogonally to enumeration, the theory of parameterized complexity [18, 22, 28] gained significant traction as a means of coping with 𝖭𝖯-hardness. In this framework, an instance x is equipped with a parameter of interest k=κ(x) and the efficient algorithms, known as fixed-parameter tractable (𝖥𝖯𝖳), are those of running time f(k)n𝒪(1), for some computable function f. An equivalent definition of tractability in this framework, and central to our work, is that of decision kernelization: a polynomial-time algorithm, or kernel, that compresses an instance (x,k) into an equivalent instance (y,) such that |y|,g(k) for some computable function g, known as the size of the kernel. Beyond their theoretical interest, kernels are also models for theoretically guaranteed pre-processing algorithms, a key feature in real-world applications, such as in integer optimization. Polynomial kernels, i.e., when g(k)=𝗉𝗈𝗅𝗒(k), are of particular interest, as they typically result in significant reductions in input size. Kernelization theory counts with several robust results and tools [1, 39, 25, 6, 28, 4, 11, 8, 21], including meta-theorems [7, 29, 27, 32], for both upper and lower bounds.

A very successful case study in kernelization is that of Vertex Cover, arguably the most fundamental problem in parameterized complexity. Abu-Khzam et al. [1] presented the first kernel with 𝒪(k) vertices for the problem when parameterized by the solution size k, using the then-novel concept of crown decompositions to improve on the previously best known kernel with 𝒪(k2) vertices, implied by a result of Buss and Goldsmith [13]. Currently, the best known kernels for Vertex Cover have size 2k [15], and are based on the half-integral relaxation of Nemhauser and Trotter [38]. Alongside Vertex Cover, the Feedback Vertex Set problem has been quite influential in kernelization theory [12, 9, 39]. When parameterized by the solution size k, it was first shown to admit a kernel with 𝒪(k11) vertices by Burrage et al. [12]; this was later improved to a cubic kernel by Bodlaender and van Dijk [9]. Shortly afterwards, Thomassé [39] presented a kernel with 𝒪(k2) vertices and edges by introducing a generalization of crown decompositions known as q-expansions, which have since been used in other examples in the literature [25, 33, 26, 34]. Thomassé’s kernel size has also been shown to be asymptotically optimal by Dell and Marx [21].

Over the last years, there have been mounting efforts to extend parameterized complexity to the enumeration setting [37, 24, 20, 19, 30, 33, 14, 5, 36, 17], with input-𝖥𝖯𝖳 and 𝖥𝖯𝖳-delay having their expected definitions; the work of Creignou et al. [17] has been particularly influential in this endeavor, and we refer to it for a broader discussion on parameterized enumeration. We will also not further discuss input-sensitive enumeration, focusing on delay-based algorithms. While parameterized enumeration algorithms have been developed for some decades, it took much longer, however, for the area of enumerative kernelization to emerge, even though kernelization itself did play a significant role in several works [24, 19, 17].

Only very recently Golovach et al. [30] defined polynomial-delay enumeration (PDE) kernels, which are equivalent to the existence of 𝖥𝖯𝖳-delay algorithms, much like 𝖥𝖯𝖳 algorithms and kernels are equivalent in the decision world; previous models, such as full kernels [19] and enum-kernels [17], had issues that made them unsatisfactory definitions for enumerative kernelization. Intuitively, a PDE kernel has two parts: the first, 𝒜1, is the compression algorithm and has the same constraints as a decision kernel, while the second 𝒜2, known as the lifting algorithm, receives the input (x,k), the output (y,) of 𝒜1, and a solution Y𝖲𝗈𝗅(y), and must output, with 𝗉𝗈𝗅𝗒(|x|+|y|+k+)-delay, a non-empty subset SY𝖲𝗈𝗅(x); additionally, the SY’s must partition 𝖲𝗈𝗅(x). PDE kernels have been applied to some problems [30, 36, 14, 33], mainly restricted to variants of the Matching Cut problem; [33] is the unique exception, as it investigates an enumeration variant of the Longest Path problem; we remark that they apply the q-expansion technique to obtain their results. Despite being stated as an enum-kernel, Creignou et al.’s [17] 𝒪(k2) kernel for Enum Vertex Cover is a PDE kernel. Despite these positive results, the most basic techniques of decision kernelization theory seem quite difficult to adapt to the enumeration setting. Motivated by this phenomenon, we examine the best known kernels for Vertex Cover and Feedback Vertex Set and seek to adapt their ideas and techniques to their respective enumeration variants.

Our contributions.

Our first result is a PDE kernel for Enum Vertex Cover with 2k vertices, and directly improves upon the 𝒪(k2) kernel of Creignou et al. [17]; the problem is formally defined as follows.

Enum Vertex Cover
Instance: A graph G and an integer k.
Enumerate: All vertex covers of G of size at most k.

Our proof is a direct generalization of the kernel with 2k vertices for Vertex Cover; this, in turn, is based on the celebrated crown decomposition technique. Specifically, we obtain the following theorem.

Theorem 1.

Enum Vertex Cover admits a PDE kernel with at most 2k vertices when parameterized by the maximum desired size of a solution k.

Intuitively, our kernel works by applying the classic crown reduction that deletes the head H and crown C of the decomposition, reduces k by |H|, and returns only the body B. The 2k bound is consequence of the Nemhauser-Trotter decomposition theorem [38] and the fact that it either yields a crown decomposition or gives a bound on the size of the input graph. The complicated part is showing how to design a lifting algorithm; we do so by proving that Enum Vertex Cover restricted to crowned graphs, i.e., graphs that can be partitioned into HC where C is an independent set and there is an H-saturating matching between H and C, admits a polynomial-delay algorithm. Given a solution S of the reduced instance, our lifting algorithm has three phases: (i) brute force how the slack k(|S|+|N(BS)H|) is distributed in C, (ii) compute sets of vertices forced to be added to and forbidden in the solution given the output of (i), and (iii) solve the instance (G,|V(G)|/2) induced by the remaining vertices. The key observations are that: (a) every configuration tested in (i) leads to a solution of the input, and (b) G is a crowned graph with a perfect matching.

We then proceed to show a cubic PDE kernel for the Enum Feedback Vertex Set problem, formally defined as below.

Enum Feedback Vertex Set
Instance: A multigraph G and an integer k.
Enumerate: Every feedback vertex set of G of size at most k.

We follow a similar direction to Thomassé’s quadratic kernel [39]: we first design reduction rules to lower bound the minimum degree of the instance; then, we show that upper bounding the maximum degree is enough to lead to a kernel; and finally, we present reduction rules that yield said upper bound. The core ingredient of Thomassé’s proof – the computation of a 2-expansion in an auxiliary graph – seems to fail in the enumeration setting, and we are unable to generalize it. Nevertheless, we obtain Theorem 2. Our set of reduction rules is mostly different, which leads to a quadratic instead of a linear bound on the maximum degree. As our lower bound on the minimum degree is also different, we must prove a slight generalization on the bound used in Thomassé’s proof.

Theorem 2.

There is a PDE kernel for Enum Feedback Vertex Set parameterized by the size of the solution k with 𝒪(k3) vertices.

Organization.

In Section 2 we present some basic preliminaries about graphs, parameterized complexity, and enumeration problems. In Section 3, we present our linear PDE kernel for Enum Vertex Cover. In Section 4, we present our cubic PDE kernel for Enum Feedback Vertex Set and discuss some challenges in using rules based on q-expansions. We present concluding remarks and possible research directions in Section 5. Due to space limitations, the proofs of the statements marked with “()” have been omitted and can be found in the full version available online (https://arxiv.org/abs/2509.08475).

2 Preliminaries

We denote the set {1,2,,n} by [n]. We use standard graph-theoretic notation, and we consider simple undirected graphs without loops or multiple edges; see [10] for any undefined terminology. When the graph is clear from the context, the degree (that is, the number of neighbors) of a vertex v is denoted by deg(v), and the number of neighbors of a vertex v in a set AV(G) and its neighborhood in it are, respectively, denoted by degA(v) and NA(v); we also define N(S)=vSN(v)S. A matching M of a graph G is a subset of edges of G such that no vertex of G is incident to more than one edge in M; for simplicity, we define V(M)=uvM{u,v} and refer to it as the set of M-saturated vertices. The subgraph of G induced by X is defined as G[X]=(X,{uvE(G)u,vX}). A feedback vertex set XV(G) is such that GXG[V(G)X] is a forest; the feedback vertex number of G is the size of a feedback vertex set of minimum size. Given adjacent u,vV(G), a contraction of u into v is an operation that outputs the graph G{u} with the added edges {vwwNG(u){v}}. An algorithm is said to run with polynomial delay [16] if the times before the first output (called the precalculation period), after the last output (the postcalculation period), and in between two consecutive outputs are bounded by a polynomial in the input size only.

We refer the reader to [22, 18] for basic background on parameterized complexity and present here only definitions pertaining to parameterized enumeration.

Definition 3 (Parameterized enumeration problem (Creignou et al. [17], Golovach et al. [30])).

A parameterized enumeration problem over a finite alphabet Σ is a tuple Π=(L,𝖲𝗈𝗅,κ), shorthanded by Πκ, such that:

  1. i.

    LΣ is a decidable language;

  2. ii.

    𝖲𝗈𝗅:Σ2Σ is a computable function such that, for every instance xΣ, 𝖲𝗈𝗅(x) is finite and we have 𝖲𝗈𝗅(x) if and only if xL;

  3. iii.

    κ:Σ is the parameterization.

An instance x of Πκ is a 𝗇𝗈-instance if 𝖲𝗈𝗅(x)=, and is a 𝗒𝖾𝗌-instance otherwise.

Definition 4 (Polynomial-delay enumeration kernel).

Let Πκ be a parameterized enumeration problem. A polynomial-delay enumeration kernel, PDE kernel for short, is a pair of algorithms 𝒜1,𝒜2 such that, given an instance x of Πκ and κ(x):

  • The compression algorithm 𝒜1 runs in 𝗉𝗈𝗅𝗒(|x|+κ(x))-time and outputs an instance y of Πκ satisfying κ(y),|y|f(κ(x)), with f being a computable function, and with 𝖲𝗈𝗅(y) if and only if 𝖲𝗈𝗅(x);

  • The lifting algorithm 𝒜2 receives x, y=𝒜1(x,κ(x)), κ(x), κ(y), some Y𝖲𝗈𝗅(y), and outputs, with polynomial delay on its input, a non-empty SY𝖲𝗈𝗅(x). Moreover, {SYY𝖲𝗈𝗅(y)} is a partition of 𝖲𝗈𝗅(x).

A graph subset problem is a problem with a graph as input and a solution being a subset of its vertices. We say that a PDE kernel for a graph subset problem is extension-only if, given a solution Y𝖲𝗈𝗅(y), the lifting algorithm works by only adding some vertices in xy to Y. Intuitively, this constraint implies that a solution of the input instance x cannot be generated by two different solutions of the compressed instance y, so it only remains to prove that every solution of x is generated from some solution of y and every solution of y leads to some solution of x. Both kernels developed in this work are extension-only. We remark that the kernels for Enum Matching Cut and its variants developed by Golovach et al. [30] are not extension only, as their lifting algorithms remove some vertices of the compressed instance’s solutions.

3 A kernel with 𝟐𝒌 vertices for ENUM VERTEX COVER

In this section we prove Theorem 1. Our main tools for this result are crowned graphs and crown decompositions, given in Definition 5.

Definition 5.

A graph is a crowned graph if its vertex set can be partitioned into HC, such that C is an independent set, and such that there is a matching M between H and C where |M|=|H|. The set C is called the crown, and H is called the head. Given a graph G, a crown decomposition [18] of width t is a partition (C,H,B) of V(G) such that G[HC] is a crowned graph (with head H), NG(C)=H, and |H|=t. Set B is called the body.

To that end, we first reduce the task of finding a PDE kernel to an enumeration problem Enum Crown, and then reduce Enum Crown to an even more structured enumeration problem Enum Small Crown for which we provide a polynomial-delay enumeration algorithm. Let us first define our problem.

Enum Crown
Instance: A crowned graph G=(HC,E) and an integer x in [0,|C|].
Enumerate: All vertex covers of G of size exactly |H|+x.

The problem Enum Small Crown corresponds to the special case of Enum Crown where |C|=|H| and x=0. Given an input (G,x) of Enum Crown, we denote by 𝖲𝗈𝗅(G,x) the set of solutions. In the same way, we define 𝖲𝗈𝗅(G) for Enum Small Crown.

 Remark 6.

Every instance of Enum Crown has a solution that takes the head and any x vertices in the crown. If M is an H-saturating matching between H and C, then every solution S of Enum Small Crown and every eM satisfy |SV(e)|=1, where V(e) denotes the endpoints of e.

Our kernelization algorithm consists in the exhaustive application of Rules VC.1 and VC.2, the latter of which can be applied in polynomial time due to Lemma 7.

Reduction Rule VC.1.

Let (G,k) be the input instance of Enum Vertex Cover. If v is an isolated vertex of G, remove v from G and set kk.

Proof of safeness and lifting algorithm of Rule VC.1.

Let G=G{v}. The forward direction is immediate; S𝖲𝗈𝗅(G,k) if and only if S{v}𝖲𝗈𝗅(G,k). For the converse direction, it is also immediate that S𝖲𝗈𝗅(G,k) if and only if S𝖲𝗈𝗅(G,k); however, observe that (S{v})𝖲𝗈𝗅(G,k) if and only if |S|<k as v is isolated, and we must also output (S{v}) if possible.

As pointed out by Chlebík and Chlebíkova [15], the Nemhauser-Trotter [38] decomposition based on the half-integral relaxation of Vertex Cover is a crown decomposition.

Lemma 7 (​​[38] and [15]).

Let G be a graph without isolated vertices and with at least 2k+1 vertices. Then, there is a polynomial-time algorithm that either:

  • decides that no half-integral vertex cover of weight at most k exists; or

  • finds a crown decomposition of G of width at most k.

Reduction Rule VC.2 (Crown reduction).

Let (G,k) be an instance of Enum Vertex Cover with (C,H,B) a crown decomposition of G of width at most k. Set GG(HC), kk|H|, and return (G,k).

Lemma 8.

If Enum Crown has a polynomial-delay enumeration algorithm 𝒜, then Rule VC.2 is a reduction rule with an extension-only lifting algorithm.

Proof.

Let us show how to construct the lifting algorithm b using 𝒜. Given a solution S of the reduced instance (G,k), let x=k|S| (where x0) be the slack of the solution S, and F=N(BS)H be the set of forced vertices in H, i.e. vertices that are adjacent to some vertex of B not picked in S. Let H=HF. For any [0,min(|C|,x)], define x=|H|+, and observe that (G[HC],x) is a valid instance of Enum Crown as x|C|. For any [0,min(|C|,x)], b outputs all solutions of the form SFS, where S𝖲𝗈𝗅(G[HC],x) are enumerated by 𝒜. This completes the description of b, so let us now prove that it adheres to the requirements of Definition 4. The first item is satisfied as it is well known that the crown reduction is safe for the decision version of the problem, in the sense that (G,k) is a 𝗒𝖾𝗌-instance if and only if (G,k) is. Let us now check the second item, more precisely:

  • For every S𝖲𝗈𝗅(G,k), the set b(G,G,k,k,S) is non-empty, and can be enumerated with polynomial-delay; and

  • {b(G,G,k,k,S)S𝖲𝗈𝗅(G,k)} is a partition of 𝖲𝗈𝗅(G,k).

Let us start with the first property. Notice that there exists at least one [0,min(|C|,x)], and as for any such , tuple ((H,C),x) is an instance of Enum Crown (which always has a solution by Remark 6), we get that b(G,G,k,k,S). Moreover, b(G,G,k,k,S) runs with polynomial-delay, as for each , 𝒜 enumerates 𝖲𝗈𝗅(G[HC],x) with polynomial-delay, and there is no additional verification required in b to avoid duplicate solutions of the form SFS generated by different values of , as for any these solutions have size exactly |S|+|F|+x.

Let us now consider the second property. Observe first that for any S𝖲𝗈𝗅(G,k), any Sb(G,G,k,k,S) is indeed a solution of (G,k) as V(G) can be partitioned into V1=V(G)F and V2=HC, and S=SFS where SF is a vertex cover of G[V1], S is a vertex cover of G[V2], and there is no edge between V1S and V2. Let us now prove that 𝖲𝗈𝗅(G,k)S𝖲𝗈𝗅(G,k)b(G,G,k,k,S). Let S𝖲𝗈𝗅(G,k) and S=S(HC). As there is a matching of size |H| between the head and the crown, |S(HC)||H| and thus S𝖲𝗈𝗅(G,k). Now, let us prove that Sb(G,G,k,k,S). Observe first that as S necessarily contains F, S is partitioned into S=SF(S(HC)), where S(HC) is a vertex cover of G[HC]. Let 0 be such that |S(HC)|=|H|+0. It remains to prove that 0[0,min(|C|,x)], as this implies that (S(HC))𝖲𝗈𝗅(G[HC],x0), and thus that Sb(G,G,k,k,S). First, we have 00 as (C,H,) remains a crown decomposition, and thus there is a matching saturating H in G[HC]. Let x=k|S| where x0. Moreover, |S|=|S|+|F|+|(S(HC))|=kx+|F|+|H|+0=kx+0k, implying that 0x. As 0|C| by definition, we get the claimed inequality. Finally, observe that SV(G)=S, so it follows that b is an extension-only lifting algorithm, which implies that, for any two different solutions S1,S2 of 𝖲𝗈𝗅(G,k), the sets b(G,G,k,k,S1), and b(G,G,k,k,S2) are disjoint.

With this conditional result, we are now able to state a conditional kernelization lemma.

Lemma 9 ().

If Enum Crown has a polynomial-delay enumeration algorithm, then Enum Vertex Cover admits a PDE kernel (with extension-only lifting algorithm) with at most 2k vertices.

The remainder of this section is dedicated to proving that Enum Crown admits a polynomial-delay enumeration algorithm. In what follows, given a matching M, and a subset TV(M) such that for any eM, |V(e)T|1, we define MV(T){vvvM and vT} and call it the image of T by M. We need the following procedure and its associated technical lemma to obtain our lifting algorithm. Intuitively, in a small crowned graph G, exactly one endpoint of each edge of an H-saturating matching M can be in a vertex cover; 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,M,X0) decides which vertices must be included and which must be excluded from a solution if we fix X0 to be part of the it.

Definition 10 (𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,M,X0)).

Given a small crowned graph G=(HC,E) (meaning with |H|=|C|) and X0H, the procedure 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,M,X0) outputs two sets (F,F¯) as follows (see Figure 1). Let G=(AB,E) be an oriented bipartite graph with A=H, B=C, where:

  • for any edge e between A and B with eM, we add its oriented version from A to B.

  • for any edge e between A and B with eM, we add its oriented version from B to A.

Let ZAB be the vertices that can be reached from X0 in G, including X0 itself. Then, 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,M,X0) outputs (F,F¯) where F=ZA and F¯=ZB.

Figure 1: Example of an application of 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,M,X0) that stopped at distance three from X0, with the graph depicted corresponding to G. Edges of M correspond to the vertical arcs, while sloped arcs correspond to all other arcs of G. The light-blue-shaded vertices correspond to X0, the red-shaded to D1 (the vertices at distance one from X0), the teal-shaded to D2, the purple-shaded to D3, and the yellow-shaded vertices correspond to the graph G=G[(HF)(CF¯)].
Lemma 11.

Let G be a small crowned graph, M a perfect matching of G between H and C, X0H, and (F,F¯)=𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,M,X0). Then:

  1. 1.

    F¯=MV(F) (where FH and F¯C) and for any solution S𝖲𝗈𝗅(G) such that X0S, S contains F and avoids F¯.

  2. 2.

    For any solution S𝖲𝗈𝗅(G) such that X0S, if we define H=HF and C=CF¯),then G=G[HC] is a small crowned graph and S(CH)𝖲𝗈𝗅(G).

  3. 3.

    For any solution S𝖲𝗈𝗅(G), FS is a solution of G (that contains X0).

Proof.

Let G=(AB,E) be the oriented bipartite graph defined in Definition 10.

Proof of Item 1.

Let S𝖲𝗈𝗅(G) such that X0S. For any i0, let Di be the vertices of (A,B) at distance i from X0 in G (e.g. D0=X0, D1=MV(X0), see Figure 1). Let us show by induction that for any i, if i is even, then DiAS, and if i is odd then DiBS, and Di=MV(Di1). Observe that the statement holds for i=0. Let us now assume that it holds for i1 and consider i. If i is odd, observe first that Di=MV(Di1) by the definition of G, and, by Remark 6, for any edge v,vM with vDi1 and vDi, vS. If i is even, as Di1S= and S is a vertex cover of G, then DiS, and, as G is bipartite, we also get that DiA. Now, as F=i0mod2Di and F¯=i1mod2Di, we get F¯=MV(F), and Item 1 follows.

Proof of Item 2.

Observe first that G is indeed a crowned graph as F¯=MV(F). Now, as S𝖲𝗈𝗅(G) we get |S|=|H|; by Remark 6 we get |S(FF¯)|=|F|, leading to |S(CH)|=|H|.

Proof of Item 3.

Let S𝖲𝗈𝗅(G), and let us consider S=FS. Observe that HC is partitioned into FF¯ and HC, that F is a vertex cover of G[FF¯] (as F¯=MV(F)), and S is a vertex cover of G[HC]. By definition of F and F¯, there is no edge between F¯ and HC, implying that S is a vertex cover of G[HC]. Since |S|=|H|, we get that S is a solution of G (that contains X0 by definition of F).

Lemma 12.

If Enum Small Crown admits a polynomial-delay algorithm, then Enum Crown also admits such an algorithm.

Proof.

Let us define a polynomial-delay enumeration algorithm 𝒜 for Enum Crown. Let (G,x) be an instance of Enum Crown with V(G)=HC, and let M be a matching from H to C that saturates H. Given TV(G), we define M(T)={eMV(e)T}, i.e., the set of edges of M entirely in T. For any S𝖲𝗈𝗅(G,x), the signature of S is composed of two sets, C1(S)=V(M(S))C and C2(S)=(CV(M))S). Observe that

  • |C1(S)|=|M(S)|, where |C1(S)|x (as |C1(S)|+|H||S|=|H|+x);

  • x(|C||M|)|C1(S)| (as if x(|C||M|)>|C1(S)| then as C2(S)(CV(M)), we would have |S|=|H|+|C1(S)|+|C2(S)|<|H|+x), and |C2(S)|=x|C1(S)|;

  • By defining X1¯(S)=(CV(M))C2(S), we have SX1¯(S)=.

Figure 2: Example of the structures involved in the algorithm 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾, used in the proof of Lemma 12. The five light-blue-shaded vertices correspond to the inputs C1,C2 of 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾; the two olive-shaded vertices are forced to be in the solution by our choice of C1. X¯1, i.e., the set of vertices of CV(M) that should be forbidden in a solution to G, is represented by the three red-shaded vertices; the dark-green shaded vertices are forced to be in every solution that avoids X¯1, and, together with G~=G[H~C~], composes the input to the call to 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋 used in 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾; the four teal-shaded and four purple-shaded vertices are the outputs F,F¯ of 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋, and, together with X¯1, make up the output of 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾. Finally, the four yellow-shaded vertices represent G, the instance of Enum Small Crown to which 𝒜s will be applied.

Our next step is guessing which edges of the H-saturating matching M will have both endpoints in the solution S; in the next propagation procedure, this is represented by set C1, i.e. which vertices of CV(M) must be accompanied by their image in S. We also guess which vertices of C that are not matched to H will be included in a solution; this is represented by C2. Finally, the choice of C1 and C2 implies that the vertices X¯C(V(M)C2) are incident to yet uncovered edges. Formally, for any d[max(0,x(|C||V(M))|),x], any set C1V(M)C of size d, and any set C2CV(M) of size xd, we define (see Figure 2) 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾(C1,C2) that computes (F,F¯,X1¯) where X1¯=(CV(M))C2, and (F,F¯)=𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G~,X0) with X0=N(X1¯), and G~=G[H~C~], where H~=HMV(C1), and C~=MV(H~).

Claim 13.

For any S𝖲𝗈𝗅(G,x) of signature (C1,C2),

  1. 1.

    S contains F and avoids F¯X1¯;

  2. 2.

    By defining H=H~F and C=C~F¯, G=G[HC] is a small crowned graph and (S(CH))𝖲𝗈𝗅(G).

Proof.

Let S𝖲𝗈𝗅(G,x) have signature (C1,C2). By definition of C2(S), we get that SX1¯=, implying also that X0S. Moreover, by definition of C1(S), no edge eM with V(e)H~C~ has both its endpoints in S. Thus, if we define S~=S(H~C~), we get that S~𝖲𝗈𝗅(G~) and that X0S~. By Lemma 11, we obtain the two claimed properties.

We are now ready to define 𝒜. To this end, let 𝒜s be the polynomial-delay algorithm for Enum Small Crown. For any d[max(0,x(|C||V(M)|)),x], any set C1V(M)C of size d, and any set C2CV(M) of size xd, 𝒜 runs 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾(C1,C2) that computes (F,F¯,X1¯), and defines G, H, and C as in Item 2 of Claim 13. Note that G may be the empty graph. Then, 𝒜 outputs all solutions of the form C1M(C1)C2FS, where S𝖲𝗈𝗅(G) are enumerated by 𝒜s. Observe that we can indeed call 𝒜s on G as according to Item 2, G is a small crowned graph.

Let us first prove that there is no repetition. Observe that for each d, C1, C2 considered by 𝒜, all enumerated solutions of the form C1M(C1)C2FS (where S𝖲𝗈𝗅(G)) have a signature (C1,C2). Now, it is sufficient to observe that two solutions of (G,x) with different signatures are necessarily different, which implies that there is no repetition.

Let us now prove that all enumerated elements are in 𝖲𝗈𝗅(G,x). Let S=C1M(C1)C2FS, where S𝖲𝗈𝗅(G) exists (as S=SV(G) and G is an induced subgraph of G) and is enumerated by 𝒜. By Item 3 of Lemma 11, (SF)𝖲𝗈𝗅(G~) and contains X0. Now, observe that HC is partitioned into V1=C1M(C1)C2X1¯, and V2=H~C~. Notice that SVi is a vertex cover of G[Vi] for i{1,2}. Moreover, as V1S=X1¯, the only edges between V1 and V2 not covered by SV1 are edges between X1¯ and N(X1¯)=X0, but as SV2X0, S is indeed a vertex cover of G. Finally, |S|=2|C1|+|C2|+|F|+|H|=2|C1|+|C2|+|H~|=|H|+|C1|+|C2|=|H|+x, and so we have S𝖲𝗈𝗅(G,x).

Towards proving that all elements of 𝖲𝗈𝗅(G,x) are enumerated, let S𝖲𝗈𝗅(G,x), and (C1(S),C2(S)) be its signature. By definition of 𝒜, there exists C1 and C2 considered by 𝒜 such that Ci=Ci(S) for i{1,2}. Let (F,F¯,X1¯)=𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾(C1,C2). By Item 1, SF, and S(F¯X1¯)=, which implies that S=C1M(C1)C2FS. As S(CH)=S, Item 2 implies that S𝖲𝗈𝗅(G), and so S is enumerated by 𝒜s.

It remains to prove that there is only polynomial-time between two consecutive outputs of 𝒜. Notice first that 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝗅𝖺𝗋𝗀𝖾 runs in polynomial time. Then, for each fixed C1,C2 considered by 𝒜, as 𝒜s runs in polynomial-delay, there is at most polynomial-time between two consecutive solutions having the same signature (C1,C2). Moreover, and as for any choice of C1,C2 considered by 𝒜, we know that 𝖲𝗈𝗅(G) (by Remark 6), there is also a polynomial-delay between two consecutive solutions with different signatures.

The proof of Lemma 16 requires a more involved variant of the propagation algorithm, where the goal is to avoid a prescribed vertex v.

Definition 14 (𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v)).

Given a small crowned graph G=(HC,E) (i.e., |H|=|C|), and vH, the procedure 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v) either fails, or outputs two sets (F,F¯) that, intuitively, are forced to be included or avoided in a solution that avoids v and, upon removal, will yield a small crowned graph. We recursively define them as follows. Let F0¯={v}. Observe that N(F0¯) intersects C (because of the perfect matching M between H and C, and may intersect H). Now, for any i1 (see Figure 3):

  • to compute Fi: if there exists eM such that V(e)N(F¯i1), we fail, and otherwise we define Fi=N(F¯i1).

  • to compute F¯i: if M(Fi) is not an independent set, we fail, and otherwise we define Fi¯=M(Fi); note that F¯i1F¯i.

We continue this process until it fails or until Fi=Fi1 and F¯i=F¯i1. If there is no failure, 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v) returns (F,F¯)=(Fi,Fi¯).

(a) Computing F1 (cyan) from F¯0 (purple).
(b) Computing F¯1 (red) from F1 (teal).
(c) Computing F2 (cyan) from F¯1 (purple).
(d) Computing F¯2 (red) from F2 (teal).
(e) Failing to compute F1 (cyan) from F¯0 (purple).
(f) Failing to compute F¯1 (red) from F1 (teal).
Figure 3: Examples of executions of algorithm 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅. Vertical edges correspond to M. We reduce the width of the edges of G not involved in the corresponding operation for clarity. An arc (x,y) indicates that vertex y was included in the set currently being built by virtue of the membership of x in the root set. The edges that cause the failures in the computation of Fi or F¯i are thickened and colored differently.
Lemma 15.

Let G=(HC,E) be a small crowned graph, and vH.

  1. 1.

    If 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v) fails, then there is no S𝖲𝗈𝗅(H,C) such that vS.

  2. 2.

    Otherwise, if 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v) returns (F,F¯) (where F¯=MV(F)), then for any S𝖲𝗈𝗅(G) such that vS, FS and SF¯=; moreover, if we define H=H(FF¯) and C=C(FF¯), then G=G[HC] is a crowned graph with |C|=|H|, and S(CH)𝖲𝗈𝗅(G).

  3. 3.

    For any S𝖲𝗈𝗅(G), FS is a solution of G that avoids v.

Proof.

Suppose that there is some S𝖲𝗈𝗅(G) where vS. Let us prove by induction that for any i1, if there is a failure when computing Fi or Fi¯, then S cannot exist, and otherwise FiS and SFi¯=.

Assume there was no failure, and consider the step where we try to compute Fi. By induction, SF¯i1=, so we have that N(F¯i1)S and, by construction, Fi=N(F¯i1). By Remark 6, if there is an edge eM where V(e)Fi, then no such solution exists. Let us now consider the case where we try to compute Fi¯. Again by induction, we have Fi1S, and by Remark 6 we know that no edge of M can have both endpoints in S, implying that we must have SMV(Fi)=. Thus, if G[MV(Fi)] is not an independent set, then no such solution exists.

The correctness of Item 1 now directly follows from the induction. The proof of Item 2 is also immediate: if 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v) returns (F,F¯), then F¯=MV(F) follows from the definition, and for S𝖲𝗈𝗅(G) such that vS, FS and SF¯= follows from the induction, and the fact that (S(CH))𝖲𝗈𝗅(G) is true by Remark 6.

To prove Item 3, let S𝖲𝗈𝗅(G), and let S=FS. Notice that HC is partitioned into FF¯ and HC, that F is a vertex cover of G[FF¯] (as F¯=MV(F)), and that S is a vertex cover of G[HC]. Now, let i0 be the index where 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅 stops, meaning that Fi0=Fi01. This implies that N(F¯i0)Fi01, and thus that there is no edge between F¯i0=F¯ and HC, implying that S is a vertex cover of G[HC]. As |S|=|H|, we get that S is a solution of G that avoids v by definition of F.

With the propagation algorithm in hand, Lemma 16 can be proved by constructing a branching algorithm where we either add a vertex v of H or do not add it to the solution. The key properties we use are that: (i) there is always one solution that uses v (e.g. taking the entirety of H), and (ii) we can decide in polynomial time if it is possible to avoid v in a solution. Consequently, we recursively call our branching algorithm only if we know that there is some solution to be found in this branch.

Lemma 16.

There is a polynomial-delay algorithm for Enum Small Crown.

Proof.

Let G=(HC,E) be a small crowned graph and let us define an algorithm 𝒜s that enumerates all vertex covers of G of size |H|. If V(G)=, then 𝒜s returns , so now let vH be an arbitrary vertex. Let (Fv,Fv¯)=𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋(G,{v}), Hv=HFv, Cv=CFv¯, and Gv=G[HvCv]. Algorithm 𝒜s outputs first all solutions of the form FvS, where S are enumerated by a recursive call 𝒜s(Gv). Then, 𝒜s calls 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v). If it fails then 𝒜s stops, otherwise let (Fv¯,F¯v¯) be the output of 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v¯), Hv¯=HFv¯, Cv¯=CF¯v¯, and Gv¯=G[Hv¯Cv¯]. Algorithm 𝒜s outputs then all solutions of the form Fv¯S, where S are enumerated by a recursive call 𝒜S(Gv¯). This concludes the definition of 𝒜s.

First, observe that the recursive calls are made on small crowned graphs, as they were obtained by removing sets (F,F¯) from V(G) where F¯=MV(F). The fact that there is no repetition is immediate by induction, as in particular all solutions of FvS, where S𝖲𝗈𝗅(Gv), contain v, and all solutions of the form Fv¯S′′, where S′′𝖲𝗈𝗅(Gv¯), do not contain v.

Let us prove by induction that all enumerated elements are in 𝖲𝗈𝗅(G). We first consider enumerated sets of the form FvS, where S are enumerated by 𝒜s(Gv). By induction, we get that S𝖲𝗈𝗅(Gv), and by Item 3 of Lemma 11, we get that FvS𝖲𝗈𝗅(G). Now, for enumerated sets of the form Fv¯S′′, where S′′ are enumerated by 𝒜s(Gv¯), the induction hypothesis implies that S𝖲𝗈𝗅(Gv¯), and again by Item 3 of Lemma 15, we have that Fv¯S′′𝖲𝗈𝗅(G).

Let us now prove by induction that all elements of 𝖲𝗈𝗅(G) are enumerated. Let S𝖲𝗈𝗅(G). If vS, then by Lemma 11, S=FvS, where S𝖲𝗈𝗅(Gv), and by induction S will be enumerated by 𝒜s(Gv). If vS, then by Lemma 15, as 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅(G,v) cannot fail (as S exists), S=Fv¯S, where S𝖲𝗈𝗅(Hv¯,Cv¯), and by induction S will be enumerated by 𝒜s(Hv¯,Cv¯).

Finally, there is at most polynomial time between any two solutions, as both 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖽𝗂𝗋 and 𝗉𝗋𝗈𝗉𝖺𝗀𝖺𝗍𝖾𝖺𝗅𝗅 run in polynomial time, and because for any recursive call made on an input G{Gv,Gv¯}, we know according to Remark 6 that 𝖲𝗈𝗅(G). Moreover, the branching tree has height bounded by |V(G)| and every node either: is a leaf, and so falls in the base case where V(G)=; has exactly one child, corresponding to 𝒜s(Gv), for which a solution always exists; or has two children where 𝒜s(Gv) has the same guarantee as in the previous case, and 𝒜s(Gv¯) is called if and only if we know that 𝖲𝗈𝗅(Gv¯) by Lemma 15. Consequently, every leaf of the branching tree corresponds to a solution of G and the time taken between visiting two of them is bounded by a polynomial in |V(G)|+|E(G)|, guaranteeing the desired polynomial delay.

The following theorem is now a direct consequence of Lemmas 9, 12, and 16.

Theorem 1. [Restated, see original statement.]

Enum Vertex Cover admits a PDE kernel with at most 2k vertices when parameterized by the maximum desired size of a solution k.

4 Feedback Vertex Set

Throughout this section, we take (G,k) to be our input instance to Enum Feedback Vertex Set, let XV(G) be a 2-approximation using the algorithm given in [2], 𝖿𝗏𝗌(G) denote the size of a minimum feedback vertex set, and Δ(G) its maximum degree. Thomassé’s [39] strategy can be split into four phases: (i) apply reduction rules to bound the maximum and minimum degrees of the instance; (ii) prove that |V(G)|𝒪(Δ(G)𝖿𝗏𝗌(G)) in graphs of minimum degree three; (iii) identify if there is a vertex v in X that belong to too many vertex-disjoint cycles in (GX){v}; and (iv) once no such v exists, pick a high-degree vertex u, compute a 2-expansion (i.e. a crown decomposition where each head vertex is matched to two unique crown vertices) in an auxiliary graph, and remove all edges from u to the vertices identified by the expansion. As exhaustively applying (iv) implies a bound on the maximum degree, (i) and (ii) will yield the desired kernel. We follow a similar kernelization strategy, but use a substantially different set of rules beyond the basic ones; our presentation is closer to that of Fomin et al. [28, Chapter 5]. We present a generalization of point (i) in Lemma 20: |V(G)|𝒪(Δ(G)𝖿𝗏𝗌(G)) holds even in some of graphs of minimum degree two.

Due to space limitations, all proofs of safeness and associated lifting algorithms of the reductions rules presented in this section have been omitted, and can be found in the full version available online.

We begin by bounding the minimum degree of G; like other works dealing with multigraphs, we define degG(v) as the number of edges incident to a vertex v in G, and omit the subscript when G is clear from the context. We say that uvE(G) is a double-edge if the multiplicity of uv in E(G), denoted by 𝗆𝗎𝗅(uv), is two. Note that a double-edge is equivalent to a cycle of length two in G or, equivalently, that at least one of its endpoints must be present in every solution of the instance. Our first rule is only used to simplify the graph.

Reduction Rule FVS.1 ().

Perform the following modifications:

  1. i.

    If there is an edge uv of G of multiplicity at least three, set its multiplicity to two.

  2. ii.

    If there is some vV(G) of degree at most one, remove v.

  3. iii.

    If u,vV(G) have k+2 common neighbors, add edges uv until 𝗆𝗎𝗅(uv)=2.

  4. iv.

    If there is some vertex v incident to a loop or to k+1 distinct double-edges, remove v and set kk1.

Let us briefly discuss double-edges and their implications to a Feedback Vertex Set instance. Typically, double-edges can be divided into two groups: real edges, where we detect that one of the endpoints in fact belongs to every solution, and virtual edges, that are used to simplify the instance by showing that at least one solution (if any exists) contains one of the endpoints. The key reduction rule of Thomassé [39], which yields the required linear degree bound, makes heavy usage of virtual edges; unfortunately, we do not know how to manage the (potentially exponentially) many solutions that are forbidden in the reduced instance by the introduction of these virtual edges, or an alternative rule to linearly bound the maximum degree. More generally, virtual edges seem to make the lifting process much more complicated. As such we make a special effort to avoid them. In particular, this implies that the naive reduction rule that replaces a degree-two vertex in a triangle with a parallel edge between its neighbors is out of the question. We remark that, while this rule does have an associated lifting procedure, we hope that maintaining only real edges can be leveraged in the future to develop a smaller PDE kernel for Enum Feedback Vertex Set.

In the following rules, we always assume that we are also given an arbitrary but fixed total ordering σ of the vertices of G. This is needed to avoid repeatedly outputting a solution during lifting.

Reduction Rule FVS.2 ().

If three vertices a,x,bV(G) form an induced path with N(x)={a,b} and σ(a)<σ(b), then contract x into a.

We note that the following rule does introduce a virtual double-edge, but we remark that, if applied, it will inevitably trigger Rule FVS.4, and so we do not violate our own constraints.

Reduction Rule FVS.3 ().

If u,x,yV(G) form a triangle with N[x]=N[y]={u,x,y}, and σ(x)<σ(y), then contract y into x, i.e., make 𝗆𝗎𝗅(ux)=2.

Reduction Rule FVS.4 ().

If uV(G) shares double-edges with t1 different vertices εu={v1,,vt} with deg(vi)=2 for every i[t], remove u, every vi, and set kk1.

Reduction Rule FVS.5 ().

If there is a pair of vertices a,bV(G) and a set of degree-two vertices εab={x1,,xt} with N(xi)={a,b} for every i[t] and N(b)={a}εab, then remove N[b] and set kk1.

Lemma 17 ().

Let G be a graph and Δ its maximum degree. If none of the Rules FVS.1, FVS.2, FVS.3, FVS.4, and FVS.5 are applicable, then 𝖿𝗏𝗌(G)|V(G)|/(3Δ3).

With Lemma 17 at hand, we are tasked with bounding the maximum degree of G. Formally, a v-flower of order t is a family of t cycles that pairwise intersect only at vertex v. Rule FVS.6 and Lemma 18 are taken straight from [39]; we omit the proof of the latter for brevity, while we give a proof for the former as we must discuss how to lift the solutions of the reduced instance back to the input instance.

Reduction Rule FVS.6 ().

If there is a vertex vV(G) and an v-flower of order at least k+1, remove v and set kk1.

Lemma 18 (​​[39]).

Let G a multigraph, X a feedback vertex set of G of size at most 2k, and xV(G). In polynomial time, it is possible to accomplish exactly one of the following:

  1. 1.

    Decide if (G,k) has 𝖲𝗈𝗅(G,k)=, i.e., the corresponding decision problem is a 𝗇𝗈-instance;

  2. 2.

    Find a v-flower of order k+1; or

  3. 3.

    Find a set feedback vertex set Hx such that X{x}HxV(G){x} of size at most 3k.

What is left now is to show how to leverage the third property of Lemma 18. To do so, suppose that Rule FVS.6 is not applicable, take vV(G) with deg(v)>3k(k+1)+5k, let Hv be as in Lemma 18, and let 𝒞 denote the set of connected components of G(Hv{v}). Note that, as XHv{v}, each Ci𝒞 is a tree.

Observation 19 ().

There exists 𝒟v𝒞 with |𝒟v|>3k(k+1) such that, for every Di𝒟v: v is adjacent to one vertex of Di with a non-double-edge, and Di has at least one vertex adjacent to a vertex of Hv.

At this point, we essentially have the same setup as Thomassé [39]. Instead of leveraging q-expansions, however, we take a simpler approach, which does not yield a linear bound but allows us to obtain a polynomial PDE kernel; we remark that it is still interesting to explore if these generalizations of crown decompositions can be leveraged to reduce the quadratic bound on the maximum degree that we obtain. We are first going to slightly increase the degree of v, before decreasing it, as follows.

Reduction Rule FVS.7 ().

Let 𝒟v,Hv be as above, and Gv be the bipartite graph with bipartition ({diDi𝒟v},{huuHv}), and dihuE(Gv) if and only if NG(u)Di. For every huV(Gv) of degree at least k+2, add a double-edge uv to G.

We remark that the double-edges introduced by Rule FVS.7 are not virtual: there are k+2 cycles with pairwise intersection equal to {u,v}.

Reduction Rule FVS.8 ().

Let Hv2 be the vertices of Hv with a double-edge to v. If there exists Di𝒟v with NG(Di){v}Hv2, remove vw from G, where wDiNG(v).

Figure 4: Example of repeated applications of Rule FVS.8; where each Di𝒟v is contracted into a single vertex for ease of presentation. The two cyan-shaded vertices correspond to Hv2. The double-edges incident to v are real double-edges, the seven light-gray edges are incident to vertices of 𝒟v not affected by the rule, the four red dashed edges are the ones removed by the reduction rule, and the five solid edges are incident to vertices of 𝒟v affected by the rule.

Rule FVS.8 is our key rule to reduce the maximum degree of the graph; we present an example of repeated applications of it in Figure 4. We are now ready to bound the maximum degree of G by a function of k; along with Lemma 17, this will imply a bound on the overall size of G.

Lemma 20.

If Rules FVS.7 and FVS.8 are not applicable, then G has maximum degree at most 3k(k+1)+5k.

Proof.

Suppose that there is some vV(G) incident to more than 3k(k+1)+5k edges. By Observation 19 and Rule FVS.6, the set 𝒟v of connected components of G(Hv{v}) that v has a neighbor in, but no double-edges to, has size greater than 3k(k+1); moreover, every Di𝒟v has a neighbor in Hv. Now, take some uHv for which 𝗆𝗎𝗅(uv)<2; as Rule FVS.7 is not applicable, we know that NG(u) hits at most k+1 components of 𝒟v. As such, taking Hv2 as in Rule FVS.8, we know that NG(HvHv2) hits at most |HvHv2|(k+1) components of 𝒟v. Note that, if Hv2= and |𝒟v|>|Hv|(k+1), then there is some hHv adjacent to vertices in at least k+2 components of 𝒟v and Rule FVS.7 is applicable, so it must be the case that Hv2. As such, since at most (|Hv|1)(k+1) components of 𝒟v have a vertex adjacent to a vertex in HvHv2, it follows that there is at least one component of 𝒟v whose neighborhood is contained in Hv2{v}, which is enough to trigger Rule FVS.8.

Lemma 21.

There is a polynomial-time algorithm that, given an instance (G,k) of Enum Feedback Vertex Set, either answers that 𝖲𝗈𝗅(G,k)= or outputs an equivalent instance (G,k) where |V(G)|3k3+8k2.

Proof.

The algorithm simply consists of the exhaustive application of Rules FVS.1, FVS.2, FVS.3, FVS.4, FVS.5, FVS.6, FVS.7, and FVS.8, which also guarantee that (G,k) and (G,k) are equivalent. By Lemma 20, we have that the maximum degree Δ of G is at most 3k(k+1)+5k. By Lemma 17, we have that 𝖿𝗏𝗌(G)|V(G)|/(3Δ3). As such, if k(3k(k+1)+5k)<|V(G)|, then we know that no feedback vertex set of size k exists in G, and so 𝖲𝗈𝗅(G,k)=𝖲𝗈𝗅(G,k)=. Otherwise, |V(G)|3k3+3k2+5k2=3k3+8k2 and we are done.

Lemma 22 ().

There is a polynomial-delay algorithm that, given (G,k), (G,k), and S𝖲𝗈𝗅(G,k), returns a non-empty set 𝖫𝗂𝖿𝗍(S)𝖲𝗈𝗅(G,k). Moreover, 𝖫𝗂𝖿𝗍(G,k){𝖫𝗂𝖿𝗍(S)S𝖲𝗈𝗅(G,k)} is a partition of 𝖲𝗈𝗅(G,k).

Finally, the proof of Theorem 2 follows immediately from Lemmas 21 and 22.

Theorem 2. [Restated, see original statement.]

There is a PDE kernel for Enum Feedback Vertex Set parameterized by the size of the solution k with 𝒪(k3) vertices.

5 Final remarks

In this paper, we have developed polynomial-sized PDE kernels for the natural parameterizations of enumeration variants of some key parameterized problems, namely Enum Vertex Cover and Enum Feedback Vertex Set. In this process, we showed how to leverage crown decompositions, an important technique initially developed for decision kernelization, to the enumeration setting. We hope that these results can further motivate the study of this new domain of parameterized complexity. Among concrete open problems, we are interested in the enumeration of minimal vertex covers and feedback vertex sets; we believe our techniques are applicable to these variants of the studied problems. A more challenging question is the existence of a quadratic kernel for Enum Feedback Vertex Set, which we do not see how to obtain using our approach; it seems like tools describing global structures of the graph, like q-expansions, are needed. Finally, we remark that lower bound theories for enumerative kernelization and enumerative parameterized complexity would be of extreme benefit to the area. Currently, lower bounds are derived almost solely via the related parameterized decision problems. It is unlikely, however, that this strategy is enough to (conditionally) classify parameterized enumeration problems into tractable and intractable and which admit polynomial PDE kernels and those that do not.

References

  • [1] Faisal N. Abu-Khzam, Michael R. Fellows, Michael A. Langston, and W. Henry Suters. Crown structures for vertex cover kernelization. Theory of Computing Systems, 41(3):411–430, 2007. doi:10.1007/s00224-007-1328-0.
  • [2] Vineet Bafna, Piotr Berman, and Toshihiro Fujito. A 2-approximation algorithm for the undirected feedback vertex set problem. SIAM Journal on Discrete Mathematics, 12(3):289–297, 1999. doi:10.1137/S0895480196305124.
  • [3] Guillaume Bagan, Arnaud Durand, and Etienne Grandjean. On acyclic conjunctive queries and constant delay enumeration. In Jacques Duparc and Thomas A. Henzinger, editors, Computer Science Logic, pages 208–222, Berlin, Heidelberg, 2007. Springer Berlin Heidelberg. doi:10.1007/978-3-540-74915-8_18.
  • [4] Max Bannach, Zacharias Heinrich, Rüdiger Reischuk, and Till Tantau. Dynamic kernels for hitting sets and set packing. Algorithmica, 84(11):3459–3488, 2022. doi:10.1007/s00453-022-00986-0.
  • [5] Valentin Bartier, Oscar Defrain, and Fionn Mc Inerney. Hypergraph dualization with FPT-delay parameterized by the degeneracy and dimension. In Combinatorial Algorithms: 35th International Workshop, IWOCA 2024, Ischia, Italy, July 1–3, 2024, Proceedings, pages 111–125, Berlin, Heidelberg, 2024. Springer-Verlag. doi:10.1007/978-3-031-63021-7_9.
  • [6] Stéphane Bessy, Marin Bougeret, Dimitrios M. Thilikos, and Sebastian Wiederrecht. Kernelization for Graph Packing Problems via Rainbow Matching, pages 3654–3663. Society for Industrial and Applied Mathematics, 2023. doi:10.1137/1.9781611977554.ch139.
  • [7] Hans L. Bodlaender, Fedor V. Fomin, Daniel Lokshtanov, Eelko Penninkx, Saket Saurabh, and Dimitrios M. Thilikos. (Meta) kernelization. J. ACM, 63(5), November 2016. doi:10.1145/2973749.
  • [8] Hans L. Bodlaender, Bart M. P. Jansen, and Stefan Kratsch. Kernelization lower bounds by cross-composition. SIAM Journal on Discrete Mathematics, 28(1):277–305, 2014. doi:10.1137/120880240.
  • [9] Hans L. Bodlaender and Thomas C. van Dijk. A cubic kernel for feedback vertex set and loop cutset. Theor. Comp. Sys., 46(3):566–597, April 2010. doi:10.1007/S00224-009-9234-2.
  • [10] J.A. Bondy and U.S.R Murty. Graph Theory. Springer Publishing Company, Incorporated, 1st edition, 2008.
  • [11] Marin Bougeret, Bart M. P. Jansen, and Ignasi Sau. Bridge-depth characterizes which minor-closed structural parameterizations of vertex cover admit a polynomial kernel. SIAM J. Discret. Math., 36(4):2737–2773, 2022. doi:10.1137/21M1400766.
  • [12] Kevin Burrage, Vladimir Estivill-Castro, Michael Fellows, Michael Langston, Shev Mac, and Frances Rosamond. The undirected feedback vertex set problem has a poly(k) kernel. In Proceedings of the Second International Conference on Parameterized and Exact Computation, IWPEC’06, pages 192–202, Berlin, Heidelberg, 2006. Springer-Verlag. doi:10.1007/11847250_18.
  • [13] Jonathan F. Buss and Judy Goldsmith. Nondeterminism within P. In Christian Choffrut and Matthias Jantzen, editors, STACS 91, pages 348–359, Berlin, Heidelberg, 1991. Springer Berlin Heidelberg. doi:10.1007/BFB0020811.
  • [14] Guilherme C. M. Gomes, Emanuel Juliano, Gabriel Martins, and Vinicius F. dos Santos. Matching (Multi)Cut: Algorithms, Complexity, and Enumeration. In Édouard Bonnet and Paweł Rzążewski, editors, 19th International Symposium on Parameterized and Exact Computation (IPEC 2024), volume 321 of Leibniz International Proceedings in Informatics (LIPIcs), pages 25:1–25:15, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.IPEC.2024.25.
  • [15] Miroslav Chlebík and Janka Chlebíková. Crown reductions for the minimum weighted vertex cover problem. Discrete Applied Mathematics, 156(3):292–312, 2008. Combinatorial Optimization 2004. doi:10.1016/j.dam.2007.03.026.
  • [16] Nadia Creignou, Markus Kröll, Reinhard Pichler, Sebastian Skritek, and Heribert Vollmer. A complexity theory for hard enumeration problems. Discrete Applied Mathematics, 268:191–209, 2019. doi:10.1016/j.dam.2019.02.025.
  • [17] Nadia Creignou, Arne Meier, Julian-Steffen Müller, Johannes Schmidt, and Heribert Vollmer. Paradigms for parameterized enumeration. Theory of Computing Systems, 60(4):737–758, May 2017. doi:10.1007/s00224-016-9702-4.
  • [18] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [19] Peter Damaschke. Parameterized enumeration, transversals, and imperfect phylogeny reconstruction. Theoretical Computer Science, 351(3):337–350, 2006. Parameterized and Exact Computation. doi:10.1016/j.tcs.2005.10.004.
  • [20] Peter Damaschke. Fixed-parameter enumerability of cluster editing and related problems. Theory of Computing Systems, 46(2):261–283, 2010. doi:10.1007/s00224-008-9130-1.
  • [21] Holger Dell and Dániel Marx. Kernelization of packing problems. In Proceedings of the Twenty-Third Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’12, pages 68–81, USA, 2012. Society for Industrial and Applied Mathematics. doi:10.1137/1.9781611973099.6.
  • [22] Rodney G Downey and Michael R Fellows. Fundamentals of parameterized complexity, volume 4. Springer, 2013. doi:10.1007/978-1-4471-5559-1.
  • [23] Arnaud Durand, Nicole Schweikardt, and Luc Segoufin. Enumerating answers to first-order queries over databases of low degree. In Proceedings of the 33rd ACM SIGMOD-SIGACT-SIGART Symposium on Principles of Database Systems, PODS ’14, pages 121–131, New York, NY, USA, 2014. Association for Computing Machinery. doi:10.1145/2594538.2594539.
  • [24] Henning Fernau. On parameterized enumeration. In Oscar H. Ibarra and Louxin Zhang, editors, Computing and Combinatorics, pages 564–573, Berlin, Heidelberg, 2002. Springer Berlin Heidelberg. doi:10.1007/3-540-45655-4_60.
  • [25] Fedor V. Fomin, Tien-Nam Le, Daniel Lokshtanov, Saket Saurabh, Stéphan Thomassé, and Meirav Zehavi. Subquadratic kernels for implicit 3-hitting set and 3-set packing problems. ACM Trans. Algorithms, 15(1), January 2019. doi:10.1145/3293466.
  • [26] Fedor V. Fomin, Daniel Lokshtanov, Neeldhara Misra, Geevarghese Philip, and Saket Saurabh. Hitting forbidden minors: Approximation and kernelization. SIAM Journal on Discrete Mathematics, 30(1):383–410, 2016. doi:10.1137/140997889.
  • [27] Fedor V. Fomin, Daniel Lokshtanov, Saket Saurabh, and Dimitrios M. Thilikos. Bidimensionality and kernels. SIAM Journal on Computing, 49(6):1397–1422, 2020. doi:10.1137/16M1080264.
  • [28] Fedor V. Fomin, Daniel Lokshtanov, Saket Saurabh, and Meirav Zehavi. Kernelization: Theory of Parameterized Preprocessing. Cambridge University Press, 2019. doi:10.1017/9781107415157.
  • [29] Valentin Garnero, Christophe Paul, Ignasi Sau, and Dimitrios M. Thilikos. Explicit linear kernels via dynamic programming. SIAM Journal on Discrete Mathematics, 29(4):1864–1894, 2015. doi:10.1137/140968975.
  • [30] Petr A. Golovach, Christian Komusiewicz, Dieter Kratsch, and Van B. Le. Refined notions of parameterized enumeration kernels with applications to matching cut enumeration. Journal of Computer and System Sciences, 123:76–102, 2022. doi:10.1016/j.jcss.2021.07.005.
  • [31] David S. Johnson, Mihalis Yannakakis, and Christos H. Papadimitriou. On generating all maximal independent sets. Information Processing Letters, 27(3):119–123, 1988. doi:10.1016/0020-0190(88)90065-8.
  • [32] Eun Jung Kim, Alexander Langer, Christophe Paul, Felix Reidl, Peter Rossmanith, Ignasi Sau, and Somnath Sikdar. Linear kernels and single-exponential algorithms via protrusion decompositions. ACM Trans. Algorithms, 12(2), December 2015. doi:10.1145/2797140.
  • [33] Christian Komusiewicz, Diptapriyo Majumdar, and Frank Sommer. Polynomial-size enumeration kernelizations for long path enumeration, 2025. doi:10.48550/arXiv.2502.21164.
  • [34] Mithilesh Kumar and Daniel Lokshtanov. A 2lk Kernel for l-Component Order Connectivity. In Jiong Guo and Danny Hermelin, editors, 11th International Symposium on Parameterized and Exact Computation (IPEC 2016), volume 63 of Leibniz International Proceedings in Informatics (LIPIcs), pages 20:1–20:14, Dagstuhl, Germany, 2017. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.IPEC.2016.20.
  • [35] A. H. Land and A. G. Doig. An automatic method of solving discrete programming problems. Econometrica, 28(3):497–520, 1960. URL: http://www.jstor.org/stable/1910129.
  • [36] Diptapriyo Majumdar. Enumeration kernels of polynomial size for cuts of bounded degree, 2024. arXiv:2308.01286.
  • [37] Kitty Meeks. Randomised enumeration of small witnesses using a decision oracle. Algorithmica, 81(2):519–540, 2019. doi:10.1007/s00453-018-0404-y.
  • [38] G. L. Nemhauser and L. E. Trotter. Vertex packings: Structural properties and algorithms. Mathematical Programming, 8(1):232–248, 1975. doi:10.1007/BF01580444.
  • [39] Stéphan Thomassé. A 4k2 kernel for feedback vertex set. ACM Trans. Algorithms, 6(2), April 2010. doi:10.1145/1721837.1721848.