Kernelization of Packing Problems

TL;DR

This paper establishes tight lower bounds on kernel sizes for packing problems like d-Set Matching under complexity assumptions, and introduces new polynomial kernels for certain graph packing problems.

Contribution

It provides the first tight lower bounds for kernel sizes of packing problems and develops a general scheme for proving such bounds.

Findings

Tight lower bounds for d-Set Matching kernel sizes.

Polynomial kernels with O(k^2.5) edges for vertex-disjoint paths of length three.

A general reduction scheme for establishing kernel lower bounds.

Abstract

Kernelization algorithms are polynomial-time reductions from a problem to itself that guarantee their output to have a size not exceeding some bound. For example, d-Set Matching for integers d>2 is the problem of finding a matching of size at least k in a given d-uniform hypergraph and has kernels with O(k^d) edges. Bodlaender et al. [JCSS 2009], Fortnow and Santhanam [JCSS 2011], Dell and Van Melkebeek [JACM 2014] developed a framework for proving lower bounds on the kernel size for certain problems, under the complexity-theoretic hypothesis that coNP is not contained in NP/poly. Under the same hypothesis, we show tight lower bounds for the kernelization of d-Set Matching and other packing problems. Our bounds are tight for d-Set Matching: It does not have kernels with O(k^{d-{\epsilon}}) edges for any {\epsilon}>0 unless the hypothesis fails. By reduction, this transfers to a bound of O(k^{d-1-{\epsilon}}) for the problem of finding k vertex-disjoint cliques of size d in standard graphs. Obtaining tight bounds for graph packing problems is challenging: We make first progress in this direction by showing non-trivial kernels with O(k^2.5) edges for the problem of finding k vertex-disjoint paths of three edges each. If the paths have d edges each, we improve the straightforward O(k^{d+1}) kernel to a uniform polynomial kernel where the exponent of the kernel size is independent of k. Most of our lower bound proofs follow a general scheme that we discover: To exclude kernels of size O(k^{d-{\epsilon}}) for a problem in d-uniform hypergraphs, one should reduce from a carefully chosen d-partite problem that is still NP-hard. As an illustration, we apply this scheme to the vertex cover problem, which allows us to replace the number-theoretical construction by Dell and Van Melkebeek [JACM 2014] with shorter elementary arguments.

Equations

$$\left(\genfrac{}{}{0ex}{}{{\mathrm{deg}}_H(m)}{2}\right)\ge {\mathrm{deg}}_H(m{)}^2/4-1.$$

$$\sum _{m\in M}\left(\genfrac{}{}{0ex}{}{{\mathrm{deg}}_H(m)}{2}\right)$$

$$\ge \frac{1}{4|M|}{\left(\sum _{m\in M}{\mathrm{deg}}_H(m)\right)}^2-|M|$$

$$\ge \frac{1}{4|M|}(|X|-|M|{)}^2-|M|=\Omega (|X{|}^2/k)$$

Full text

Our bounds are tight for $d$-Set Matching: It does not have kernels with $O(k^{d-\varepsilon})$ edges for any $\varepsilon>0$ unless the hypothesis fails. By reduction, this transfers to a bound of $O(k^{d-1-\varepsilon})$ for the problem of finding $k$ vertex-disjoint cliques of size $d$ in standard graphs. Obtaining tight bounds for graph packing problems is challenging: We make first progress in this direction by showing non-trivial kernels with $O(k^{2.5})$ edges for the problem of finding $k$ vertex-disjoint paths of three edges each. If the paths have $d$ edges each, we improve the straightforward $O(k^{d+1})$ kernel can be improved to a uniform polynomial kernel where the exponent of the kernel size is independent of $k$.

Most of our lower bound proofs follow a general scheme that we discover: To exclude kernels of size $O(k^{d-\varepsilon})$ for a problem in $d$-uniform hypergraphs, one should reduce from a carefully chosen $d$-partite problem that is still $\mathsf{NP}$-hard. As an illustration, we apply this scheme to the vertex cover problem, which allows us to replace the number-theoretical construction by Dell and Van Melkebeek [JACM 2014] with shorter elementary arguments.

1 Introduction

Algorithms based on kernelization play a central role in fixed-parameter tractability and perhaps this kind of parameterized algorithms has the most relevance to practical computing. Recall that a problem is fixed-parameter tractable parameterized by some parameter $k$ of the instance if it can be solved in time $f(k)\cdot n^{O(1)}$ for some computable function $f$ depending only on the parameter $k$ (see [9, 12, 17, 33]). A kernelization algorithm for a problem $P$ is a polynomial-time algorithm that, given an instance $x$ of the problem $P$ with parameter $k$, creates an equivalent instance $x^{\prime}$ of $P$ such that the size of $x^{\prime}$ and the parameter $k^{\prime}$ of the new instance are both bounded from above by a function $f(k)$. For example, the classical result of [32] can be interpreted as a kernelization algorithm that, given an instance of Vertex Cover, produces an equivalent instance on at most $2k$ vertices, which implies that it has at most $\binom{2k}{2}$ edges. A kernelization algorithm can be thought of as preprocessing that creates an equivalent instance whose size has a mathematically provable upper bound that depends only on the parameter of the original instance and not on the size of the original instance. Practical computing often consists of a heuristic preprocessing phase to simplify the instance followed by an exhaustive search for solutions (by whatever method available). Clearly, it is desirable that the preprocessing shrinks the size of the instance as much as possible. Kernelization is a framework in which the efficiency of the preprocessing can be studied in a rigorous way.

One can find several examples in the parameterized complexity literature for problems that admit a kernel with relatively small sizes, i.e., for problems where $f(k)$ is polynomial in $k$. There are efficient techniques for obtaining such results for particular problems (e.g., [35, 21, 8, 28, 1]). Some of these techniques go back to the early days of parameterized complexity and have been refined for several years. In later developments, general abstract techniques were developed that give us kernelization results for several problems at once [18, 3].

[2] developed a framework for showing that certain parameterized problems are unlikely to have kernels of polynomial size, and [19] proved the connection with the complexity-theoretic hypothesis $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$. In particular, for several basic problems, such as finding a cycle of length $k$, a kernelization with polynomial size would imply that the hypothesis is false. The framework of [2] has led to a long series of hardness results showing that several concrete problems with various parameterizations are unlikely to have kernels of polynomial size [7, 6, 11, 1, 26, 27, 25, 4, 5, 30].

[10] refined the complexity results of [19, 2] to prove conditional lower bounds also for problems that do admit polynomial kernels. For example, they show that Vertex Cover does not have kernels of size $O(k^{2-\varepsilon})$ unless the hypothesis $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$ fails. Similar lower bounds are given for several other graph covering problems where the goal is to delete the minimum number of vertices in such a way that the remaining graph satisfies some prescribed property. Many of the lower bounds are tight as they match the upper bounds of the best known kernelization algorithms up to an arbitrarily small $\varepsilon$ term in the exponent.

In the present paper, we also obtain kernel lower bounds for problems that have polynomial kernels, but the family of problems that we investigate is very different: packing problems. Covering and packing problems are dual to each other, but there are significant differences in the way they behave with respect to fixed-parameter tractability. For example, techniques such as bounded search trees or iterative compression are mostly specific to covering problems, while techniques such as color coding are mostly specific to packing problems. Feedback Vertex Set is the problem of covering all cycles and has kernels with $O(k^{2})$ edges [35, 10], while its packing version is the problem of finding $k$ vertex-disjoint cycles and is unlikely to have polynomial kernels [6]. Therefore, the techniques for understanding the kernelization complexity of covering and packing problems are expected to differ very much. Indeed, the proofs of [10] for the problem of covering sets of size $d$ cannot be straightforwardly adapted to the analogous problem of packing sets of size $d$.

Our contributions are twofold. First, we obtain lower bounds on the kernel size for packing sets and packing disjoint copies of a prescribed subgraph $H$. An example of the latter is the problem of finding $k$ vertex-disjoint $d$-cliques in a given graph. For packing sets, our lower bound is tight, while determining the best possible kernel size for graph packing problems with every fixed $H$ remains an interesting open question. Fully resolving this question would most certainly involve significantly new techniques both on the complexity and the algorithmic side. To indicate what kind of difficulties we need to overcome for the resolution of this question, we show kernels with $O(k^{2.5})$ edges for the problem of packing $k$ vertex-disjoint paths on three edges. Moreover, we show that the problem of packing $k$ vertex-disjoint paths on $d$ edges admits a uniformly polynomial kernel, that is, a polynomial kernel where the exponent of the running time and the kernel size does not depend on $d$.

Secondly, the techniques used in our lower bounds are perhaps as important as the concrete results themselves. We present a simple and clean way of obtaining lower bounds of the form $O(k^{d-\varepsilon})$. Roughly speaking, the idea is to reduce from an appropriate $d$-partite problem by observing that if we increase the size of the universe by a factor of $t^{1/d}$, then we can conveniently pack together $t$ instances. A similar effect was achieved by [10], but it used a combinatorial tool called the Packing Lemma, whose proof uses nontrivial number-theoretical arguments. As a demonstration, we show that our scheme allows us to obtain the main kernelization results of [10] with very simple elementary techniques. Furthermore, this scheme proves to be very useful for packing problems, even though in one of our lower bounds it was easier to invoke the Packing Lemma. It seems that both techniques will be needed for a complete understanding of graph packing problems.

1.1 Results

The matching problem in $d$-uniform hypergraphs, $d$-Set Matching, is to decide whether a given hypergraph has a matching of size $k$, i.e., a set of $k$ pairwise disjoint hyperedges. Correspondingly, the Perfect $d$-Set Matching problem is to find a perfect matching, i.e., a matching with $k=n/d$ where $n$ is the number of vertices. Finally, Perfect $d$-Dimensional Matching is the problem Perfect $d$-Set Matching when restricted to $d$-partite hypergraphs, i.e., hypergraphs partitioned into $d$ color classes so that each hyperedge has at most one vertex per color class. [15] give a kernelization algorithm for $d$-Set Matching, which is the most general of these three problems.

Theorem 1.1** ([15]).**

*The problem $d$-Set Matching has kernels with $O(k^{d})$ hyperedges. *

In Appendix A, we sketch a straightforward but instructive proof of this fact using the sunflower lemma of [13]. Our main result is that the kernel size above is asymptotically optimal under the hypothesis $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$.

Theorem 1.2**.**

*Let $d\geq 3$ be an integer and let $\varepsilon$ be a positive real. If $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$ holds, then Perfect $d$-Dimensional Matching does not have kernels with $O(k^{d-\varepsilon})$ hyperedges. *

Since Perfect $d$-Dimensional Matching is the special case of $d$-Set Matching where $k=n/d$ and the input graphs are $d$-partite, the lower bound applies to that problem as well and it shows that the upper bound in Theorem 1.1 is asymptotically tight.

A particularly well-studied special case of set matching is when the sets are certain fixed subgraphs (e.g., triangles, cliques, stars, etc.) of a given graph. We use the terminology of [37], who surveys graph theoretical properties of such graph packing problems. Formally, an $H$-matching of size $k$ in a graph $G$ is a collection of $k$ vertex-disjoint subgraphs of $G$ that are isomorphic to $H$. The problem $H$-Matching is to find an $H$-matching of a given size in a given graph. Both problems are $\mathsf{NP}$-complete whenever $H$ contains a connected component with more than two vertices [24] and is in $\mathsf{P}$ otherwise.

The kernelization properties of graph packing problems received a lot of attention in the literature (e.g., [31, 14, 34, 16, 36, 29]). The problem $H$-Matching can be expressed as a $d$-Set Matching instance with $O(k^{d})$ edges (where $d\coloneqq|V(H)|$) and therefore Theorem 1.1 implies a kernel of size $O(k^{d})$. In the particularly interesting special case when $H$ is a clique $K_{d}$, we use a simple reduction to transfer the above theorem to obtain a lower bound for $K_{d}$-Matching.

Theorem 1.3**.**

*Let $d\geq 3$ be an integer and let $\varepsilon$ be a positive real. If $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$ holds, then $K_{d}$-Matching does not have kernels with $O(k^{d-1-\varepsilon})$ edges. *

An upper bound of size $O(k^{d})$ follows for $K_{d}$-Matching from Theorem 1.1. This does not quite match our conditional lower bounds of $O(k^{d-1-\varepsilon})$, and it is an interesting open problem to make the bounds tight.

The $H$-Factor problem is the restriction of $H$-Matching to the case $k=n/d$, that is, the task is to find an $H$-matching that involves all vertices. For every fixed graph $H$, the problem $H$-Factor has kernels with $O(k^{2})$ edges, for the trivial reason that an $n$-vertex instance has size $O(n^{2})$ and we have $k=\Theta(n)$ by the definition of $H$-Factor. We show that this bound is tight for every $\mathsf{NP}$-hard $H$-Factor problem.

Theorem 1.4**.**

*Let $H$ be a connected graph with $d\geq 3$ vertices and $\varepsilon$ a positive real. If $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$ holds, then $H$-Factor does not have kernels with $O(k^{2-\varepsilon})$ edges. *

Thus, it is unlikely that instances of $H$-Factor can be reduced in polynomial time to sparse instances. The proof of this result is based on the Packing Lemma of [10].

Obtaining tight bounds for $H$-Matching in general seems to be a challenging problem. As Theorem 1.3 shows in the case of cliques, the lower bound of $O(k^{2-\varepsilon})$ for $H$-Matching implied by Theorem 1.4 is not always tight. On the other hand, the upper bound of $O(k^{|V(H)|})$ is not always tight either: A simple high-degree reduction rule shows that if $H$ is a star of arbitrary size, then kernel with $O(k^{2})$ edges are possible, which is tight by Theorem 1.4. Furthermore, if $H=P_{3}$ is a path on 3 edges, then a surprisingly nontrivial extremal argument gives us the following.

Theorem 1.5**.**

$P_{3}$-Matching* has kernels with $O(k^{2.5})$ edges. *

We don’t know currently if the exponent 2.5 is tight or the kernel size can be perhaps improved to $O(k^{2})$. Theorem 1.5 raises the obvious question of how the exponent behaves for $P_{d}$-Matching if $d$ increases (where $P_{d}$ is the path on $d$ edges): does it go to infinity or is there a universal constant bound on the exponent of the kernel size for every $P_{d}$-Matching problem? We show that there is a “uniformly polynomial” kernel for $P_{d}$-Matching for any $d$:

Theorem 1.6**.**

For $P_{d}$-Matching (with $d$ being part of the input),

we can compute in time $n^{O(1)}$ a kernel of size $f(d)\cdot k^{O(1)}$, and 2. 2.

we can compute in time $f(d)\cdot n^{O(1)}$ a kernel of size $k^{O(1)}$,

*where $f(d)$ is some computable function. *

We cannot expect to improve Theorem 1.6 to kernels that can be computed in time $n^{O(1)}$ and achieve size $k^{O(1)}$ or even $(kd)^{O(1)}$, because setting $k=1$ would then yield a polynomial kernel for the $d$-Path problem, which is known to imply $\mathsf{coNP}\subseteq\mathsf{NP/poly}$. The significance of these subtle differences in the running times/kernel sizes shows that one has to be very careful when talking about “uniformly polynomial” kernelization for a family of problems, as small changes in the definitions can matter a lot. In Section 5, we examine how Path Matching, Clique Matching, and Set Matching behave under subtly different definitions. Uniform kernelization was studied also by [20], in the context of hitting forbidden minors.

The examples of cliques, stars, and paths show that the exact bound on the kernel size of $H$-Matching for a particular $H$ could be very far from the $O(k^{|V(H)|})$ upper bound provided by the sunflower kernel or the $O(k^{2-\varepsilon})$ lower bound of Theorem 1.4. It seems to be very challenging to obtain tight upper and lower bounds on the kernel sizes for all $H$. Our proofs of Theorem 1.5 and Theorem 1.6 indicate what kind of combinatorial problems we have to understand for a full solution. However, we want to point out that the algorithms in these proofs are very “fragile” in that they heavily rely on extremal properties of paths in graphs, and we were unable to extend them even in minor ways, such as to the problem of matching paths of length $d$ starting in the set $X$, or going from set $X$ to set $Y$.

After obtaining our results, we learnt that [22] independently achieved kernel lower bounds for packing problems using the paradigm of Lemma 2.1. In particular, their bounds for $d$-Set Matching and $K_{d}$-Matching are $O(k^{d-3-\varepsilon})$ and $O(k^{d-4-\varepsilon})$, respectively.

2 Techniques

The $\operatorname{OR}$ of a language $L$ is the language $\operatorname{OR}(L)$ that consists of all tuples $(x_{1},\dots,x_{t})$ for which there is an $i\in[t]$ with $x_{i}\in L$. Instances $\overline{x}=(x_{1},\dots,x_{t})$ for $\operatorname{OR}(L)$ have two natural parameters: the length $t$ of the tuple and the maximum bitlength $s=\max_{i}|x_{i}|$ of the individual instances for $L$. The following lemma captures the method that was used by [10] to prove conditional kernel lower bounds.

Lemma 2.1**.**

Let $\Pi$ be a problem parameterized by $k$ and let $L$ be an $\mathsf{NP}$-hard problem. Assume that there is a polynomial-time mapping reduction $f$ from $\operatorname{OR}(L)$ to $\Pi$ and a number $d>0$ with the following property: given an instance $\overline{x}=(x_{1},\dots,x_{t})$ for $\operatorname{OR}(L)$ in which each $x_{i}$ has size at most $s$, the reduction produces an instance $f(\overline{x})$ for $\Pi$ whose parameter $k$ is at most $t^{1/d+o(1)}\cdot\operatorname{poly}(s)$.

*Then $\Pi$ does not have kernels of size $O(k^{d-\varepsilon})$ for any $\varepsilon>0$ unless $\mathsf{coNP}\subseteq\mathsf{NP/poly}$. *

[2] formulated this method without the dependency on $t$. This suffices to prove polynomial kernel lower bounds since $d$ can be chosen as an arbitrarily large constant. [10] adapted the proofs of [19, 2] to obtain the formulation above, and generalized it to an oracle communication setting.

We now informally explain a simple scheme for proving kernel lower bounds of the form $O(k^{d-\varepsilon})$ for a parameterized problem $\Pi$. Lemma 2.1 requires us to devise a reduction from $\operatorname{OR}(L)$ (for some $\mathsf{NP}$-hard language $L$) to $\Pi$ whose output instances have parameter $k$ at most $t^{1/d}\cdot\operatorname{poly}(s)$. We carefully select a problem $L$ whose definition is $d$-partite in a certain sense, and we design the reduction from $\operatorname{OR}(L)$ to $\Pi$ using the general scheme described. Most problem parameters can be bounded from above by the number of vertices; therefore, what we need to ensure is that the number of vertices increases roughly by at most a factor of $t^{1/d}$.

For simplicity of notation, we informally describe the case $d=2$ first. We assume that $L$ is a bipartite problem, meaning that each instance is defined on two sets $U$ and $W$, and “nothing interesting is happening inside $U$ or inside $W$.” We construct the instance of $\Pi$ by taking $\sqrt{t}$ copies of $U$ and $\sqrt{t}$ copies of $W$. For each of the $t$ instances of $L$ appearing in the $\operatorname{OR}(L)$ instance, we select a copy $U^{\prime}$ of $U$ and a copy $W^{\prime}$ of $W$, and we embed the instance of $L$ into the union $U^{\prime}\cup W^{\prime}$. This way, we can embed all $\sqrt{t}\cdot\sqrt{t}=t$ instances of $L$ such that each pair $(U^{\prime},W^{\prime})$ is selected for exactly one instance of $L$. The fact that $L$ is a bipartite problem helps ensuring that two instances of $L$ sharing the same copy of $U$ or the same copy of $W$ do not interfere. A crucial part of the reduction is to ensure that every solution of the constructed instance can use at most one copy of $U$ and at most one copy of $W$. If we can maintain this property (using additional arguments or introducing gadgets), then it is usually easy to show that the constructed instance has a solution if and only if at least one of the $\sqrt{t}\cdot\sqrt{t}$ instances appearing in its construction has a solution.

For $d>2$, the scheme is similar. We start with a $d$-partite problem $L$ and make $t^{1/d}$ copies of each partition class. Then there are $(t^{(1/d)})^{d}=t$ different ways of selecting one copy from each class, and therefore we can compose together $t$ instances following the same scheme.

As a specific example, let us consider $\Pi=\textsc{Vertex Cover}$ in graphs, where we have $d=2$. The known kernel lower bound for this problem can be reproved more elegantly by choosing $L$ in a not completely obvious way. In particular, we let $L$ be Multicolored Biclique:

Input:

A bipartite graph $B$ on the vertex set $U\mathbin{\dot{\cup}}W$, an integer $k$, and partitions $U=(U_{1},\dots,U_{k})$ and $W=(W_{1},\dots,W_{k})$.

Decide:

Does $B$ contain a biclique $K_{k,k}$ that has a vertex from each of the sets $U_{1},\dots,U_{k}$ and $W_{1},\dots,W_{k}$?

This is a problem on bipartite graphs and $\mathsf{NP}$-complete as we prove in Appendix B.

Theorem 2.2** ([10]).**

If $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$, then Vertex Cover does not have kernels with $O(k^{2-\varepsilon})$ edges.

Proof*.*

We apply Lemma 2.1 with $L=\textsc{Multicolored Biclique}$. To this end, we devise a reduction that is given an instance $(B_{1},\dots,B_{t})$ for $\operatorname{OR}(L)$ and outputs one instance of Vertex Cover with at most $\sqrt{t}\cdot\operatorname{poly}(s)$ vertices, where $s$ is the largest size among the $B_{1},\dots,B_{t}$. We can assume without loss of generality that every instance $B_{i}$ has the same number $k$ of blocks in the partitions and every block in every instance $B_{i}$ has the same size $n$: we achieve this property by adding at most $\operatorname{poly}(s)$ isolated vertices to each instance, which will not affect the correctness or the asymptotic size bound. Similarly, we can assume that $\sqrt{t}$ is an integer. In the following, we refer to the $t$ instances of $L$ instance as $B_{(i,j)}$ for $i,j\in\{1,\dots,\sqrt{t}\}$, and we let $U_{(i,j)}$ and $W_{(i,j)}$ be the two parts of the bipartite graph $B_{(i,j)}$.

After this preprocessing, the reduction modifies each instance $B_{(i,j)}$ so that $U_{(i,j)}$ and $W_{(i,j)}$ become complete $k$-partite graphs; more precisely, if two vertices in $U_{(i,j)}$ or two vertices in $W_{(i,j)}$ are in different blocks (that is, they have different colors), then we make them adjacent. The new graph $B^{\prime}_{(i,j)}$ has a $2k$-clique if and only if there is a correctly partitioned $K_{k,k}$ in $B_{(i,j)}$.

Next, the reduction constructs a graph $G$ by introducing $2\sqrt{t}$ sets $U^{1}$, $\dots$, $U^{\sqrt{t}}$ and $W^{1}$, $\dots$, $W^{\sqrt{t}}$ of $kn$ vertices each. For every $i,j\in\{1,\dots,\sqrt{k}\}$, we copy the graph $B^{\prime}_{(i,j)}$ to the vertex set $U^{i}\cup W^{j}$ by injectively mapping $U_{(i,j)}$ to $U^{i}$ and $W_{(i,j)}$ to $W^{j}$. Note that $U_{(i,j)}$ and $W_{(i,j)}$ induces the same complete $k$-partite graph in $B^{\prime}_{(i,j)}$ for every $i$ and $j$, thus this copying can be done in such a way that $G[U^{i}]$ receives the same set of edges when copying $B^{\prime}_{(i,j)}$ for any $j$ (and similarly for $G[W^{j}]$). Therefore, $G[U^{i}\cup W^{j}]$ is isomorphic to $B^{\prime}_{(i,j)}$ for every $i,j$.

We claim that $G$ has a $2k$-clique if and only if at least one $B^{\prime}_{(i,j)}$ has a $2k$-clique (and therefore at least one $B_{(i,j)}$ has a correctly partitioned $K_{k,k}$). The reverse direction is clear, as $B^{\prime}_{(i,j)}$ is a subgraph of $G$ by construction and thus every clique in $B^{\prime}_{(i,j)}$ is also a clique in $G$. For the forward direction, observe that $G$ has no edge between $U^{i}$ and $U^{i^{\prime}}$ if $i\neq i^{\prime}$, and between $W^{j}$ and $W^{j^{\prime}}$ if $j\neq j^{\prime}$. Therefore, the $2k$-clique of $G$ is fully contained in $G[U^{i}\cup W^{j}]$ for some $i,j$. As $G[U^{i}\cup W^{j}]$ is isomorphic to $B^{\prime}_{(i,j)}$, this means that $B^{\prime}_{(i,j)}$ also has a $2k$-clique.

Let $N$ be the number of vertices in $G$ and note that $N=2\sqrt{t}\cdot kn\leq t^{1/2}\cdot\operatorname{poly}(s)$ holds. The graph $G$ has a $2k$-clique if and only if its complement $\overline{G}$ has a vertex cover of size $N-2k$. So, if at the end our reduction outputs $\overline{G}$, the algorithm we constructed is indeed a polynomial-time reduction from $\operatorname{OR}(L)$ to Vertex Cover that achieves the size bound required for Lemma 2.1. ■

In Appendix C, we extend the elegant version of this proof to the vertex cover problem for $d$-uniform hypergraphs.

3 Kernelization of the Set Matching Problem

The $d$-Set Matching problem is given a $d$-uniform hypergraph to find at least $k$ disjoint hyperedges. For $d=2$, this is the maximum matching problem in graphs, which is polynomial-time solvable. The restriction of the problem to $d$-partite hypergraphs and $k=n/d$ is the Perfect $d$-Dimensional Matching and $\mathsf{NP}$-hard [23] for $d\geq 3$.

We use Lemma 2.1 to prove that the kernel size in Theorem 1.1 is asymptotically optimal under the hypothesis $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$. For the reduction, we use gadgets with few vertices that coordinate the availability of groups of vertices. For example, we may have two sets $U_{1},U_{2}$ of $s$ vertices each and our gadget makes sure that, in every perfect matching of the graph, one set is fully covered by the gadget while all vertices of the other group have to be covered by hyperedges external to the gadget (see Figure 1). Ultimately, we design gadgets that enable us to select exactly one of the $m=t^{1/d}$ blocks in each of the $d$ color classes, which will in turn activate one of the $t=m^{d}$ instances of the $\operatorname{OR}$-problem. The precise formulation of the gadget is as follows.

Lemma 3.1** (Selector gadget).**

Let $d\geq 3$, $m\geq 1$, and $s\geq 1$ be integers. There is a $d$-partite $d$-uniform hypergraph $S$ with $O(dms)$ vertices and disjoint blocks $U_{1},\dots,U_{m}\subseteq V(S)$, each of size $s$ and in the same color class of $S$, such that the following conditions hold.

1. (i)

(Completeness) $S-U_{i}$ has a unique perfect matching for all $i\in[m]$. 2. (ii)

(Soundness) For all sets $B\subseteq U_{1}\cup\dots\cup U_{m}$ so that $B\neq U_{i}$ for any $i\in[m]$, the graph $S-B$ does not have a perfect matching.

*Moreover, the graph can be computed in polynomial time. *

The fact that the selector gadget is $d$-partite gives us the result for Perfect $d$-Dimensional Matching rather than just for $d$-Set Matching, and it is also useful in the reduction to $K_{d}$-Matching. We defer the proof of Lemma 3.1 to §3.1, and use it now to prove the following reduction.

Lemma 3.2**.**

*Let $d\geq 3$ be an integer. There is a polynomial-time mapping reduction from $\operatorname{OR}($Perfect $d$-Dimensional Matching$)$ to Perfect $d$-Dimensional Matching that maps $t$-tuples of instances of bitlength $s$ each to instances on $t^{1/d}\cdot\operatorname{poly}(s)$ vertices. *

Proof*.*

Let $G_{1},\dots,G_{t}$ be instances of Perfect $d$-Dimensional Matching, that is, $d$-partite $d$-uniform hypergraphs of size $s$ each. We can assume w.l.o.g. that each color class of each $G_{i}$ contains exactly $n/d$ vertices where $n\leq s$. The goal is to find out whether some $G_{i}$ contains a perfect matching. We reduce this question to a single instance $G$ on few vertices.

The vertex set of $G$ consists of $d\cdot t^{1/d}$ groups of $n/d$ vertices each, i.e., $V(G)=\bigcup_{a,b}V_{a,b}$ for $a\in[d]$ and $b\in[t^{1/d}]$. Then we can write the input graphs as $G_{b}$ using an index vector $b=(b_{1},\dots,b_{d})\in[t^{1/d}]^{d}$. For each graph $G_{b}$ we add edges to $G$ in the following way: We identify the vertex set of $G_{b}$ with $V_{1,b_{1}}\mathbin{\dot{\cup}}\dots\mathbin{\dot{\cup}}V_{d,b_{d}}$, and we let $G$ contain all the edges of $G_{b}$. Since each $G_{b}$ is $d$-partite, the same is true for $G$ at this stage of the construction. Now we modify $G$ such that each perfect matching of $G$ only ever uses edges originating from at most one graph $G_{b}$. For this it suffices to add a gadget for every $a\in[d]$ that blocks all but exactly one group $V_{a,b}$ in every perfect matching. For each $a\in[d]$, we add an independent copy $S_{a}$ of the gadget $S$ from Lemma 3.1 to $G$, where we identify the sets $U_{1}=V_{a,1}$ up to $U_{m}=V_{a,m}$. Clearly, $|V(G)|\leq O(st^{1/d})$, and the graph $G$ is $d$-partite as this is true for the input graphs and the gadgets.

Now we verify the correctness of the reduction. If some $G_{b}$ has a perfect matching, then the completeness property of $S_{a}$ ensures that $S_{a}-V_{a,b_{a}}$ has a unique perfect matching for all $a\in[d]$. Together with the perfect matching of $G_{b}$, this gives a perfect matching of $G$.

For the soundness, assume $M$ is a perfect matching of $G$. Consider now the copy of $S_{a}$ introduced into the construction. The vertex set of this gadget is $\bigcup_{i=1}^{m}V_{a,i}$ and a set $Z_{a}$ of vertices private to this gadget. Let $M_{a}\subseteq M$ be the set of those edges that contain at least one vertex of $Z_{a}$. Then $M_{a}$ covers every vertex of $Z_{a}$ and a subset of $\bigcup_{i=1}^{m}V_{a,i}$. Now Lemma 3.1(ii) implies that there is a $b_{a}$ such that $M_{a}$ covers every vertex of $\bigcup_{i=1}^{m}V_{a,i}$ except $V_{a,b_{a}}$. It follows that $M^{*}=M\setminus\bigcup_{a\in[d]}M_{a}$ covers every $V_{a,b_{a}}$. Since $V_{a,b_{a}}$ is an independent set in $S_{a}$, we hav e that $M^{*}$ uses only edges of $G_{b}$ to cover the $V_{a,b_{a}}$. In particular, $G_{b}$ has a perfect matching. ■

Theorem 1.2, our kernel lower bound for $d$-Set Matching, now follows immediately by combining the above with Lemma 2.1.

3.1 Construction of the Selector Gadget

Proof* (of Lemma 3.1).*

We first implement the selector gadget $S_{m}$ for $m=2$ and then use this as a building block for $m>2$.

The switch gadget $S=S_{2}$ is a $d$-uniform cycle $e_{1},\dots,e_{2s}$ as depicted on the left in Figure 1. Formally, we impose the following structure (where indices are understood modulo $2s$):

• $\circ$

$|e_{i}\cap e_{i+1}|=1$ if $i$ is odd.

• $\circ$

$|e_{i}\cap e_{i+1}|=d-2$ if $i$ is even.

• $\circ$

$|e_{i}\cap e_{j}|=0$ if $j\not\in\{i-1,i,i+1\}$.

The graph contains $O(ds)$ vertices. We set the two sets of size $s$ that we want to switch between as $U_{1}=\bigcup_{\text{odd }i}e_{i}\setminus\bigcup_{\text{even }i}e_{i}$ and $U_{2}=\bigcup_{\text{even }i}e_{i}\setminus\bigcup_{\text{odd }i}e_{i}$. To show the required properties, let us first note that the hypergraph graph is $d$-partite: The vertices of $U_{1}\cup U_{2}$ form color class $1$, the vertices appearing in the intersections $e_{i}\cap e_{i+1}$ for odd $i$ form color class $2$, and the remaining vertices form color classes $3$ through $d$. For the soundness, note that removing $U_{1}$ from the graph also removes the edges $e_{i}$ with odd indices, and the edges that remain form a perfect matching of $S-U_{1}$. The case of removing $U_{2}$ is analogous. For the completeness, note that removing any set $B\subseteq U_{1}\cup U_{2}$ other than $U_{1}$ or $U_{2}$ from $S$ leaves a graph that does not have a perfect matching.

Now let $m>2$ and let $U_{1},\dots,U_{m}$ be disjoint sets of size $s$ each. We construct $S=S_{m}$ as on the bottom right of Figure 1 by adding independent copies of the graph $S_{2}$ between $U_{1}$ and $U_{2}$, between $U_{2}$ and $U_{3}$, and in general between $U_{i}$ and $U_{i+1}$ for all $i\in[m-1]$. The graph is trivially $d$-partite since this was true for $S_{2}$ and the sets $U_{1}\cup\dots\cup U_{m}$ are all in the same color class, say $1$; the number of vertices of $S$ is $O(dms)$. For the completeness, consider the graph $S-U_{i}$ for some $i\in[m]$. By the completeness of $S_{2}$, the two instances of $S_{2}$ that are incident to $U_{i}$ can be completed to a perfect matching that covers $U_{i-1}$ and $U_{i+1}$. We can continue applying the completeness property of $S_{2}$ inductively to find the unique perfect matching of $S-U_{i}$.

The soundness property of $S_{2}$ implies that ${B\cap(U_{i}\cup U_{i+1})}$ must be equal to $U_{i}$ or $U_{i+1}$ for all $i$ or else there cannot be a perfect matching. Moreover, assume that $B$ contains more than one set $U_{i}$. By the soundness of $S_{2}$, these sets cannot be adjacent or else there is no perfect matching. Let us for simplicity assume that $B$ contains exactly two non-adjacent sets, say $B=\{U_{1},U_{i}\}$, and we assume for contradiction that $S-B$ does not contain a perfect matching. Then the completeness property of $S_{2}$ implies that there is exactly one perfect matching between $U_{i-1}$ and $U_{i}$ that does not use vertices from $U_{i}$ but covers all vertices of $U_{i-1}$. Thus $S-(U_{1}\cup U_{i-1})$ also contains a perfect matching. By induction, we can see that $S-(U_{1}\cup U_{2})$ has a perfect matching, which we already ruled out. Overall, we get $B=U_{i}$ for some $i$. ■

4 Kernel Lower Bounds for Graph Matching Problems

For a graph $H$, the $H$-Matching problem is given a graph $G$ to find a maximal number of vertex-disjoint copies of $H$. This problem is $\mathsf{NP}$-complete whenever $H$ contains a connected component with more than two vertices [24] and is in $\mathsf{P}$ otherwise.

4.1 Clique Packing

We prove Theorem 1.3, that $K_{d}$-Matching for $d\geq 3$ does not have kernels with at most $O(k^{d-1-\varepsilon})$ edges unless $\mathsf{coNP}\subseteq\mathsf{NP/poly}$. For this, we devise a parameter-preserving reduction from the problem of finding a perfect matching in a $(d-1)$-partite $(d-1)$-uniform hypergraph.

Lemma 4.1**.**

*For all $d\geq 4$, there is a polynomial-time mapping reduction from Perfect $(d-1)$-Dimensional Matching to $K_{d}$-Matching that does not change the parameter $k$. *

Proof*.*

Let $G$ be a $(d-1)$-partite $(d-1)$-uniform hypergraph on $n$ vertices. For each edge $e$ of $G$, we add a new vertex $v_{e}$ and transform $e\cup\{v_{e}\}$ into a $d$-clique in $G^{\prime}$. We claim that $G$ has a matching of size $k\coloneqq n/(d-1)$ if and only if $G^{\prime}$ has a $K_{d}$-matching of size $k$. The completeness is clear since any given matching of $G$ can be turned into a $K_{d}$-matching of $G^{\prime}$ by taking the respective $d$-clique for every $(d-1)$-hyperedge. For the soundness, let $G^{\prime}$ contain a $K_{d}$-matching of size $k$. Note that any $d$-clique of $G^{\prime}$ uses exactly one vertex $v_{e}$ since the underlying graph of $G$ does not contain any $d$-cliques and since no two $v_{e}$’s are adjacent. Thus every $d$-clique of $G^{\prime}$ is of the form $e\cup\{v_{e}\}$, which gives rise to a matching of $G$ of size $k$. ■

This combined with Lemma 2.1 and Lemma 3.2 implies Theorem 1.3 for $d\geq 4$. The case $d=3$ follows from Theorem 1.4, which we establish independently in the following.

4.2 General Graph Matching Problems

We prove Theorem 1.4, that $H$-Factor does not have kernels of size $O(k^{2-\varepsilon})$ unless $\mathsf{coNP}\subseteq\mathsf{NP/poly}$, whenever $H$ is a connected graph with at least three vertices.

We use the coordination gadget of Lemma 3.1 in a reduction from a suitable $\operatorname{OR}$-problem to $H$-Matching. To do so, we translate the coordination gadget for Perfect $d$-Dimensional Matching to $H$-Factor, which we achieve by replacing hyperedges with the following hyperedge-gadgets of [24].

Lemma 4.2**.**

*Let $H$ be a connected graph on $d\geq 3$ vertices. There is a graph $e=e(v_{1},\dots,v_{d})$ that contains $\{v_{1},\dots,v_{d}\}$ as an independent set such that, for all $S\subseteq\{v_{1},\dots,v_{d}\}$, the graph $e-S$ has an $H$-factor if and only if $|S|=0$ or $|S|=d$. *

Proof*.*

Let $v$ be a vertex of $H$. We construct $e$ as in Figure 2. We start with one central copy of $H$. For each vertex $u\in[d]=V(H)$, we create a new copy $H_{u}$ of $H$ and denote its copy of $v$ by $v_{u}$. Finally, we add an edge between $u\in H$ and $w\in(H_{u}-v_{u})$ if $v_{u}w$ is an edge of $H_{u}$.

For the claim, assume that $0<|S|<d$. Then $|V(e-S)|$ is not an integer multiple of $d=|V(H)|$ and there can be no $H$-factor in $e-S$. For the other direction, assume that ${|S|=0}$. Then the subgraphs $H_{u}$ for $u\in[d]$ and $H$ are $d+1$ pairwise disjoint copies of $H$ in $e$ and form an $H$-factor of $e$. In the case $|S|=d$, we observe that the $d$ subgraphs ${(H_{u}-v_{u})\cup\{u\}}$ form an $H$-factor of $e-S=e-\{v_{1},\dots,v_{d}\}$. ■

For the proof of the $H$-Matching kernel lower bounds, we use the Packing Lemma. Recall that a set $E$ of edges in a $d$-uniform hypergraph is a clique on $p$ vertices if there is a set $S$ of $p$ vertices such that $E$ contains exactly the $\binom{p}{d}$ size-$d$ subsets of $S$.

Lemma 4.3** ([10]).**

For all integers $p\geq d\geq 2$ and $t>0$ there is a $p$-partite $d$-uniform hypergraph $P$ on O\big{(}p\cdot\max(p,t^{1/d+o(1)})\big{)} vertices such that

1. (i)

the hyperedges of $P$ are partitioned into $t$ cliques $K_{1},\dots,K_{t}$ on $p$ vertices each, and 2. (ii)

$P$* contains no cliques on $p$ vertices other than the $K_{i}$’s.*

*Furthermore, for any fixed $d$, the hypergraph $P$ and the $K_{i}$’s can be constructed in time polynomial in $p$ and $t$. *

The chromatic number $\chi(H)$ is the minimum number of colors required in a proper vertex-coloring of $H$. The proof of [24] shows that $H$-Factor is $\mathsf{NP}$-complete even in case we are looking for an $H$-factor in $\chi(H)$-partite graphs. We are going to make use of that in the following reduction.

Lemma 4.4**.**

*There is a polynomial-time mapping reduction from \operatorname{OR}(\textsc{H-Factor}) to $H$-Factor that maps $t$-tuples of instances of size $s$ each to instances that have at most $\sqrt{t}^{1+o(1)}\cdot\operatorname{poly}(s)$ vertices. *

Proof*.*

Let $p=\chi(H)$ be the chromatic number of $H$. For an instance $G_{1},\dots,G_{t}$ of \operatorname{OR}(\textsc{H-Factor}), we can assume w.l.o.g. that the $G_{i}$ are $p$-partite graphs with $n$ vertices in each part. We construct a graph $G$ that has an $H$-factor if and only if some $G_{i}$ has an $H$-factor. For this, we invoke the Packing Lemma, Lemma 4.3, with $d=2$, and we obtain a $p$-partite graph $P$ that contains $t$ cliques $K_{1},\dots,K_{t}$ on $p$ vertices each. We identify the vertex set of $G_{i}$ with $V(K_{i})\times[n]$ injectively in such a way that vertices in the same color class have the same first coordinate. We define an intermediate $p$-partite graph $G^{\prime}$ on the vertex set $V(P)\times[n]$ as $G^{\prime}=G_{1}\cup\dots\cup G_{t}$. To obtain $G$ from $G^{\prime}$, we add $p$ coordination gadgets of Lemma 3.1 with $m=\sqrt{t}^{1+o(1)}$ and $d=p$. For each color class $C\subset V(G^{\prime})$, we add a coordination gadget where the $U_{i}\subset C$ are those vertices that project to the same vertex in $P$. Finally, we replace each $p$-hyperedge by the gadget in Lemma 4.2, which finishes the construction of $G$.

For the completeness of the reduction, assume $G_{i}$ has an $H$-factor $M$. To construct an $H$-factor of $G$, we start by using $M$ to cover the vertices $V(G_{i})$ in $G$. The completeness of the coordination gadgets guarantees that we find a perfect matching in the $d$-uniform hypergraph $G^{\prime}-V(G_{i})$ that uses only hyperedges of the coordination gadgets. By Lemma 4.2, this gives rise to an $H$-factor of $G$.

For the soundness, assume we have an $H$-factor $M$ of $G$. Lemma 4.2 guarantees that the edge gadgets can be seen as $p$-hyperedges in the intermediate graph $G^{\prime}$. Soundness of the coordination gadgets guarantees that $M$ leaves exactly one group free per part. Now let $H^{\prime}$ be a copy of $H$ that is contained in $G$ but not in any of the gadgets. Since $H^{\prime}$ has chromatic number $p$, $H^{\prime}$ intersects all $p$ parts and has an edge between any two distinct parts. By construction of $G$, this implies that the projection of $H$ onto $P$ is a clique. By the packing lemma, this clique is one of the $K_{i}$’s. Therefore, each $H^{\prime}$ of the $H$-factor $M$ that is not in one of the gadgets is contained in $G_{i}$, which implies that $G_{i}$ has an $H$-factor.

The claim follows since $G$ is a graph on $\sqrt{t}^{1+o(1)}\operatorname{poly}(s)$ vertices that has an $H$-factor if and only if some $G_{i}$ has an $H$-factor. ■

Now Lemma 2.1 immediately implies Theorem 1.4, our kernel lower bounds for $H$-Factor.

5 Multiparameter Kernelization

The kernelization complexities of $d$-Set Matching and $d$-Clique Matching appear to be significantly different from that of $P_{d}$-Matching. To make this observation formal, we consider multiparameter problems: Let $\Pi$ be a problem that has a primary parameter $s$ and a secondary parameter $d$. Here, $s$ should be thought of as the solution size – for packing problems, $s=kd$ is the number of vertices in the solution.

We want to classify the kernelization complexity of $\Pi$ further, so we assume that $\Pi$ is fixed-parameter tractable with respect to the solution size $s$, that is, it has an algorithm running in time $f(s)\operatorname{poly}(n)$. Here, $\operatorname{poly}(n)$ means $C\cdot n^{C}$ for some fixed constant $C$, which is independent from $d$. We classify the running time of a kernelization algorithm $A$ for $\Pi$ into the following three classes:

1. (A)

$A$ runs in time $\operatorname{poly}(n)$. 2. (B)

$A$ runs in time $f(d)\operatorname{poly}(n)$ for some computable non-decreasing function $f$. 3. (C)

$A$ runs in time $O(n^{f(d)})$ for some computable non-decreasing function $f$.

Moreover, we distinguish the following asymptotic kernel sizes that $A$ may produce:

1. (1)

$\operatorname{poly}(s)$ 2. (2)

$g(d)\operatorname{poly}(s)$ for some computable non-decreasing function $g$ 3. (3)

$O(s^{g(d)})$ for some computable non-decreasing function $g$

A priori, this gives us nine different possible kernelization complexities for a multiparameter problem, where A1 is the best type and C3 is the worst.

For example, $d$-Set Matching has kernels of size $O(d!k^{d})$ that can be computed in time $\operatorname{poly}(n)$, so it is of type A3. The running time is so fast because we can find sunflowers in $d$-uniform hypergraphs in linear time. Moreover, our lower bound from Theorem 1.2 shows that the problem is unlikely to have type C2 or better. This completely classifies the multiparameter kernelization complexity of $d$-Set Matching (see Figure 3).

As another example, $d$-Clique Matching has kernels of size $O(d!k^{d})$ that can be computed in time $O(n^{O(d)})$, which is a kernel of type $C3$. For this problem, we cannot find sunflowers quickly since finding even one $d$-clique is hard: Assume there was a B3-kernelization for $d$-Clique Matching. Then this algorithm works in particular for $k=1$, in which case it runs in time $f(d)\operatorname{poly}(n)$ and produces and output of size $O(s^{g(d)})=O(d^{g(d)})$. On this kernel, we can run any brute force algorithm for finding a clique; overall, this gives an $\mathsf{FPT}$-algorithm for the $d$-Clique problem, which implies $\mathsf{FPT}=\mathsf{W}[1]$.

In Section 6.2, we explore the multiparameter kernelization complexity of the $P_{d}$-Matching problem. We will find it useful to apply the following standard trick, which can turn any B2-kernelization into one of type A2 and one of type B1.

Lemma 5.1**.**

*Any kernelization algorithm of type B2 gives rise to kernelization algorithms of type A2 and B1. *

In particular, a problem has kernels of type A2 if and only if it has kernels of type B1.

Proof*.*

Let $A$ be a B2-type kernelization algorithm. We construct a B1-type kernelization $B$ as follows: If $g(d)<k$, then we run $A$, which outputs an instance of size $\operatorname{poly}(k)$. Otherwise, $g(d)\geq k$. Since $\Pi$ is FPT with respect to $k$, we can solve it in time $h(k)\operatorname{poly}(n)\leq h(g(d))\operatorname{poly}(n)$ which reduces the kernel size to a constant. Since $h$ and $g$ are computable, $B$ is of type B1. We construct an A2-type kernelization $C$ as follows: If $f(d)<n$, then we run $A$, which takes time $\operatorname{poly}(n)$. Otherwise, $f(d)\geq n$, which means that the instance is already sufficiently kernelized. ■

6 Kernels for Graph Packing Problems

The sunflower kernelization in Theorem 1.1 immediately transfers to $H$-Matching for any fixed graph $H$ and yields kernels with $O(k^{d})$ edges. For every graph $H$, [31] shows that $H$-Matching has kernels with $O(k^{d-1})$ vertices where $d=|V(H)|$, but this gives only the weaker bound $O(k^{2d-2})$ on the number of edges. Here we show that for some specific $H$, we can obtain kernels that are better than the $O(k^{d})$ bound implied by Theorem 1.1. As a very simple example, we show this first for $K_{1,d}$-Matching, the problem of packing vertex-disjoint stars with $d$ leaves.

Proposition 6.1**.**

$K_{1,d}$-Matching* has kernels with $O(k^{2})$ edges. *

Proof*.*

Let $(G,k)$ be an instance of $K_{1,d}$-Matching If $G$ has a vertex $v$ of degree at least $dk+1$, let $e$ be an edge incident to $v$. We claim that we can safely remove $e$. If $G-e$ has a $K_{1,d}$-matching of size $k$, then this also holds for $G$. For the other direction, let $M$ be a $K_{1,d}$-matching of size $k$ in $G$. If $M$ does not contain $e$, it is also a matching of $G-e$. Otherwise $M$ contains $e$. Let $M^{\prime}$ be obtained from $M$ by removing the star that contains $e$. Now $v$ is not contained in $M^{\prime}$. Since $M^{\prime}$ covers at most $d(k-1)$ vertices, at least $d+1$ neighbors of $v$ are not contained in $M^{\prime}$. Even if we remove $e$, we can therefore augment $M^{\prime}$ with a vertex-disjoint star that is centered at $v$ and has $d$ leaves. This yields a star matching of size $k$ in $G-e$.

For the kernelization, we repeatedly delete edges incident to high-degree vertices. Then every vertex has degree at most $dk$. We further remove any vertex or edge that not part of a $K_{1,d}$. Now we greedily compute a maximal star matching $M$ and answer ’yes’ if $M$ has size $k$. Otherwise, we claim that the graph has most $O(k^{2})$ edges. Since $M$ covers at most $dk$ vertices, the degree bound implies that at most $(dk)^{2}$ edges are incident to $M$. To count the edges outside $M$, observe that for every such edge $e$, at least one endpoint is adjacent to $M$: otherwise, we know that $e$ is part of a $K_{1,d}$ (since we haven’t removed $e$) and this $K_{1,d}$ would be disjoint from $M$. Each vertex of $G$ outside of $M$ have at most $d-1$ neighbors outside of $M$ because they would otherwise have been added to $M$. Thus there are at most $(d-1)\cdot(dk)^{2}$ edges not incident to $M$ and so $G$ has at most $d^{3}\cdot k^{2}$ edges. ■

By Theorem 1.4, it is unlikely that star matching problems have kernels with $O(k^{2-\varepsilon})$ edges, so the above kernels are likely to be asymptotically optimal.

6.1 Packing Paths of Length 3

Let $P_{d}$ be the simple path with $d$ edges. As $P_{2}$ is the same as $K_{1,2}$, the problem $P_{2}$-Matching is already covered by Proposition 6.1, thus we have a $O(k^{2})$ upper bound and a matching $O(k^{2-\varepsilon})$ lower bound for this problem. For $P_{3}$-Matching, the situation is less clear. Using a similar strategy as in the proof of Proposition 6.1, it is easy to reduce the maximum degree to $O(k^{2})$ and then argue that the kernel has $O(k^{3})$ edges. Surprisingly, the maximum degree can be further reduced to $O(k^{1.5})$ using much more complicated combinatorial arguments. This gives rise to kernels of size $O(k^{2.5})$ without a tight lower bound.

Theorem 6.2**.**

$P_{3}$-Matching* has kernels with $O(k^{2.5})$ edges. *

We prove Theorem 6.2 by showing that the maximum degree $\Delta$ of the graph can be reduced to $O(k^{1.5})$. Once we have an instance $G$ with maximum degree $\Delta$, we can obtain a kernel of size $O(\Delta\cdot k)$ with fairly standard arguments as follows. First, we greedily compute a maximal $P_{3}$-matching. If we find at least $k$ paths, then we are done. Otherwise let $S$ be the set of at most $4k$ vertices in the paths. As every vertex has degree at most $\Delta$, there are at most $4k\Delta$ edges incident to $S$. Now let us count the number of edges in $G\setminus S$. The graph $G\setminus S$ does not contain paths of length $3$, so every connected component of $G\setminus S$ is either a triangle or a star. Therefore, the average degree is at most $2$ in $G\setminus S$. If a component of $G\setminus S$ is not adjacent to $S$, it can be safely removed without changing the solution. If a component of $G\setminus S$ has a vertex $v$ with at least two neighbors in $G\setminus S$ that have degree one in $G$, then we keep only one of them. Since every solution uses at most one of them, they are interchangeable. After doing this, every component of $G\setminus S$ has at most two vertices not adjacent to $S$ in $G$. This means that a constant fraction of the vertices in $G\setminus S$ is adjacent to $S$. As there are at most $4\Delta k$ edges incident to $S$, this means that there are at most $O(\Delta k)$ vertices in $G\setminus S$. Taking into account that the average degree is at most two in $G\setminus S$, we see that there are at most $O(\Delta\cdot k)$ edges in $G\setminus S$. This yields kernels with $O(k^{2.5})$ edges. It remains to argue how to reduce the maximum degree to $\Delta$.

Degree reduction. Let $G$ be a graph that contains a vertex $v$ with more than $\Delta$ neighbors. In the following, we call any $P_{3}$-matching of size $k$ a solution. Our kernelization procedure will find an edge $e$ incident to $v$ that can be safely removed, so that $G$ has a solution if and only $G\setminus e$ has a solution. The most basic such reduction is as follows.

Lemma 6.3**.**

*If there there is a matching $a_{1}b_{1}$, $\dots$, $a_{n}b_{n}$ of size $n\geq 4k+2$ in $G\setminus v$ such that every $a_{i}$ is a neighbor of $v$, then any single edge $e$ incident to $v$ can be safely removed. *

Proof*.*

Suppose that there is a solution containing a path going through $e$. The paths in the solution cover $4k$ vertices, thus without loss of generality, we can assume that $a_{1}$, $b_{1}$, $a_{2}$, $b_{2}$ are not used. We replace the path containing $e$ with the path $b_{1}a_{1}va_{2}$ to obtain a solution of $G\setminus e$. ■

Let us greedily find a maximal matching $a_{1}b_{1},\dots,a_{n}b_{n}$ in $G\setminus v$ with the requirement that every $a_{i}$ is a neighbor of $v$. If $n\geq 4k+2$, we can safely remove an arbitrary edge incident to $v$ by Lemma 6.3 and then proceed inductively. Otherwise, let $M=\{a_{1},b_{1},\dots,a_{n},b_{n}\}$ be the set of at most $8k+2$ vertices that are covered by this matching. Let $X\coloneqq N(v)\setminus M$. Now every neighbor $y$ of a vertex $x\in X$ is in $M\cup\{v\}$ since the matching $M$ could otherwise have been extended by the edge $xy$. In particular, $X$ induces an independent set. It holds that $|X|\geq 100k$ since otherwise the degree of $v$ is smaller than $\Delta$.

The following technical definition is crucial in our kernelization algorithm.

Definition 6.4**.**

*Let $u$ be a vertex of $M$ and let $X_{u}=N(u)\cap X$ be the neighborhood of $u$ in $X$. We call $u$ good if every set $S\subseteq M$ satisfies the following property: If there is a matching between $S$ and $X_{u}$ of size $|X_{u}|-1$, then $S$ has more than $4k$ neighbors in $X$. *

It is not obvious how to decide in polynomial time whether a vertex is good. Nevertheless, if certain vertices of $M$ are known to be good, we can make progress by deleting an edge.

Lemma 6.5**.**

*If $x\in X$ has only good neighbors in $M$, then the edge $vx$ can be safely removed. *

Proof*.*

We argue that if there is a solution then there is also a solution that does not use $vx$. If $vx$ is used as the first or the third edge of a path, the high degree of $v$ makes sure that there is a neighbor $y$ of $v$ not used by the solution, and we can replace $vx$ by $vy$. Now consider a solution that contains a path $P=avxu$ using $vx$ as its middle edge; by assumption, $u\in M$ is good.

By definition, the set $X_{u}$ contains all vertices $x^{\prime}$ of $X$ that are common neighbors of $u$ and $v$. Hence, if some vertex $x^{\prime}\in X_{u}\setminus x$ is not used by the solution, then we can replace $P$ by $avx^{\prime}u$. Now assume that every $x^{\prime}\in X_{u}\setminus x$ is part of some path. None of these paths contain $v$. If $x^{\prime}$ is the endpoint of a path, then the mate of $x^{\prime}$ is its unique neighbor in the path; if $x^{\prime}$ is in the middle of a path, then the mate of $x^{\prime}$ is the endpoint that is adjacent to $x^{\prime}$ in the path. Recall that every neighbor of $x^{\prime}\in X$ is in $M\cup\{v\}$, so the mate of any $x^{\prime}\in X_{u}\setminus x$ is contained in $M$. The vertices in $X_{u}\setminus x$ have distinct mates even if two vertices of $X_{u}\setminus x$ are on the same path. This gives rise to a matching between $X_{u}\setminus x$ and the set $S\subseteq M$ of all mates of vertices in $X_{u}\setminus x$. Since this matching has size $|X_{u}|-1$ and $u$ is good, $S$ has at least $4k+1$ neighbors in $X$. Thus, some neighbor $y\in X$ of $S$ is not used by the solution.

Let $x^{\prime}\in X_{u}\setminus x$ be a vertex whose mate $w\in S$ is adjacent to a vertex $y\in X$ that is not used by the solution. Since $w$ is the mate of $x^{\prime}$, the edge $wx^{\prime}$ occurs in a path $Q$ of the solution. We distinguish two cases. If $x^{\prime}$ is an endpoint of $Q$, then we replace the paths $P=avxu$ and $Q=x^{\prime}wcd$ by the two new paths $avx^{\prime}u$ and $ywcd$. If $x^{\prime}$ is not an endpoint of $Q$, then we replace $P=avxu$ and $Q=wx^{\prime}cd$ by $ux^{\prime}cd$ and $avyw$. These are paths since $x^{\prime}$ is a common neighbor of $v$ and $u$, and $y$ is a common neighbor of $v$ and $w$. In all cases we found solutions that do not use $vx$, so $vx$ can be safely removed. ■

Next we show that, if $v$ has sufficiently large degree, then we can find a vertex $x\in X$ for which the the reduction rule in Lemma 6.5 is applicable.

Lemma 6.6**.**

*There is a polynomial-time algorithm that, given a vertex $v$ of degree larger than $\Delta=C\cdot k^{1.5}$ for some universal constant $C$, finds a vertex $x\in X$ that has only good neighbors in $M$. *

Proof*.*

We maintain an increasing set $M^{\prime}\subseteq M$ of vertices satisfying the invariant that all vertices in $M^{\prime}$ are good. Initially we set $M^{\prime}=\emptyset$. We repeat a procedure that either outputs $x$ as required or adds a new good vertex to $M^{\prime}$. If some $x\in X$ does not have neighbors in $M\setminus M^{\prime}$, then by the invariant all neighbors of $x$ in $M$ are good and we can output $x$. Otherwise, with $M\setminus M^{\prime}=\{m_{1},\dots,m_{t}\}$, we can define a partition $X^{1},\dots,X^{t}$ of $X$ such that every vertex of $X^{i}$ is adjacent to $m_{i}$. Some of the $X^{i}$ can be empty.

We construct a bipartite graph $H$ that is a subgraph of the bipartite graph between $X$ and $M$. Initially, $H$ has the vertex set $X\cup M$ and no edges. We preserve the invariant that every vertex of $X$ has degree at most one in $H$.

For every $1\leq i\leq t$ with $|X^{i}|>1$, we add edges to $H$ in the following way. For every edge $xy$ of $G$ with $x\in X^{i}$ and $y\in M$, let the weight of $xy$ be the degree $\deg_{H}(y)$ of $y$ currently in $H$. In this weighted graph $G$, we now compute a matching between $X^{i}$ and $M$ that has cardinality exactly $|X^{i}|-1$ and weight at most $4k$. This can be done in polynomial time using standard algorithms. If there is such a matching, we add all edges of the matching to $H$ and continue with the next $i$. This preserves the invariant that every vertex of $X$ has degree at most one in $H$ since the sets $X^{i}$ are disjoint. If there is no such matching, then we claim that $m_{i}$ is good. Assume for contradiction that there is a matching of cardinality $|X_{m_{i}}|-1$ between $X_{m_{i}}=N(m_{i})\cap X$ and a subset $S\subseteq M$ that has at most $4k$ neighbors in $X$. Note that this matching matches at least $|X^{i}|-1$ elements of $X^{i}$ to vertices in $S$. As $H$ is a subgraph of $G$, it follows that $S$ has at most $4k$ neighbors in $H$. This implies that $\sum_{y\in S}\deg_{H}(y)\leq 4k$ since every vertex of $X$ has degree at most one in $H$, so the sum of the degrees of vertices in $S$ is exactly the size of the neighborhood of $S$ in $H$. This contradicts with the fact that we did not find a suitable matching of weight at most $4k$. Thus $m_{i}$ is good and can be added to $M^{\prime}$.

We show that unless $|X|=O(k^{1.5})$, the above process finds a good vertex in $M$. Suppose that the process terminates without finding a good vertex. Let $N$ be the number of paths of length two in the final graph $H$ we obtained. As the degree of every vertex of $X$ is at most one in $H$, every path of length two is of the form $abc$ with $a\in X^{i}$, $b\in M$, and $c\in X^{j}$ for some $1\leq i,j\leq t$. Furthermore, we have $i\neq j$: the edges incident to $X^{i}$ form a matching in $H$. For some $i$, let us count the number of paths with $a\in X^{i}$ and $c\in X^{j}$ for $j<i$. Consider a vertex $a\in X^{i}$ that is not isolated in $H$; it has a unique neighbor $b$ in the graph $H$. Consider the graph $H^{\prime}$ at the step of the algorithm before finding the matching incident to $X^{i}$, and let $d$ be the degree of $b$ in $H^{\prime}$. Then it is clear that $H$ contains exactly $d$ paths of length two connecting $a$ to a vertex of $X^{j}$ with $j<i$: the vertex $b$ has exactly $d$ neighbors in $X^{1}\cup\dots\cup X^{i-1}$. Thus if $S_{i}$ is the set of vertices that $X^{i}$ is matched to, then the total number of paths between $X^{i}$ and $\bigcup_{j=1}^{i-1}X^{j}$ is exactly the total degree of $S_{i}$ in $H^{\prime}$, which is at most $4k$ by the selection of the matching. Thus the total number $N$ of paths can be bounded by $t\cdot 4k\leq(8k+2)\cdot 4k=O(k^{2})$.

On the other hand, the number of paths of length two containing $m\in M$ as their middle vertex is exactly

[TABLE]

Note that $\sum_{m\in M}\deg_{H}(m)\geq|X|-|M|$: in every nonempty $X^{i}$, there is exactly one vertex that is isolated in $H$, and every other vertex has degree one. Thus the total number of paths is exactly

[TABLE]

where we used the relationship between arithmetic and quadratic mean in the second inequality, and the facts $|M|\leq 8k+2$, $|X|>100k$ in the last step. Putting together the upper bound $N=O(k^{2})$ obtained earlier on the number of path of length 2 in $H$ and the lower bound $N=\Omega(|X|^{2}/k)$ we have just proved, it follows that $|X|=O(k^{1.5})$.

Thus, we can choose $\Delta=C\cdot k^{1.5}$ for some large enough constant $C>0$ so that the above procedure is guaranteed to find a vertex $x\in X$ that contains only good neighbors in $M$. ■

6.2 Packing Paths of Length $d$

In this section, we study the kernelization of $P_{d}$-Matching which is given an instance $(G,k)$ to decide whether there are at least $k$ vertex-disjoint paths with $d$ edges each. For $d=1$, this is equal to the problem of finding a standard matching of size at least $k$ and therefore computable in polynomial time. The results of [24] imply that the problem is $\mathsf{NP}$-complete for any constant $d\geq 2$. Theorem 1.1 implies that the problem has kernels of size $O(k^{d})$ for every constant $d$. Furthermore, we know kernels of size $O(k^{2})$ for $d=2$ (Proposition 6.1) and $O(k^{2.5})$ for $d=3$ (Theorem 1.5). The best lower bound we have is $O(k^{2-\varepsilon})$ for every $d\geq 2$. Surprisingly, we prove that $P_{d}$-Matching has kernels whose size is bounded by a polynomial whose degree is independent from $d$. We first state a result about the existence of an annotated kernel of type B2 (in the notation of Section 5) for $P_{d}$-Matching. With some additional arguments, it will give a proof of Theorem 1.6.

Theorem 6.7**.**

*For every $d\in\mathbb{N}$, $P_{d}$-Matching has annotated kernels with O\big{\lparen}d^{d^{2}}d^{7}k^{3}\big{\rparen} vertices. The kernelization algorithm runs in time $\operatorname{poly}(d^{d^{2}}n)$. *

Proof*.*

If $d<2$, the problem can be computed in polynomial time, so let $d\geq 2$.

We describe the kernelization algorithm A step by step, interleaved with a discussion. The algorithm is not quite a kernelization algorithm for $P_{d}$-Matching, but it is one for the following weighted version of the problem: The input is a simple graph $G$ with possible self-loops and weights $w_{e}\in[d]$ on the edges, and a number $k$. We call a self-loop $\{v\}$ a dangling edge as this makes more sense in the context of paths: We allow paths $e_{1},\dots,e_{\ell}$ to start and end with dangling edges, but all other edges have to be regular edges; in the degenerate case that the path involves only one vertex, its dangling edge can be used only once. The goal of the weighted $P_{d}$-Matching problem is to find $k$ vertex-disjoint paths such that the weight of each path is at least $d$. The weight of a path $e_{1},\dots,e_{\ell}$ is the sum $\sum_{i\in[\ell]}w_{e_{i}}$ of its edge weights. $P_{d}$-Matching is the restriction of this problem to graphs without dangling edges and with weight $1$ on every edge.

Let $(G,k)$ be the input for the algorithm.

1. (A1)

Greedily compute a maximal set of disjoint paths in $G$, each of which has length at most $d$ and weight at least $d$. If the path matching contains at least $k$ paths, we have found a solution and are done with the kernelization. Otherwise, let $M\subseteq V(G)$ be the set of vertices used by the paths. We have $|M|\leq(d+1)(k-1)$, and the graph $G^{\prime}\coloneqq G-M$ does not contain any path of weight $\geq d$.

We can find a path of weight $\geq d$ deterministically in time \exp\big{\lparen}O(d)\big{\rparen}\operatorname{poly}(n), so (A1) runs in polynomial time. Let $G^{\prime}_{1},\dots,G^{\prime}_{t}$ be a list of all connected components of $G^{\prime}$, and select arbitrary vertices $r_{i}\in V(G^{\prime}_{i})$ for each $i\in[t]$. We call these vertices roots.

1. (A2)

For each $i\in[t]$, compute a depth-first search tree $T_{i}$ in $G^{\prime}_{i}$ starting at the root $r_{i}$. Let $F\coloneqq\dot{\bigcup}_{i\in[t]}T_{i}$ be the corresponding DFS-forest.

We have $V(F)=V(G^{\prime})$. The depth of each tree in $F$ is at most $d-1$ as otherwise $M$ would not have been maximal. For every $v\in V(F)$, we let $T_{v}$ be the subtree that consists of $v$ and all of its successors in $F$. Let $u,v\in V(F)$ so that neither $u$ is an ancestor of $v$ nor vice-versa. Then $V(T_{u})$ and $V(T_{v})$ are disjoint; moreover, if $u$ and $v$ are in the same component of $G^{\prime}$, then every path in $G^{\prime}$ from $V(T_{u})$ to $V(T_{v})$ leads through a common ancestor of $u$ and $v$.

A request is a tuple $(f,i)$ where $f\subseteq V(G)$ with $\lvert f\rvert\in\{1,2\}$ prescribes one or two vertices of $G$, and $i\in[d]$ is a weight. For a set $S\subseteq V(G)$, we let $\operatorname{Paths}^{S}(f,i)$ be the set of all paths in $G[S\cup f]$ of weight $\geq i$ such that: If $f=\{x,y\}$ for $x\neq y$, then the endpoints of the path are $x$ and $y$, and if $f=\{x\}$, then the path starts at $x$. We say that $S$ satisfies the request $(f,i)$ if $\operatorname{Paths}^{S}(f,i)\neq\emptyset$. Note that $f$ is an edge of $G$ with $w_{f}\geq i$ if and only if the empty set (and hence every set $S$) satisfies $(f,i)$; in this case, we say that the request $(f,i)$ is resolved.

The idea of the kernelization algorithm is to resolve as many requests as we can possibly afford, meaning that we want to increase the weight of edges in $G$ as much as possible. Doing so can never destroy existing solutions for the instance $(G,k)$, but we need to carefully avoid introducing solutions in case $(G,k)$ is a no-instance.

We begin by resolving requests $(f,i)$ with $f\subseteq M$. We let $N_{f,i}$ be the set of all vertices $v\in V(F)$ such that $V(T_{v})$ satisfies the request $(f,i)$. If $u$ is an ancestor of $v$ in $T$, then $V(T_{u})\supseteq V(T_{v})$, so all requests satisfied by a tree $T_{v}$ are also satisfied by the trees $T_{u}$ of its ancestors. Hence $F[N_{f,i}]$ is a subforest of $F$ such that, for all $j\in[t]$, either $V(T_{j})$ is disjoint from $N_{f,i}$ or the root $r_{j}$ of $T_{j}$ is contained in $N_{f,i}$. In a rooted tree, a leaf is a vertex that does not have any children; in particular, the root is a leaf if and only if it is the only node.

1. (A3)

For each unresolved request $(f,i)$ with $f\subseteq M$:

If $F[N_{f,i}]$ has more than $dk$ leaves, we set $w_{f}\coloneqq i$.

Here we use the convention that $w_{f}=0$ if and only if $f$ is not an edge, and so if $f$ was not an edge before, we add it and set its weight to $i$.

To see that (A3) is safe, let $(f,i)$ be an unresolved request such that $F[N_{f,i}]$ has more than $dk$ leaves. Let $G$ be the graph before changing the weight of $w_{f}$, and let $G^{+}$ be the graph with the new weight $w^{\prime}_{f}=i$. Since $(f,i)$ is unresolved in $G$, we have ${w^{\prime}_{f}>w_{f}}$. We need to show that $G$ has $k$ disjoint paths of weight $\geq d$ if and only if $G^{+}$ does. The only if direction is trivial since we only increase weights. For the if direction, let $P_{1},\dots,P_{k}$ be disjoint paths of weight $\geq d$ in $G^{+}$. If none of the paths use $f$, the path matching also exists in $G$. Otherwise, suppose without loss of generality that $f$ appears in $P_{1}$. The set $P=V(P_{1})\cup\dots\cup V(P_{k})$ has size at most $dk$. Moreover, the sets $V(T_{v})$ are mutually disjoint for all leaves $v$ of $F[N_{f,i}]$ since $F$ is a forest. Hence the intersection of $P$ and $V(T_{v})$ is empty for at least one leaf $v$ of $F[N_{f,i}]$. Since $v\in N_{f,i}$, the set $V(T_{v})$ satisfies the request $(f,i)$. Hence we can replace $f$ in $P_{1}$ with a path in $G$ from $\operatorname{Paths}^{V(T_{v})}(f,i)$, and we obtain a set of $k$ disjoint paths of weight $\geq d$ in the graph $G$.

After (A3) has been applied, every request $(f,i)$ that is still unresolved has a corresponding forest $F[N_{f,i}]$ with at most $dk$ leaves. The number of vertices of the forest $F[N_{f,i}]$ is at most the number of its leaves times its depth plus 1. Since the forest $F$ does not contain a path of length $d$, the depth of each tree is at most $d-1$, and the total number of vertices in $F[N_{f,i}]$ is at most $d^{2}k$. Let $N^{\prime}$ be the union of all $N_{f,i}$ for unresolved requests $(f,i)$ with $f\subseteq M$. That is, $N^{\prime}$ is the set of all vertices $v\in V(F)$ such that $T_{v}$ satisfies an unresolved request $(f,i)$ over $M$. There are at most $\lvert M\rvert^{2}\cdot d\leq d^{3}k^{2}$ requests over $M$, and $N_{f,i}$ has size at most $d^{2}k$ for each of them, hence the size of $N^{\prime}$ is at most $d^{5}k^{3}$. The algorithm keeps all vertices from $M\cup N^{\prime}$ in the kernel, so it remains to select $\operatorname{poly}(dk)$ vertices from the graph $G^{\prime\prime}\coloneqq G^{\prime}-N^{\prime}$.

Let $C\subseteq V(G^{\prime\prime})$ be any connected component of $G^{\prime\prime}$. We claim that $C$ satisfies the following properties:

$C$ does not satisfy any unresolved request over $M$. 2. 2.

$|N(C)\cap N^{\prime}|\leq d-1$.

For these claims, first note that $C\subseteq V(F)$ and that $G[C]$ is connected. It is easy to see that $C=V(T_{v})$ for some vertex $v\in C$. Indeed, let $v$ be a vertex of $C$ whose depth in the DFS forest is minimum possible. The fact that $v\in C$ implies that $v\not\in N^{\prime}$, and it follows from the definition of $N^{\prime}$ that $T_{v}$ is also disjoint from $N^{\prime}$. Every neighbor of $T_{v}$ in $G^{\prime}$ is an ancestor $v$, and the ancestors of $v$ are not in $C$ by the minimal choice of $v$. Thus $C$ is exactly $V(T_{v})$. To see the first claim, recall that the definition of $v\not\in N^{\prime}$ is that $V(T_{v})$ does not satisfy any unresolved request $(f,i)$ over $M$.

For the second claim, since $F$ is a DFS-forest, the only $G^{\prime}$-neighbors that $V[T_{v}]$ can have lie on the unique path in $F$ that leads from a root to $v$. In particular, since ${N^{\prime}\subseteq V(F)}$, all neighbors of $V(T_{v})$ that are contained in $N^{\prime}$ must lie on this root-to-$v$ path. Finally, any root-to-$v$ path has at most $d$ vertices including $v$, which implies that ${N(C)\cap N^{\prime}}$ has size at most $d-1$.

The neighborhood of each component $C$ is in $M\cup N^{\prime}$. In the rest of the proof, we analyze how a component $C$ can satisfy requests $(f,i)$ with $f\subseteq M\cup N^{\prime}$ but $f\cap N^{\prime}\neq\emptyset$. Let us give an intuitive reason why we consider only $f\cap N^{\prime}\neq\emptyset$, that is, ignore requests $(f,i)$ with $f\subseteq M$. A solution to the generalized $P_{d}$-matching instance $(G,k)$ can use vertices from $C$ in some number of segments of the paths. If such a segment is a path from $\operatorname{Paths}^{C}(f,i)$ for $f\subseteq M$, then this segment must correspond to a resolved request $(f,i)$ since $C$ does not satisfy any unresolved requests over $M$. Since the request is resolved, we can replace this segment through $C$ with the edge $f$ of weight $\geq i$. Thus as we shall see, it can be assumed by a minimality argument that each path segment that the solution uses in $C$ enters through a vertex of $N^{\prime}$; they may then end within $C$, exit back out to $N^{\prime}$, or exit out to $M$. Thus it is indeed sufficient to analyse how $C$ can satisfy requests with at least one endpoint in $N^{\prime}$. Furthermore, since there are at most $d-1$ vertices in $N(C)\cap N^{\prime}$, the solution can route at most $d-1$ path segments through $C$ in total. Moreover, all unresolved requests $(g,i)$ with $g\subseteq M\cup N^{\prime}$ that $C$ can satisfy must have $g\subseteq\left\lparen N(C)\cap N^{\prime}\right\rparen\cup M$ and $g\cap N^{\prime}\neq\emptyset$. Therefore, we obtain the following property:

The number of unresolved requests over $M\cup N^{\prime}$ that $C$ satisfies is at most $\lvert N(C)\cap N^{\prime}\rvert\cdot\lvert N(C)\cap(N^{\prime}\cup M)\rvert\cdot d\leq O(d^{3}k)$.

Before reducing the size of each connected component of $G^{\prime\prime}$, the algorithm first reduces their number by resolving requests $(g,i)$ over $M\cup N^{\prime}$ that could be satisfied by $C$.

1. (A4)

For all unresolved requests $(g,i)$ over $M\cup N^{\prime}$: If $G^{\prime\prime}$ has more than $dk$ connected components $C$ that satisfy the request $(g,i)$, we set $w_{g}\coloneqq\max\{w_{g},i\}$.

The rationale for why these request can be resolved is as in (A3): Let $P\subseteq V(G)$ be any set of size at most $dk$ and let $(g,i)$ be a newly resolved request. Then $P$ has an empty intersection with at least one component $C$ that satisfies the request $(g,i)$. This means any size-$k$ solution using the edge $g$ with its new edge weight can be rerouted through an available component $C$ that satisfies the request $(g,i)$.

We call a component $C$ useful if there is an unresolved request $(g,i)$ over $M\cup N^{\prime}$ that is satisfied by $C$. There are at most $O(d^{3}k)$ such request. Due to (A4), each such unresolved request gives rise to at most $dk$ useful components. Hence the number of useful components is at most $O\left\lparen d^{4}k^{2}\right\rparen$. Let $N^{\prime\prime}$ be the set of all vertices that belong to a useful connected component of $G^{\prime\prime}$.

1. (A5)

Set $G\coloneqq G[M\cup N^{\prime}\cup N^{\prime\prime}]$.

In other words, this step deletes all components that are not useful. To see that doing so is safe, let $G$ be the current graph and let $C$ be a component that is not useful. The claim is that $G$ has a generalized $P_{d}$-matching if and only if $G-C$ does. The if direction is trivial since any generalized $P_{d}$-matching in $G-C$ also exists in $G$. For the only if direction, let $P_{1},\dots,P_{k}$ be paths in $G$ of weight at least $d$ each, and let them be chosen in such a way that the number of vertices of $C$ that they use is minimized. We claim that they actually don’t use any vertex of $C$.

Assume for contradiction that the solution had a path segment that uses vertices of $C$. The path segment cannot have weight $\geq d$ since $C$ does not contain any paths of weight $\geq d$. Hence the path segment has some weight $i<d$, and it must enter $C$ from a vertex $x$ outside of $C$, and it may leave to a vertex $y$ outside of $C$; in particular, $C$ satisfies the request $(g,i)$ for some $f\subseteq M\cup N^{\prime}$. The request $(g,i)$ is not resolved, for if it was, we could replace the path segment through $C$ by the edge $g$ with $w_{g}\geq i$, which would make use of strictly fewer vertices of $C$. Since $g\subseteq N(C)\subseteq M\cup N^{\prime}$ holds, $(g,i)$ is unresolved, and $(g,i)$ is satisfied by $C$, we arrive at a contradiction with the fact that $C$ is not useful. Overall, if there is a solution, then there is a solution that does not use any vertex of $C$, and so it is safe to delete $C$.

At this point, we are keeping the $\operatorname{poly}(dk)$ vertices of $M\cup N^{\prime}$ in the kernel as well as $\operatorname{poly}(dk)$ useful components. The only issue left to resolve is that useful components may still contain too many vertices. Recall that at most $d-1$ segments of paths from a solution can intersect $C$. Since every path has length at most $d$, every solution $P$ uses at most $(d-1)(d+1)\leq d^{2}$ vertices of $C$. We will replace $C$ with a graph $C^{\prime}$ of size at most $f(d)$ such that any set of at most $d-1$ requests can be satisfied by $C$ if and only if it can be satisfied by $C^{\prime}$. We construct $C^{\prime}$ as an induced subgraph of $C$ by using representative sets.

1. (A6)

For each unresolved request $(g,i)$ over $M\cup N^{\prime}$ and for each useful connected component $C$:

1. (a)

Set $S\coloneqq\emptyset$. 2. (b)

While $|S|\leq d^{2}$:

1. i.

Find an arbitrary path $p^{\prime\prime}$ from $\operatorname{Paths}^{C-S}(g,i)$ and mark the vertices $V(p^{\prime\prime})\setminus g$ as useful. If no such path exists, break the while loop. 2. ii.

Branch on $v\in V(p^{\prime\prime})\setminus g$ and add $v$ to $S$. 2. (A7)

Delete all vertices of useful components that have never been marked as useful in any branch for any request.

Before we prove the correctness of (A7), let us first analyze the running time and kernel size. For given $C$ and $(g,i)$, (A6) produces a branching tree of depth at most $d^{2}$ since $|S|$ increases by one in every branching step. The fan-out of the branching tree is equal to the size of $V(p)\setminus g$, which is at most $i$ and thus at most $d$. Therefore, the branching tree has at most $O(d^{d^{2}})$ vertices, and at most $O(d^{d^{2}})$ vertices of $C$ get marked as useful; this is the number of vertices we keep for the component $C$ and the unresolved request $(g,i)$. Since the number of unresolved requests that $C$ satisfies is at most $O(d^{3}k)$ and since the number of useful components is at most $O(d^{4}k^{2})$, the total number of vertices that remain after (A7) is $O(d^{d^{2}}d^{7}k^{3})$.

For the correctness, let $G$ be the graph before applying (A7) and let $G^{-}$ be the graph after. The claim is that $G$ has a solution if and only if $G^{-}$ does. The if direction is trivial since $G^{-}$ is a subgraph of $G$. For the only if direction, let $P_{1},\dots,P_{k}$ be disjoint paths of $G$, each of weight $\geq d$, and let this solution be chosen as to minimize the number $u$ of useless vertices being used and, subject to that, to minimize the number $o$ of other vertices of $G^{\prime\prime}$ that are being used by the solution. If $u=0$ zero, then $P_{1},\dots,P_{k}$ is also a solution of $G^{-}$, what we wanted to show. Assume for contradiction that $u>0$ and the solution uses a useless vertex $v$, and let $C$ be the useful connected component of $G^{\prime\prime}$ that contains $v$.

Let $(g,i)$ for $g\subseteq M\cup N^{\prime}$ be the request to $C$ that the solution $P_{1},\dots,P_{k}$ satisfies with the path segment $p=e_{1},\dots,e_{\ell}$ that uses $v\in C$. That is, $p$ is a connected subgraph of some $P_{j}$ and satisfies the following properties:

$p\in\operatorname{Paths}^{C}(g,i)$ and 2. 2.

if $p$ contains an endpoint of $P_{j}$, then $\lvert g\rvert=1$; otherwise $\lvert g\rvert=2$.

We remark that a path segment $p$ cannot contain both endpoints of $P_{j}$ since $C$ does not contain paths of weight $\geq d$. If $(g,i)$ was resolved, we could replace the corresponding path segment by the edge $g$ of weight $w_{g}\geq i$, which would lead to a solution with fewer useless vertices or fewer useful vertices of $G^{\prime\prime}$. Since we minimized both these numbers, the request $(g,i)$ is unresolved and thus considered in (A6).

We now show that $p$ can be replaced by another path $p^{\prime}\in\operatorname{Paths}^{C}(g,i)$ so that $p^{\prime}$ only uses vertices of $C$ that were marked as useful; this then contradicts the fact that the solution minimized the number of useless vertices. Thus the solution uses only useful vertices. Let $T\subseteq C$ be the set of all vertices of $C$ that are used by the solution, but not including the vertices of the segment $p$. That is, T\coloneqq\Big{\lparen}\left\lparen V(P_{1})\cup\dots\cup V(P_{k})\right\rparen\setminus V(p)\Big{\rparen}\cap C. By previous considerations, the size of $T$ is at most $d^{2}$. Clearly, $\operatorname{Paths}^{C\setminus T}(g,i)$ contains $p$, and we prove that it also contains a path $p^{\prime}$ that only uses useful vertices. Consider the branching tree that (A6) builds for the request $(g,i)$ and the component $C$. We start at the root of the branching tree and we follow a single branch in our argument; we only follow a branch if it satisfies $S\subseteq T$. In step b) ii) of such a branch, the set $\operatorname{Paths}^{C\setminus S}(g,i)$ is not empty, for it contains the path $p$. Let $p^{\prime\prime}$ be the path that ends up being selected and whose vertex set $V(p^{\prime\prime})$ gets marked as useful. We either have $V(p^{\prime\prime})\cap T=\emptyset$, and so we have found our path $p^{\prime}=p^{\prime\prime}$, or we have $V(p^{\prime\prime})\cap T\neq\emptyset$. In the latter case, we follow a branch in which $v\in V(p^{\prime\prime})\cap T$ gets added to $S$; this clearly preserved the invariant $S\subseteq T$. The process stops at the latest when $S=T$ holds, in which case $V(p^{\prime\prime})\cap T=\emptyset$ is guaranteed and $p^{\prime}=p^{\prime\prime}$ is the path we want to find. Overall, we replaced the segment $p$ with a segment $p^{\prime}$ that uses only useful vertices, a contradiction. Hence the solution $P_{1},\dots,P_{k}$ only uses useful vertices, which means it’s also a solution of $G^{-}$. ■

Note that $P_{d}$-Matching is $\mathsf{NP}$-hard, and in particular, the reduction takes time $f(d)\cdot\operatorname{poly}(n)$. Thus we can compose the compression above with the $\mathsf{NP}$-hardness reduction to obtain kernels of size $f(d)\cdot\operatorname{poly}(k)$ for $P_{d}$-Matching. We can also obtain a kernel more directly by modifying the argument above as follows: Every time we increase the weight of an edge $g$ in step (A3) or (A4), we store a set $V_{g}$ of at most $d^{2}k$ vertices of $G^{\prime}$ so that $\operatorname{Paths}^{V_{g}}(g,w_{g})$ contains at least $dk+1$ paths that are internally disjoint. These vertices witness that we were allowed to increase the weight to $w_{g}$. In the end, we would also keep the vertex sets $V_{g}$ in the kernel. This does not change the asymptotics for the number of vertices in the kernel.

Following the notation introduced in Section 5, Theorem 6.7 and the arguments in the previous paragraph show that $P_{d}$-Matching has uniform kernels of type B2. By Lemma 5.1, it follows that $P_{d}$-Matching has kernels of type A2 and B1 as well, proving Theorem 1.6 stated in the the introduction.

As $P_{d}$-Matching has kernels of type A2 and B1, it is natural to wonder whether it has kernels of type A1. Restricting the problem to $k=1$ yields the $d$-Path problem. An A1-kernelization for $P_{d}$-Matching would imply a polynomial kernel for $d$-Path, which it does not have unless $\mathsf{coNP}\subseteq\mathsf{NP/poly}$.

Acknowledgements

We thank Martin Grohe and Dieter van Melkebeek for valuable comments on previous versions of this paper.

Appendix A Sunflower Kernelization for Set Matching

We sketch a modern proof of Theorem 1.1, that $d$-Set Matching has kernels with $O(k^{d})$ hyperedges.

Proof* (Sketch).*

A sunflower with $p$ petals is a set of $p$ hyperedges whose pairwise intersections are equal. By the sunflower lemma, any $d$-uniform hypergraph $G$ with more than $d!\cdot r^{d}$ edges has a sunflower with $r+1$ petals [13] and in fact such a sunflower can be found in linear time. We set $r=dk$ and observe that, in any sunflower with $r+1$ petals, we can arbitrarily choose an edge $e$ of the sunflower and remove it from the graph. To see this, assume we have a matching $M$ of $G$ with $k$ edges. If $M$ does not contain $e$, then $M$ is still a matching of size $k$ in $G-e$. On the other hand, if $M$ contains $e$, there must be a petal that does not intersect $M$ since we have $dk+1$ petals but $M$ involves only $dk$ vertices. Thus we can replace $e$ in the matching by the edge that corresponds to that petal, and we obtain a matching of $G^{\prime}$ that consists of $k$ hyperedges. This establishes the completeness of the reduction. The soundness is clear since any matching of $G^{\prime}$ is a matching of $G$. ■

Appendix B Multicolored Biclique

Lemma B.1**.**

Multicolored Biclique* is $\mathsf{NP}$-complete. *

Proof*.*

Let graph $G$ and integer $k$ be an instance of Clique. Let $\{v_{i}\mid 1\leq i\leq n\}$ be the vertex set of $G$. We construct a bipartite graph $B$ on vertex set $\{u_{i,j},w_{i,j}\mid 1\leq i\leq k,1\leq j\leq n\}$. We make vertices $u_{i,j}$ and $v_{i^{\prime},j^{\prime}}$ adjacent if and only if

• $\circ$

either $(i,j)=(i^{\prime},j^{\prime})$ or

• $\circ$

$i\neq i^{\prime}$ and vertices $v_{j}$ and $v_{j^{\prime}}$ are adjacent.

Consider the partitions $U=U_{1}\cup\dots\cup U_{k}$ and $W=W_{1}\cup\dots\cup W_{k}$, where $U_{i}=\{u_{i,j}\mid 1\leq j\leq n\}$ and $W_{i}=\{w_{i,j}\mid 1\leq j\leq n\}$. We claim that $B$ contains a biclique $K_{n,n}$ respecting these partitions if and only if $G$ contains a $k$-clique. It is easy to see that if $\{v_{a_{1}},\dots,v_{a_{k}}\}$ is a clique in $G$, then $\{u_{1,a_{1}},\dots,u_{k,a_{k}},w_{1,a_{1}},\dots,w_{k,a_{k}}\}$ is a biclique of the required form in $B$. On the other hand, if $\{u_{1,a_{1}},\dots,u_{k,a_{k}},w_{1,b_{1}},\dots,w_{k,b_{k}}\}$ is such a biclique, then $a_{i}=b_{i}$ for every $1\leq i\leq k$; otherwise $u_{i,a_{i}}$ and $w_{i,b_{i}}$ are not adjacent. It follows that $\{v_{a_{1}},\dots,v_{a_{k}}\}$ is a clique in $G$: if $v_{a_{i}}$ and $v_{a_{i^{\prime}}}$ are not adjacent in $G$ (including the possibility that $a_{i}=a_{i^{\prime}}$), then $u_{i,a_{i}}$ and $w_{i^{\prime},b_{i^{\prime}}}=w_{i^{\prime},a_{i^{\prime}}}$ are not adjacent in $B$. ■

Appendix C Lower Bounds for Vertex Cover in Hypergraphs

We present an elementary reduction from \operatorname{OR}(\textsc{3-Sat}) to $d$-Vertex Cover, i.e., the vertex cover problem in $d$-uniform hypergraphs. The $d$-partiteness flavor is crucial in the reduction, but it is not necessary to explicitly spell out the $d$-partite problem $L$ as we did with Multicolored Biclique before.

Recall that a subset $S$ of vertices in a $d$-partite hypergraph is a clique if all of the $\binom{|S|}{d}$ size-$d$ subsets of $S$ are edges of the hypergraph. Similarly, $S$ is an independent set if none of these $\binom{|S|}{d}$ sets is an edge of the hypergraph. The set $S$ is a vertex cover if every edge of the hypergraph has a non-empty intersection with $S$. The complement $\overline{H}$ of a $d$-uniform hypergraph contains edge $e$ if and only if $H$ does not contain $e$. Analogously to graphs, $H$ has an independent set of size $k$ if and only if $\overline{H}$ has a clique of size $k$. Moreover, an $n$-vertex hypergraph has an independent set of size $k$ if and only if it has a vertex over of size $n-k$.

Theorem C.1** ([10]).**

*Let $d\geq 2$ be an integer. If $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$ holds, then $d$-Vertex Cover does not have kernels of size $O(k^{d-\varepsilon})$. *

Proof*.*

Let $\varphi_{1},\dots,\varphi_{t}$ be $t$ instances of $3$-Sat, each of size $s$. Without loss of generality, assume that the set of variables occurring in the formulas is a subset of $[s]$. Let $P$ be the consistency graph on partial assignments that assign exactly three variables of $[s]$. More precisely, the vertex set of $P$ is the set of functions $\sigma:S\to\{0,1\}$ for sets $S\in\binom{[s]}{3}$, and two partial assignment $\sigma,\sigma^{\prime}\in V(P)$ are adjacent in $P$ if and only if $\sigma$ and $\sigma^{\prime}$ are consistent, i.e., they agree on the intersection of their domains. Now the cliques of size $\binom{s}{3}$ in $P$ are exactly the cliques that are obtained from full assignments $[s]\to\{0,1\}$ by restriction to their three-variable sub-assignments. Furthermore, $P$ has no clique of size larger than $\binom{s}{3}$.

We construct a $d$-uniform hypergraph $G$ on $n=t^{1/d+o(1)}\operatorname{poly}(s)$ vertices that has a clique with some number $k$ of vertices if and only if some $\varphi_{i}$ is satisfiable. We known that this is further equivalent to $\overline{G}$ having an independent set of size $k$, or to $\overline{G}$ having a vertex cover of size $n-k=t^{1/d+o(1)}\operatorname{poly}(s)$. Thus such a reduction is sufficient to apply Lemma 2.1 and to prove the lower bound for $d$-Vertex Cover.

We use a suitable bijection between $[t]$ and $[t^{1/d}]^{d}$, and we write the $\varphi_{i}$’s as $\varphi_{b_{1},\dots,b_{d}}$ for $(b_{1},\dots,b_{d})\in[t^{1/d}]^{d}$. The vertex set of $G$ consists of $d\cdot t^{1/d}$ groups of vertices $V_{a,b}$ for $a\in[d]$ and $b\in[t^{1/d}]$. We consider each set $V_{1,b}$ as a copy of the vertex set of $P$, and for $a>1$, we let $|V_{a,b}|=1$ for all $b$. A subset $e$ of $d$ elements of $V(G)$ is a hyperedge in $G$ if and only if the following properties hold:

each $a\in[d]$ has at most one $b=b_{a}\in[t^{1/d}]$ for which $e\cap V_{a,b}\neq\emptyset$, 2. 2.

$e\cap V_{1,b_{1}}$ corresponds to a clique in $P$, and 3. 3.

if $e\cap V_{a,b_{a}}\neq\emptyset$ for all $a$, then the (unique) partial assignment $\sigma\in e\cap V_{1}$ does not set any clause of $\varphi_{b_{1},\dots,b_{d}}$ to false.

Edges with $|e\cap V_{1,b_{1}}|>1$ play the role of checking the consistency of partial assignments, and edges with $|e\cap V_{a,b_{a}}|=1$ for all $a$ select an instance $\varphi_{b}$ and check whether that instance is satisfiable.

We set $k=\binom{s}{3}+d-1$. For the completeness of the reduction, let $\sigma:[s]\to\{0,1\}$ be a satisfying assignment of $\varphi_{b_{1},\dots,b_{d}}$. Let $C$ be the set of all three-variable sub-assignments of $\sigma$ in the set $V_{1.b_{1}}$, and we also add the $d-1$ vertices of $V_{2,b_{2}}\cup\dots\cup V_{d,b_{d}}$ to $C$. We claim that $C$ induces a clique in $G$. Let $e$ be a $d$-element subset of $C$, we show that it is a hyperedge in $G$ since it satisfies the three conditions above. Clearly, $e\subseteq C$ is fully contained in $V_{1,b_{1}}\cup\dots\cup V_{d,b_{d}}$ and satisfies the first condition. The second condition is satisfied since $e\cap V_{1,b_{1}}$ contains only sub-assignments of the full assignment $\sigma$. The third condition holds since $\sigma$ is a satisfying assignment and therefore none of its sub-assignments sets any clause to false.

For the soundness, let $C$ be a clique of size $k$ in $G$. By the first property, $C$ intersects at most one set $V_{a,b_{a}}$ for all $a$. Also, the intersection $C\cap V_{1,b_{1}}$ induces a clique in $G$ and therefore corresponds to a clique of $P$. By the properties of $P$, this intersection can have size at most $\binom{s}{3}$, and the only other vertices $C$ can contain are the $d-1$ vertices of $V_{2,b_{2}}\cup\dots\cup V_{d,b_{d}}$. Thus, we indeed have $|C\cap V_{1,b_{1}}|=\binom{s}{3}$ and $|C\cap V_{2,b_{2}}|=\dots=|C\cap V_{d,b_{d}}|=1$. The properties of $P$ imply that the first intersection corresponds to some full assignment $\sigma:[s]\to\{0,1\}$. By the third property, no three-variable sub-assignment sets any clause of $\varphi_{b_{1},\dots,b_{d}}$ to false, so $\sigma$ satisfies the formula.

Thus, (G,k)\in\textsc{d-Clique} if and only if (\varphi_{1},\dots,\varphi_{t})\in\operatorname{OR}(\textsc{3-Sat}). Since $G$ and $k$ are computable in time polynomial in the bitlength of $(\varphi_{1},\dots,\varphi_{t})$ and $n\coloneqq|V(G)|\leq t^{1/d}\cdot\operatorname{poly}(s)$, we have established the polynomial-time mapping reductions that are required to apply Lemma 2.1. Thus, if $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$ holds, $d$-Clique does not have kernels of size $O(n^{d-\varepsilon})$. Due the bijection mentioned in the paragraph before the statement of Theorem C.1, between $k$-cliques in $G$, $k$-independent sets in the complement hypergraph $\overline{G}$, and $(n-k)$-vertex-covers in $\overline{G}$, the claim follows, namely that $d$-Vertex-Cover does not have kernels of size $O(k^{d-\varepsilon})\leq O(n^{d-\varepsilon})$ if $\mathsf{coNP}\not\subseteq\mathsf{NP/poly}$. ■