A Polynomial Kernel For Multicut In Trees

The MULTICUT IN TREES problem consists in deciding, given a tree, a set of requests (i.e. paths in the tree) and an integer k, whether there exists a set of k edges cutting all the requests. This problem was shown to be FPT by Guo and Niedermeyer. They also provided an exponential kernel. They asked whether this problem has a polynomial kernel. This question was also raised by Fellows. We show that MULTICUT IN TREES has a polynomial kernel.

💡 Research Summary

The paper addresses the long‑standing open question of whether the MULTICUT IN TREES problem admits a polynomial‑size kernel. The problem is defined on a tree T with a set R of requests, each request being a simple path between two vertices, and an integer k. The task is to decide whether there exists a set S of at most k edges whose removal intersects every request in R. While Guo and Niedermeyer previously showed that the problem is fixed‑parameter tractable (FPT) with respect to k, they only provided an exponential‑size kernel and asked whether a polynomial kernel exists—a question also raised by Fellows.

The authors answer affirmatively by constructing a kernel whose size is bounded by O(k³). Their approach proceeds in two conceptual phases: (1) a structural classification of requests, and (2) a suite of reduction rules that systematically shrink the instance while preserving equivalence.

Structural classification.
Requests are partitioned into three families: (i) leaf‑leaf requests (both endpoints are leaves), (ii) leaf‑internal requests (one endpoint is a leaf, the other an internal node), and (iii) internal‑internal requests (both endpoints are internal). This taxonomy exploits the hierarchical nature of trees: leaf‑leaf paths are uniquely determined, and any edge on such a path is a candidate for the cut. By focusing on the endpoint types, the authors can bound the number of “critical” edges that may appear in a solution.

Reduction rules.
Four main reduction rules are introduced, each provably safe (i.e., they do not change the answer) and implementable in linear time.

1. Overload Rule. If more than k requests share the same tree edge, that edge must belong to any feasible solution. The rule therefore selects the edge, adds it to the solution set, and deletes all requests intersecting it. This eliminates “overloaded” edges that would otherwise force the solution size beyond k.

2. Depth Bounding Rule. When a branch of the tree has depth exceeding a function linear in k, the authors compress the deep segment into a single “virtual” node, rerouting the affected requests accordingly. The compression does not affect solvability because any solution that cuts the deep part can be transformed to cut the virtual edge instead, preserving the number of cuts.

3. Leaf Elimination Rule. If a leaf v is incident to more than k requests, the unique edge incident to v must be selected. The rule adds that edge to the solution and removes all requests involving v. This mirrors the overload rule but is specialized for leaf‑centric configurations.

4. Duplicate Edge Rule. When multiple requests correspond to the same pair of endpoints (hence the same path), all but one are redundant and can be discarded. This eliminates unnecessary multiplicities without affecting feasibility.

The algorithm repeatedly applies these rules until none is applicable. The authors prove that this process terminates after a number of iterations polynomial in the input size and that the resulting instance satisfies the following bounds:

• The number of leaves is at most O(k²) because each leaf can be involved in at most k requests after reduction.
• Consequently, the number of leaf‑leaf requests is bounded by O(k⁴), but the overload rule forces many of them to be resolved, tightening the bound to O(k³).
• The number of internal vertices is also bounded by O(k³) because each internal vertex can be adjacent to at most k critical edges after reduction.

Summing up, both the vertex set and the request set of the reduced instance are bounded by a cubic function of k, yielding a kernel of size O(k³). The authors also provide a detailed correctness proof: each reduction rule either fixes an edge that must appear in any solution or removes requests that are already guaranteed to be satisfied by previously fixed edges. Hence the reduced instance is a yes‑instance if and only if the original instance is.

The paper concludes with a discussion of the broader implications. The existence of a polynomial kernel for MULTICUT IN TREES closes a gap in the parameterized complexity landscape of cut problems on trees, aligning it with other classic tree‑based problems such as VERTEX COVER and FEEDBACK VERTEX SET, which also admit cubic or quadratic kernels. Moreover, the techniques—particularly the overload and leaf elimination rules—are likely adaptable to more general graph classes (e.g., bounded‑treewidth graphs) and to related separation problems where requests are defined by paths rather than arbitrary vertex subsets.

In summary, the authors deliver a constructive, linear‑time kernelization algorithm that reduces any instance of MULTICUT IN TREES to an equivalent instance of size O(k³). This result not only resolves an open question posed by Guo, Niedermeyer, and Fellows but also enriches the toolkit for designing efficient preprocessing procedures in parameterized algorithmics.