Abstract 1 Introduction 2 Preliminaries 3 Technical overview 4 Protrusion replacement for disconnected forbidden minors 5 Uniform 𝟐-lossy polynomial compression algorithm 6 Uniform (𝟏+ϵ)-lossy polynomial compression protocol 7 Conclusion References

Protrusion Decompositions Revisited:
Uniform Lossy Kernels for Reducing Treewidth and Linear Kernels for Hitting Disconnected Minors

Roohani Sharma ORCID Discrete Mathematics Group, Institute for Basic Science (IBS), Daejeon, South Korea Michał Włodarczyk ORCID Institute of Informatics, University of Warsaw, Poland
Abstract

Let be a finite family of graphs. In the -Deletion problem, one is given a graph G and an integer k, and the goal is to find k vertices whose deletion results in a graph with no minor from the family . This may be regarded as a far-reaching generalization of Vertex Cover and Feedback vertex Set. In their seminal work, Fomin, Lokshtanov, Misra & Saurabh [FOCS 2012] gave a polynomial kernel for this problem when the family contains a planar graph. As the size of their kernel is g()kf(), a natural follow-up question was whether the dependence on in the exponent of k can be avoided. The answer turned out to be negative: Giannopoulou, Jansen, Lokshtanov & Saurabh [TALG 2017] proved that this is already inevitable for the special case of the Treewidth-η-Deletion problem.

In this work, we show that this non-uniformity can be avoided at the expense of a small loss. First, we present a simple 2-approximate kernelization algorithm for Treewidth-η-Deletion with a kernel size g(η)k6. Next, we show that the approximation factor can be made arbitrarily close to 1, if we settle for a kernelization protocol with 𝒪(1) calls to an oracle that solves instances of size bounded by a uniform polynomial in k. We extend the above results to general -Deletion, whenever contains a planar graph, as long as an oracle for Treewidth-η-Deletion is available for small instances. Notably, all our constants are computable functions of and our techniques work also when some graphs in may be disconnected.

Our results rely on two novel techniques. First, we transform so-called “near-protrusion decompositions” into true protrusion decompositions by sacrificing a small accuracy loss. Secondly, we show how to optimally compress such a decomposition with respect to general -Deletion. Using our second technique, we also obtain linear kernels on sparse graph classes when contains a planar graph, whereas the previously known theorems required all graphs in to be connected. Specifically, we generalize the kernelization algorithm by Kim, Langer, Paul, Reidl, Rossmanith, Sau & Sikdar [TALG 2015] on graph classes that exclude a topological minor.

Keywords and phrases:
kernelization, graph minors, treewidth, uniform kernels, minor hitting
Funding:
Roohani Sharma: Supported by the Young Scientist Fellowship of the Institute for Basic Science (IBS-R029-Y8).
Michał Włodarczyk: Supported by the Polish National Science Centre SONATA-19 grant 2023/51/D/ST6/00155.
Copyright and License:
[Uncaptioned image] © Roohani Sharma and Michał Włodarczyk; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Graph algorithms analysis
Related Version:
Full Version: https://arxiv.org/abs/2601.08424
Acknowledgements:
We thank the anonymous reviewer for pointing out a way to derive a finer bound for Lemma 26.
Editors:
Meena Mahajan, Florin Manea, Annabelle McIver, and Nguyễn Kim Thắng

1 Introduction

Consider a finite family of graphs. In the -Deletion problem we are given a graph G and a positive integer k and we ask whether one can remove k vertices from G to obtain a graph that is -minor-free, that is, it does not contain any graph F as a minor. This captures a wide variety of graph problems such as Vertex Cover, Feedback Vertex Set, Diamond Hitting Set, or d-Path Transversal. It is known that -Deletion is fixed-parameter tractable (FPT) [28] for every family and it admits a polynomial kernel111A polynomial kernel for a parameterized problem L is a polynomial-time algorithm that given an instance (I,k) of L returns an equivalent one (I,k) such that |I|+k𝗉𝗈𝗅𝗒(k). See the book [8]. whenever contains at least one planar graph [11]. This condition is equivalent to the existence of a constant η() such that every -minor-free graph has treewidth [5, §7] bounded by η() [26]. A canonical problem that fits into this category is Treewidth-η-Deletion: remove k vertices from a graph to reduce its treewidth to η. The arguably simplest case for which does not contain a planar graph is Vertex Planarization; here the existence of a polynomial kernel remains a major open problem [18].

What may seem like a downside of the kernelization algorithm by Fomin et al. [11] is its non-uniformity: the size of the kernel is of the form 𝒪(kf()) for some function f. This turns out to be inevitable: Treewidth-η-Deletion does not admit a kernel of size 𝒪η(ko(η)) unless NP coNP/poly [14]. On the positive side, uniform kernels are known for Treedepth-η-Deletion with 𝒪η(k6) vertices [14] and for families of connected graphs that include K2,p (for any p) with 𝒪(k10) vertices [22] (cf. [10]).

Another way to obtain uniform kernelization is to restrict the input graph G to some well-behaving graph class. There are several meta-theorems that yield linear kernels for miscellaneous problems over the class of planar graphs [4], for every proper minor-closed graph class [12], and even for every graph class that excludes some graph as a topological minor [13, 19]. These approaches suffer from a different weakness though: they require the problem in question to satisfy a certain separation condition. This translates to a restriction that every graph in the family must be connected. Consequently, we could not handle deletion to graph classes such as “planar graphs of bounded face cover” or “bounded-treewidth graphs embeddable on a torus”. In the second example, observe that the family of minimal minor obstructions to torus embeddability includes K5+K5.

Lossy kernelization.

In order to overcome known barriers against polynomial kernels [3, 8], researchers started to study a lossy variant of kernelization [23]. Intuitively, an α-approximate kernel reduces the task of finding an approximate solution to an instance of size 𝗉𝗈𝗅𝗒(k) where k bounds the optimum. Here, the approximation factor α measures how much is “lost in translation” between the two instances: a c-approximate solution is translated to an (αc)-approximate solution. Such lossy kernels have been studied for Vertex Planarization [18] and for -Deletion with a connectivity constraint on solution [7, 24]. To capture the difficulty of an approximation task by parameter k, solutions larger than k are treated as equally bad and we define their cost as k+1 [23].

Analogously to exact kernelization, one can allow the algorithm to repeatedly call an oracle that (approximately) solves an instance of bounded size. Assuming that the oracle processes instances of size 𝗉𝗈𝗅𝗒(k), such an algorithm is called an (approximate) polynomial Turing kernelization [16, 21]. A restricted model in which the number of oracle calls is bounded by 𝗉𝗈𝗅𝗒(k) (so, in particular, it does not depend on the input size) has been dubbed a lossy kernelization protocol [9]. In fact, allowing just two oracle calls unlocks technical tools unavailable for currently known one-shot lossy kernels [9]. Whereas there are problems that admit an exact polynomial Turing kernel and are unlikely to admit a regular polynomial kernel [17], the current lower bound techniques do not distinguish whether the oracle is called 𝗉𝗈𝗅𝗒(k) times or just once [8, §21]. It is therefore an intriguing question if and how (lossy) kernelization protocols can outperform one-shot (lossy) kernels.

Our results.

In this paper we address the two raised issues that trouble the existing kernelization algorithms for -Deletion. First, we show that a uniform polynomial kernelization for Treewidth-η-Deletion is possible if we settle for 2-approximation. This should be compared to polynomial-time 𝒪(logη)-approximation algorithm for Treewidth-η-Deletion [15] whereas c-approximation with an absolute constant c remains elusive. Our result extends to -Deletion  for any family containing a planar graph, modulo the fact that we still need an oracle solving Treewidth-η-Deletion. As the oracle problem differs from the original one, we obtain a slightly weaker result, namely a lossy polynomial compression.

Theorem 1 (Uniform lossy kernel).

Let be a finite family of graphs containing at least one planar graph. Then -Deletion admits a 2-lossy compression with 𝒪(k5) vertices and of size 𝒪(k6). Moreover, Treewidth-η-Deletion admits a 2-lossy kernel with 𝒪(k5) vertices and of size 𝒪(k6).

We can improve the approximation factor from 2 to (1+ϵ) for any ϵ>0 by calling the oracle in several rounds. The number of rounds, as well as the degree in the kernel size, depend only on ϵ. Hence we obtain a uniform lossy compression protocol with approximation factor arbitrary close to 1 and with constant number of rounds.

Theorem 2 (Uniform lossy protocol).

Let be a finite family of graphs containing at least one planar graph. For any ϵ>0, -Deletion admits a (1+ϵ)-lossy compression protocol of call size 𝒪(k6+k3r+1), and at most 1+r rounds, where r=1+log1+ϵ(1ϵ).

For the special case of Treewidth-η-Deletion, there is a (1+ϵ)-lossy kernelization protocol with same call size and number of rounds.

The proofs of Theorems 1 and 2 rely on “protrusion techniques” [8, §16]. An r-protrusion is a vertex subset XV(G) such that (i) treewidth of G[X] is at most r and (ii) X contains at most r vertices with a neighbor outside X. A graph G admits an (α,β)-protrusion decomposition if there is a vertex subset P0V(G) of size α so that GP0 can be covered by α many β-protrusions (see Section 2 for formal definitions). In the proofs we transform so-called near-protrusion decompositions [11] into true protrusion decompositions with bounded parameters α,β by sacrificing small accuracy loss. The known techniques can compress such structures in a uniform fashion as long as all graphs in the family are connected. To tackle the remaining cases, we prove the following lemma. Here, 𝗈𝗉𝗍(G) denotes the minimum size of a solution to -Deletion in G, i.e., an -deletion set.

Lemma 3 (Handling disconnected forbidden minors).

Let be a finite family of graphs. There is an algorithm that, given a graph G with an (α,β)-protrusion decomposition and integer k, runs in time 𝒪,β(|V(G)|) and outputs a graph G with 𝒪,β(α+k) vertices such that min(𝗈𝗉𝗍(G),k+1)=min(𝗈𝗉𝗍(G),k+1).

We remark that the factor hidden in the 𝒪()-notation is a computable function of (,β). See Lemma 14 for a full statement tailored for lossy kernelization. As a corollary of Lemma 3 we obtain linear kernels on graph classes where one can compute an (𝒪(k),𝒪(1))-protrusion decomposition. The most general cases where such a construction is known are classes with excluded topological minor [19]. Whereas the known linear kernels for -Deletion require all the graphs in to be connected [4, 12, 13, 19], we are able to drop this assumption.

Theorem 4 (Linear kernel on sparse graphs).

Let H be a graph and be a finite family of graphs containing at least one planar graph. Then -Deletion admits a linear kernel on H-topological-minor-free graphs.

Organization of the paper.

We begin with an informal exposition of our main technical ideas in Section 3. The most of the remaining space is devoted to Lemma 3 (Section 4) which is too technical to be covered in the overview. We prove Theorems 1 and 2 in Sections 5 and 6. Since Theorem 4 follows from Lemma 3 and previous results, it is given in the full version of the article. The full version also contains the proofs of lemmas marked with () as well as background on tree decompositions and lossy kernelization.

2 Preliminaries

For any object F, the notation 𝒪F() hides factors depending on F. For p we denote [p]=[1,p]={1,,p}.

Definition 5.

Let T be a rooted tree and SV(T) be a set of vertices in T. We define the least common ancestor of (not necessarily distinct) u,vV(T), denoted as 𝖫𝖢𝖠(u,v), to be the deepest node x which is an ancestor of both u and v. The LCA closure of S is the set 𝖫𝖢𝖠¯(S)={𝖫𝖢𝖠(u,v):u,vS}.

Lemma 6 ([8, Lem. 9.26, 9.27, 9.28]).

Let T be a rooted tree, SV(T) be non-empty, and L=𝖫𝖢𝖠¯(S). All of the following hold.

  1. 1.

    Each connected component C of TL satisfies |NT(C)|2.

  2. 2.

    |L|2|S|1.

  3. 3.

    𝖫𝖢𝖠¯(L)=L.

Protrusions.

For any β, a β-protrusion in a graph G is a vertex set XV(G) such that the treewidth of G[X] is at most β and |G(X)|β, where G(X)=NG(V(G)X). When G is clear from the context, we drop the subscript.

Definition 7.

For α,β, an (α,β)-protrusion decomposition of a graph G is a partition of the vertex set V(G)=(P0,P1,,P) such that:

  1. 1.

    max{|P0|,}α, and

  2. 2.

    for each i[1,], N[Pi] is a β-protrusion, and

  3. 3.

    for each i[1,], N(Pi)P0.

We refer to P0 as the root bag of the decomposition. A protrusion decomposition is called nice if for each i[1,] it holds that |N(Pi)|β.

Lemma 8.

An (α,β)-protrusion decomposition (P0,P1,,P) of G can be transformed in linear time into a nice (α,β)-protrusion decomposition (P0,P1,,P) such that for each i[1,] it holds that PiPi.

Proof.

Fix i[1,]. By definition, we have that |(N[Pi])|=|N(V(G)N[Pi])|β. Suppose that vN(Pi)(N[Pi]). Then N(v)N[Pi] and moving v from P0 to Pi does not alter the set N[Pi], hence N[Pi]{v} remains a β-protrusion. After performing such an operation exhaustively for each i[1,] and vN(Pi)(N[Pi]), we obtain a nice (α,β)-protrusion decomposition.

Boundaried graphs.

A t-boundaried graph is a triple 𝐇=(H,B,λ) where H is a graph, BV(H) is of size t and λ:[t]B is a bijection representing a labeling function. We refer to the set B as 𝐇 and call it the boundary of 𝐇. By V(𝐇) we refer to V(H). Given two t-boundaried graphs 𝐇𝟏=(H1,B1,λ1) and 𝐇𝟐=(H2,B2,λ2), 𝐇𝟏𝐇𝟐 denotes the graph H obtained by first taking the disjoint union of H1 and H2 and then identifying each vertex u1 in B1 with u2B2 such that λ11(u1)=λ21(u2). For h and a graph G, h-folio(G) is the set of all graphs on at most h vertices which appear in G as a minor.

Lemma 9 ().

There is a computable function γ:×× so that the following holds. Let h,r,d and be a family of graphs where each graph has at most h vertices. Next, for a graph G and an r-protrusion X, let us denote 𝐇=(G[X],G(X),λ), where λ is some labeling function, and 𝐇=(G[N[V(G)X]],G(X),λ). Note that G=𝐇𝐇.

Then there is an algorithm that, given G and X, runs in time 𝒪h,r,d(|X|) and returns a graph G with the following properties.

  1. 1.

    G is obtained from G by replacing the boundaried graph 𝐇 with a |G(X)|-boundaried graph 𝐇^, that is G=𝐇^𝐇 such that:

    • h-folio(𝐇𝐇)=h-folio(𝐇^𝐇^)

    • |V(𝐇^)|γ(h,r,d).

  2. 2.

    Given an -deletion set S in G such that |SV(𝐇^)|d, one can in polynomial time find an -deletion set S in G of size at most |S|. And vice versa, an -deletion set S in G such that |SV(𝐇)|d can be lifted to an -deletion set S of size at most |S| in G.

Additionally, suppose that Q is a fixed graph and G is Q-topological-minor free. Then the algorithm outputs a graph G that is also Q-topological-minor free in time 𝒪h,r,d,Q(|X|).

The proof of Lemma 9 appears in the full version for completeness and follows the proof of [13, Theorem 1.1]. Note that the key highlight of Lemma 9 is that the function γ is computable and the family is arbitrary (and not necessarily of connected graphs).

3 Technical overview

We sketch the main ideas in Theorems 1 and 2 for the simplest case of Treewidth-η-Deletion. The starting point is a near-protrusion decomposition from [11]: one can assume that graph G is equipped with disjoint sets X,Z so that |X|=𝒪η(k), |Z|=𝒪η(k3), tw(GX)η, each component C of G(XZ) has 𝒪η(1) neighbors in Z and each u,vN(C)X are highly connected. The last condition implies that for any solution S of size k, if {u,v}S= then u,v must share a bag in any tree decomposition of GS of width η. Therefore, it is safe to insert the edge uv to G. We can thus assume that N(C)X is a clique. If this clique has size 2(η+1) then we know that any solution must remove at least half of its vertices. And so we can remove the entire clique by paying 2 in the approximation factor. After applying such a reduction rule, each component C of G(XZ) has 𝒪η(1) neighbors in total. This implies that N[C] forms an 𝒪η(1)-protrusion, having both its treewidth and boundary bounded. The framework of protrusion replacement [4, 13] allows us to replace G[N[C]] by a subgraph of constant size that exhibits the same behavior with respect to the problem in question. The caveat is that the number of such protrusions may be as large as kΩ(η) which is prohibitive for constructing a uniform kernel.

Uniform lossy kernel.

We would like to transform the current decomposition into a (𝒪η(kc),𝒪η(1))-protrusion decomposition, where c does not depend on η. We call a component C of G(XZ) simplicial if N(C) forms a clique. Because we can insert edges between highly connected vertices in XZ, each non-edge may appear only in a bounded number of sets N(C). We use this argument to bound the number of non-simplicial components by 𝒪η(k5). Let us neglect the simplicial components for a moment and let G denote the graph without them. Then G admits a protrusion decomposition of desired form and we can compress G to G′′ on 𝒪η(k5) vertices. This is the output of the kernelization algorithm.

It remains to provide a mechanism to lift a solution S′′ from G′′ to G. First, we note that a solution S′′ can be lifted to a solution S of G using standard tools. The interesting step is lifting S to a solution S in G. This is the part where the lifting step of the algorithm does a nontrivial (yet, polynomial-time) computation exploiting a treewidth bound. Consider a tree decomposition 𝒯 of GS of width η and a simplicial component C of G(XZ). Since N(C)S is a clique, it must be covered by some bag in 𝒯. Therefore, we can plug G[N[C]] into 𝒯 by merging a tree decomposition of G[N[C]] of width 2η+1 and the tree decomposition 𝒯 alongside N(C)S. This argument bounds the treewidth of GS by 2η+1 and on such a graph we can solve Treewidth-η-Deletion exactly in polynomial time. We output the union of S and the optimal solution in GS, resulting in 2-approximation.

Uniform lossy protocol.

Improving the approximation factor below 2 requires a different approach. We can still start with the sets XZ as described in the beginning of this section, and make each connected component C of G(XZ) a protrusion, this time by removing a clique in the neighbourhood of C whose size is at least (η+1)(1+ϵ)/ϵ. The main challenge is to bound the number of simplicial protrusions. Let Y0=XZ. Since we now aim at a lossy kernelization protocol, we can send G[Y0] to the oracle which outputs Y1Y0 for which tw(G[Y0Y1])η. Assume for simplicity that the oracle always returns an optimal solution. Then |Y1|=𝗈𝗉𝗍(G[Y0])𝗈𝗉𝗍(G). And once again, we ask the oracle for a solution Y2 in G[Y1].

Suppose first that |Y2|>(1ε)|Y1|. Observe that any optimal solution S in G satisfies |SY1|𝗈𝗉𝗍(G[Y1]) so 𝗈𝗉𝗍(GY1)𝗈𝗉𝗍(G)(1ε)|Y1|. A crucial observation is that removing Y1 from G allows us to construct an (𝒪η(k5),𝒪η(1))-protrusion decomposition. For each simplicial component C, the set N(C)Y1 forms a clique in the graph G[Y0Y1] of treewidth η. But the number of cliques in a bounded-treewidth graph is linear so we can group the simplicial components into 𝒪η(|Y0Y1|) protrusions according to their neighborhoods in Y0Y1. Together with 𝒪η(k5) non-simplicial components, this allows us to compress the graph GY1 into size 𝒪η(k5). Let S1 be the solution in GY1 computed with the help of the oracle. Assuming |S1|=𝗈𝗉𝗍(GY1) we get |S1|+|Y1|𝗈𝗉𝗍(G)(1ε)|Y1|+|Y1|=𝗈𝗉𝗍(G)+ϵ|Y1|(1+ϵ)𝗈𝗉𝗍(G).

Suppose now that |Y2|(1ε)|Y1|. We continue asking the oracle for solution Yi+1 in G[Yi]. Let j be the first iteration for which |Yj+1|>(1ε)|Yj|. We repeat the same trick but this time the set Y0Yj is partitioned into j subsets (Y0Y1),(Y1Y2),,(Yj1Yj), each inducing a graph of treewidth η. The number of cliques in G[Y0Yj] can be bounded by f(η,j)|Y0|j, allowing us to construct an (𝒪η,j(k𝒪(j)+5),𝒪η,j(1))-protrusion decomposition.

This procedure yields a uniform kernelization protocol as long as j can be bounded. But suppose we keep getting outcome |Yj+1|(1ε)|Yj|. Then for r=1+log1ϵ(ϵ) we obtain |Yr|(1ε)r1|Y1|=ε|Y1|ε𝗈𝗉𝗍(G). In this case we can again use the oracle to compute a solution in GYr, bounding the number of protrusions by |Y0|r, and merge it with Yr, achieving (1+ε)-approximation. See Figure 3 on page 3 for an illustration.

In order to handle -Deletion, we need to be more careful because inserting an edge between highly connected vertices may no longer be safe. To this end, we introduce an auxiliary graph which collects these inserted edges and exploit the fact that the optimum to -Deletion can be lower bounded by the optimum to Treewidth-η-Deletion, for some η=η(). We need to ask the oracle for solutions to Treewidth-η-Deletion over the auxiliary graph as well, and this is the reason why in general we end up with compression protocol, rather than kernelization protocol. Whereas the standard protrusion replacement technique suffices to finish the construction when all the graphs in are connected, dealing with the general case requires one more tool.

Handling disconnected forbidden minors.

There are two known ways to compress protrusions in the presence of disconnected graphs in . First, one can consider an annotated version of -Deletion, where some vertices are marked as undeletable [4], but this requires the oracle to solve a significantly harder task. Secondly, one can take advantage of a certain well-quasi-order over boundaried graphs [11] but this involves a non-constructive argument and results in factors that a priori may be an uncomputable function of . Besides, both approaches are insufficient to construct a linear kernel in Theorem 4.

To visualize the issue, consider F=K4+C5 and an (α,β)-protrusion decomposition (P0,P1,,P) of a graph G. It may be the case that G[Pi] is K4-free for some i[1,] but it contains a lot of minor models of C5. Depending on whether a solution to F-Deletion hits all the copies of K4 outside P, it may need to remove either none or a very large number of vertices in P. In fact, such a problem does not admit finite integer index [19], a property crucial for protrusion replacement [4, 13].

Observe however that if G[Pi] contains a disjoint packing of k+1 minor models of C5, then we already know that no solution of size k can make the graph C5-minor-free, so it should “focus” on hitting the K4-minors. There is a caveat though: it might be the case that the only minor model of K4 in G intersects each model of C5 and so K4+C5 already does not appear as a minor. In order to circumvent such error-prone corner cases, we refine an (α,β)-protrusion decomposition to one with dichotomy property. It states that for every connected graph F on at most h vertices (where h is the maximum graph size in ) either F does not appear as a minor in GP0 or F has a large “private” collection of protrusions in which it appears. This property implies that any optimal solution S can use only 𝒪,β(1) vertices from each protrusion, mimicking the missing separation property. Intuitively, the aforementioned collections justify that any solution S of size k must focus on hitting minors that do not appear in GP0, and so it does not make sense to remove too many vertices from a single protrusion. Consequently, the constructive protrusion replacement by Garnero et al. [13] can be adapted to compress protrusions in a decomposition with the dichotomy property.

To construct a decomposition with dichotomy property we generalize the packing/covering duality for connected minor models in bounded-treewidth graphs [25]. In our case however we do not pack models of a single graph F but we consider a family of connected graphs and in each step of a greedy procedure we need to choose one graph F to be packed, without spoiling the invariants for the remaining graphs from . The details are technical and we omit them here.

4 Protrusion replacement for disconnected forbidden minors

In this section we collect ingredients to prove Lemma 14 which is a generalization of Lemma 3. We begin with two crucial definitions. We write 2[1,] to denote the power set of [1,].

Definition 10 (Minor packing).

Let c and be a finite family of graphs. We say that a protrusion decomposition (P0,P1,,P) of G admits an (,c)-minor packing if there is a mapping I:2[1,] such that:

  1. 1.

    for each F, |I(F)|=c,

  2. 2.

    for each F,iI(F), it holds that FmG[Pi],

  3. 3.

    for each distinct F1,F2, the sets I(F1),I(F2) are disjoint.

Definition 11 (Dichotomy property).

Let k,h and h𝖼𝗈𝗇𝗇 denote the family of all connected graphs on at most h vertices. We say that a protrusion decomposition (P0,P1,,P) of graph G has (k,h)-dichotomy property if it admits an (,k+h)-minor packing, where h𝖼𝗈𝗇𝗇 is the family of connected graphs that belong to h-folio(GP0).

We prove that any protrusion decomposition can be modified to satisfy (k,h)-dichotomy property. After initializing =h𝖼𝗈𝗇𝗇, we consider each graph from and as long as GP0 contains an F-deletion set SF of size 𝒪h,β(k) for some F, we insert SF into P0 and remove F from . More precisely, we first compute the LCA-closure for SF in a tree decomposition of GP0 to preserve the invariants of a protrusion decomposition. When we cannot proceed, each remaining graph F must have a large packing of disjoint minor models in GP0. Note that these models can intersect for different F. We give a greedy procedure that scans a tree decomposition of GP0 bottom-up and marks bags that allow us to separate a new protrusion containing a model of F (see Figure 2 on page 2). We also care to keep the set of marked bags closed under LCA, so that we end up with a protrusion decomposition of GP0 with an (,k+h)-minor packing. Finally, we merge it with the protrusion decomposition of G.

Lemma 12.

Suppose G admits an (α,β)-protrusion decomposition (P0,P1,,P). Then it also admits a nice (α+𝒪h,β(k),𝒪h,β(1))-protrusion decomposition with (k,h)-dichotomy property. Furthermore, this new decomposition, together with the corresponding minor packing, can be constructed in time 𝒪h,β(|V(G)|) given the old one.

Figure 1: Illustration to Lemma 13 for F being a disjoint union F1+F1+F2+F3 and ={F}. Top left: An -deletion set S is marked with black discs. The gray areas correspond to those Pi which belong to I(F1),I(F2). Their neighborhoods in P0 are sketched as well. Each Pi in the corresponding family contains a minor model of the graph drawn in brown and is disjoint from S. Top right: S^ is obtained from S by removing SP1 and adding the vertices marked with squares. A potential minor model Φ of F in GS^ is drawn in blue. It places one copy of F1 inside P1. Bottom right: A new model Φ of F is obtained from Φ by moving the image of F1 to an unused component in I(F1). But this model is also present in GS which leads to a contradiction.

The proof of Lemma 12 is technical and we defer it to Section 4.1 to keep the focus of the current section. We now explain how dichotomy property ensures that an optimal -deletion set can remove only a bounded number of vertices from each protrusion.

Lemma 13.

Suppose G admits a nice (α,β)-protrusion decomposition (P0,P1,,P) with (k,h)-dichotomy property and let be a family of graphs of maximum size h. Next, suppose that G has an -deletion set S of size k. Then G has an -deletion set S^ with the property that for each i[1,] we have |S^Pi|β(h|h𝖼𝗈𝗇𝗇|+1) and |S^||S|.

Furthermore, one can compute S^, given G, S and (P0,P1,,P), in polynomial time. Moreover, every minimum -deletion set in G has the described property.

Proof.

Let Gh𝖼𝗈𝗇𝗇 be the family of those connected graphs on at most h vertices that appear as minors in GP0. Due to (k,h)-dichotomy property, for each HG there is a collection I(H)[1,] of size k+h, such that for iI(H) we have HmG[Pi] and the sets I(H) are disjoint for distinct graphs H from G. Since |S|k, for some h indices iI(H) the set Pi is disjoint from S. Let us denote this subset as JHI(H). Consequently, for each HG we have |JH|=h, the sets JH are pairwise disjoint, and for each iJH it holds that HmG[Pi] and PiS=, Note that HG|JH|h|h𝖼𝗈𝗇𝗇|.

Suppose that there exists j[1,] for which |SPj|>β(h|h𝖼𝗈𝗇𝗇|+1). W.l.o.g. we will assume that j=1. Let S^ be obtained from S by (1) removing SP1, (2) inserting N(P1), (3) inserting N(Pi) for every iJH, HG (see Figure 1). Note that |S^|<|S| because the given protrusion decomposition is nice.

We will now prove that S^ is also an -deletion set. Suppose not, and let F be a graph appearing in GS^ as a minor. Let F1,,Fc, ch, be the connected components of F. Note that some of them may be isomorphic. Consider a minor model Φ of F in GS^ for which the number of Fj appearing in P1 is minimized. More precisely, we minimize the number c of indices j[c] for which Φ(V(Fj))P1. Observe that P1 is a union of connected components of GS^ so if Φ(V(Fj)) intersects P1 then it must be fully contained in P1. If c=0 then F is a minor of G(P1S^). But this is an induced subgraph of GS, which is -minor-free by assumption, so this is impossible.

Consequently, the minor model Φ places c1 connected components of F inside P1. Assume w.l.o.g. that this is the case for F1. Aiming at contradiction, we want to modify Φ to place F1 outside P1, without affecting the models of remaining Fj, j>1. Since F1mG[P1] it follows that F1G. Recall that for each iJF1 it holds that S^Pi= (because SPi=) and N(Pi)S^. Since each Fj is connected, Φ(Fj) can intersect at most one Pi for iJF1. Next, |JF1|=h and ch, so there is some iJF1 for which Pi is disjoint from all Φ(Fj), j>1. Therefore, we can move the model of F1 from P1 to Pi, obtaining a model Φ of F in GS^ with c1 components contained in P1. This contradicts the choice of the model Φ and, consequently, contradicts the assumption that FmGS^. Hence S^ is a valid -deletion set.

We can repeat this process to reduce the intersection of S^ with each Pi because the described modification to S never adds new vertices from any Pi. A single refinement step can be implemented in polynomial time using any polynomial-time algorithm for minor testing, for example [27, 20], which also yields an algorithm to construct S^. Observe that if G has an -deletion set of size at most k, then every minimum -deletion set S in G must satisfy |SPi|β(h|h𝖼𝗈𝗇𝗇|+1) as otherwise we could find a smaller -deletion set.

We can now combine Lemma 13 with Lemma 9 to compress each Pi in a protrusion decomposition to a constant size. It is crucial that Lemma 9 preserves the h-folio of G[Pi] therefore the dichotomy property is maintained after the replacement. The last point of the lemma statement refers to the solution cost capped at k+1, which will be convenient in the design of a lossy kernelization protocol.

Lemma 14.

Let k,h and be a family of graphs of maximum size h. There is an algorithm that, given a graph G with an (α,β)-protrusion decomposition, runs in time 𝒪h,β(|V(G)|) and returns a graph G on 𝒪h,β(α+k) vertices such that min(𝗈𝗉𝗍(G),k+1)=min(𝗈𝗉𝗍(G),k+1).

Furthermore, given an -deletion set S in G, one can in polynomial time lift it to an -deletion set S in G, satisfying

val(G,k)-Del(S)𝗈𝗉𝗍-Del((G,k))val(G,k)-Del(S)𝗈𝗉𝗍-Del((G,k)).

Proof.

We apply Lemma 12 to construct a nice (α^,β^)-protrusion decomposition (P0,P1,,P) with the (k,h)-dichotomy property, where α^=α+𝒪h,β(k) and β^=𝒪h,β(1). Let d:=β^(h|h𝖼𝗈𝗇𝗇|+1). We will iteratively replace each protrusion induced by NG[Pi] with one of constant size using Lemma 9. Below we describe this process for P1.

We fix some labeling λ of G(NG[P1])) and replace the boundaried graph 𝐇=(G[N[P1]],N(P1),λ) with a boundaried graph 𝐇^ of size 𝒪h,β^,d(1)𝒪h,β(1). Denote the new graph G and let P1 be the set of vertices put in place of P1.

Claim 15.

Suppose that 𝗈𝗉𝗍(G)k. Then 𝗈𝗉𝗍(G)𝗈𝗉𝗍(G).

Proof.

By Lemma 13 there exists an optimal -deletion set S in G such that |SP1|d. Lemma 9 guarantees that such an S can be translated to an -deletion set in G of size at most |S|.

Claim 16.

The protrusion decomposition (P0,P1,P2,,P) of G admits (k,h)-dichotomy property.

Proof.

Lemma 9 ensures that h-folio(𝐇𝐇)=h-folio(𝐇^𝐇^) which can be rewritten as h-folio(G[P1])=h-folio(G[P1]). If P1 contributed a minor model to the minor packing corresponding to (k,h)-dichotomy property, it can be replaced by a minor model of the same graph in G[P1].

Claim 17.

Suppose that 𝗈𝗉𝗍(G)k. Then 𝗈𝗉𝗍(G)𝗈𝗉𝗍(G). Furthermore, given an -deletion set S in G of size k, one can in polynomial time lift it to an -deletion set S in G of size at most |S|.

Proof.

The previous claim allows us to apply Lemma 13 to graph G and S. Given S we can in polynomial time find an -deletion set S^ in G of size |S| for which |S^P1|d. By applying Lemma 9 we can lift S^ to a solution in G of size at most |S^||S|. By taking S to be an optimal -deletion set in G, we infer that 𝗈𝗉𝗍(G)𝗈𝗉𝗍(G).

Claims 15 and 17 imply that min(𝗈𝗉𝗍(G),k+1)=min(𝗈𝗉𝗍(G),k+1) and provide a mechanism to lift a bounded-size solution from G to G while preserving its size. Claim 16 ensures that we preserve the (k,h)-dichotomy property in the new protrusion decomposition of G, so we can repeat this process to replace each Pi. Application of Lemma 9 takes time linear in the size of the protrusion being replaced, so the total running time is linear.

We now justify the final inequality for lifting solutions. Recall that when S is a feasible -deletion set in G then val(G,k)-Del(S)=min{|S|,k+1} and 𝗈𝗉𝗍-Del((G,k)) is the minimum over val(G,k)-Del(S). In these terms, we have 𝗈𝗉𝗍-Del((G,k))=𝗈𝗉𝗍-Del((G,k)). Suppose first that |S|>k so val(G,k)-Del(S)=k+1. Then we simply return S=V(G) for which val(G,k)-Del(S)=k+1 and the inequality holds. Otherwise, |S|k. We use the lifting algorithm described in Claim 17 to compute a solution S in G so that |S||S| and we have |S|𝗈𝗉𝗍-Del((G,k))|S|𝗈𝗉𝗍-Del((G,k)).

4.1 Proof of Lemma 12

We first summon the known packing-covering duality for bounded-treewidth graphs.

Proposition 18 ([25, Lemma 3.10]).

Let β, and G,F be graphs, such that tw(G)β and F is connected. Then either G contains a packing of disjoint minor models of F or there is a set SV(G) of size at most (β+1) such that GS is F-minor-free.

Furthermore, for fixed F there is a linear algorithm that outputs one of these two objects, when given a corresponding tree decomposition of G.

The following lemma utilizes the LCA-closure in a tree decomposition to cover a given vertex set S by the root bag of a protrusion decomposition.

Lemma 19 ().

Let β1, G be a graph of treewidth at most β, and SV(G). Then there exists a nice (2(β+1)|S|, 2(β+1))-protrusion decomposition (P0,P1,,Pp) of G with SP0. Furthermore, (P0,P1,,Pp) can be computed in linear time when a corresponding tree decomposition of G is given.

Next, we will need a mechanism to refine a protrusion decomposition by another one, while preserving an (,c)-minor packing.

Lemma 20 ().

Let be a family of connected graphs, c, (P0,P1,,Pp) be a nice (α1,β1)-protrusion decomposition of a graph G, and (Q0,Q1,,Qq) be a nice (α2,β2)-protrusion decomposition of GP0 with an (,c)-minor packing. Then G admits a nice (α1+2α2β2,β1+β2)-protrusion decomposition with an (,c)-minor packing, whose root bag is P0Q0. Furthermore, the new decomposition and its minor packing can be computed in linear time.

The following lemma shows that if we have a sufficiently large packing of F-minors in a bounded-treewidth graph, for every Fh𝖼𝗈𝗇𝗇, then we can choose a large subset from each packing, so that together all the picked minor models are disjoint.

Lemma 21.

Let h, h𝖼𝗈𝗇𝗇, G be a graph such that tw(G)β and for each F there is a disjoint packing of 6(β+1)|h𝖼𝗈𝗇𝗇|(k+h) minor models of F in G. Then there exists a nice (𝒪h,β(k), 2β+2)-protrusion decomposition (Q0,Q1,,Q) of G with an (,k+h)-minor packing. Furthermore, (Q0,Q1,,Q) and the corresponding minor packing can be constructed in time 𝒪h,β(|V(G)|).

Proof.

Consider a binary tree decomposition (T,χ) of G of width β, rooted at some node r. It can be constructed in linear time [2]. For a subset CV(T) let χ¯(C)=χ(C)χ(V(T)C) be the set of vertices appearing only in the bags from C. We will describe a procedure that scans T bottom-up and marks two disjoint sets M,LV(T), both initialized as empty. Intuitively, a node will be marked (and added to M) when it is a deepest node below which we can still find a minor model that can be added to the minor packing, and L will form the LCA closure of M. When we add a new node to M or L, we will create new connected components C of T(ML) not containing r. To some of these components we will assign F such that FmG[χ¯(C)]. We will refer to the number of components assigned to F as the score of F. We say that F is completed when its score reaches k+h. After the i-th step we shall maintain the following invariants.

  1. 1.

    The set MiLi comprises i nodes and Li is contained in 𝖫𝖢𝖠¯(Mi).

  2. 2.

    The sum of all scores equals |Mi|.

  3. 3.

    Let Cir denote the connected component of T(MiLi) that contains r. For every connected component C of T(MiLi) different from Cir, it holds that |N(C)|2.

  4. 4.

    For each F either F is already completed or G[χ¯(Cir)] contains a packing of 3(β+1)(2|h𝖼𝗈𝗇𝗇|(k+h)i) minor models of F.

Clearly, the invariants hold for i=0, before the first iteration. We will never increase a score of F that has been already completed so the algorithm terminates when |Mi|=||(k+h). As |MiLi||𝖫𝖢𝖠¯(Mi)|2|Mi| (Lemma 6), it follows that the algorithm will perform at most 2||(k+h)2|h𝖼𝗈𝗇𝗇|(k+h) iterations.

Consider the i-th iteration, 1i<2||(k+h), and suppose there are still some not completed graphs in . Consider tV(T) that is not equal or descendant of any tMiLi. For such t let CitV(T) denote the set of those nodes which are descendants of t but not equal to or a descendant of any tMiLi. We look for the deepest node tV(T) for which G[χ¯(Cit)] contains a minor model of some F that is not yet completed. By invariant (4), such a node t must exist because for each not completed F there is a packing of at least 3(β+1) models of F in χ¯(Cir) whereas χ(r) can intersect at most β+1 of them, so t=r satisfies the criteria.

We consider two scenarios. First suppose that there are some t1,t2Mi for which t^=𝖫𝖢𝖠(t1,t2) is descendant of t and t^ does not belong to LiMi. Choose such t^ that is deepest and update Li+1=Li{t^}, Mi+1=Mi. In the second scenario, when there is no such t^, we set Mi+1=Mi{t}, Li+1=Li. By the choice of t, in the latter scenario we have created a new component C of T(MiLi), not containing r, for which FmG[χ¯(C)]. Note that C can be chosen as a single component of T(MiLi) because F is connected. Then we assign F to C. See Figure 2 for an example.

Figure 2: Illustration to Lemma 21. The bags corresponding to nodes from Mi are drawn in blue and those from Li are drawn in brown. The already collected minor models, assigned to some components, are yellow. Left: A bag of t selected in the i-th iteration and a minor model of some F below t have blue borders. The first scenario does not trigger so t is added to Mi. This creates a component C (light yellow) of T(MiLi) to which we assign F. The component Cir has gray background. Right: In this situation there is t^ below t that is 𝖫𝖢𝖠 of two nodes from Mi1. We do not add t to Mi but instead t^ is inserted to Li. We do not increase any score in this scenario.

We need to justify that all the invariants are preserved. The first two are clear.

To show invariant (3), we inspect the two scenarios. In first one, we have chosen the t^=𝖫𝖢𝖠(t1,t2) for some t1,t2Mi that does not yet belong to LiMi. Suppose that one of the created components of T(MiLi) below t^ has more than two neighbors. Then it has at least two neighbors different from t^. Let s1,s2MiLi denote these neighbors and let s^=𝖫𝖢𝖠(s1,s2). Note that s^ must be a descendant of t^. By invariant (1), there are s1,s2Mi such that s^=𝖫𝖢𝖠(s1,s2) as well. This contradicts the choice of t^ because s^ satisfies the same condition and is located deeper. The same argument works in the second scenario. If some component of T(MiLi) created below t has more than two neighbors, then t must have a descendant s^ with the same property, hence it is the first scenario that must have occurred.

To advocate invariant (4) we show that for every not-yet-completed F the number of disjoint minor models of F in χ¯(Cir) can decrease only moderately. Let F denote the initial disjoint packing of 6(β+1)|h𝖼𝗈𝗇𝗇|(k+h) minor models of F in G. Let iFF denote the subfamily of those minor models which are entirely contained in χ¯(Cir). We aim to show that |i+1F||iF|3(β+1); this will imply invariant (4).

Let us fix F and let tV(T) be the node chosen in the i-th iteration, in any of the two scenarios. Recall that we work on a binary tree decomposition so t has either one or two children; w.l.o.g. assume there are two of them: t1,t2. Furthermore, let C1,C2 be the connected components of Cir{t} that contains t1,t2, respectively. Let UV(G) induce a minor model from iFi+1F. Suppose that Mχ¯(C1). Because we have not chosen t1 in the i-th iteration, U must intersect χ(t1). Similarly, if Uχ¯(C2) then U must intersect χ(t2). If neither of these cases hold, U must intersect χ(t) because G[U] is connected. Since |χ(t)χ(t1)χ(t2)|3(β+1) and the considered minor models are disjoint, we infer that |iFi+1F|3(β+1). Hence invariant (4) is preserved.

Having completed all F, the process stops. Let j denote the number of the last iteration, let M=Mj,L=𝖫𝖢𝖠¯(M). Invariant (2) implies that |M|=||(k+h). By invariant (3) we know that LLjCjr, that is, we do not add any new vertices to L that would intersect a component of T(MjLj) to which we have assigned some F. We define Q0=tLχ(t); this set has at most 2(β+1)|M|2(β+1)|h𝖼𝗈𝗇𝗇|(k+h) vertices. By Lemma 6 the neighborhood of each connected component of GQ0 is contained in at most two bags of (T,χ), so it contains at most 2(β+1) vertices. For each F we gather the components of TL assigned to F. For each such component C we add the set QC=χ¯(C) to the protrusion decomposition. This gives us the (,k+h)-minor packing. Using LCA-closure, the remaining components of TL can be grouped into 2|L| sets, each with neighborhood in at most two nodes. This concludes the proof.

We are ready to prove the Lemma 12 and thus complete the proof of Lemma 14.

Proof of Lemma 12.

Let k^=6(β+1)|h𝖼𝗈𝗇𝗇|(k+h). Due to Lemma 8 we can assume that (P0,P1,,P) is nice, i.e., for i[1,] we have |NG(Pi)|β. Initialize 1=h𝖼𝗈𝗇𝗇, α1=α, β1=β, and 𝒫1=(P0,P1,,P), P1=P0. In the i-th iteration we will remove one set from i and construct a new protrusion decomposition 𝒫i+1 with a root bag denoted as Pi+1. We will maintain an invariant that GPi is F-minor-free for each Fh𝖼𝗈𝗇𝗇i.

In the i-th iteration, i1, we apply Proposition 18 for every Fi, the graph GP0i and =k^. Suppose that for some Fi this call returns a vertex set SF of size (β+1)k^ for which G(PiSF) is F-minor-free. Then we apply Lemma 19 to the graph GPi and set SF to compute a nice (2(β+1)k^, 2(β+1))-protrusion decomposition of GPi whose root bag contains SF. Next, we apply Lemma 20, disregarding the parameter , to transform it into a nice (αi+1,βi+1)-protrusion decomposition 𝒫i+1 of G whose root bag Pi+1 contains SF and Pi. We can estimate αi+1=αi+2(β+1)2k^ and βi+1=βi+2(β+1). We set i+1=i{F} and the invariant is preserved.

Let j denote the iteration number at which this process stops. Let =j. We have j|h𝖼𝗈𝗇𝗇|+1 so αj=α+𝒪h,β(k) and βj=𝒪h,β(1). If = then we are done so let us assume otherwise.

Since the process has stopped, Proposition 18 guarantees that every F has a packing of k^ disjoint minor models in GPj. Hence the requirements of Lemma 21 are satisfied with respect to the graph GPj. Applying the lemma gives us a nice (𝒪h,β(k), 2β+2)-protrusion decomposition 𝒬 of GPj with an (,k+h)-minor packing. Finally, we apply Lemma 20 with respect to 𝒫j, 𝒬, and the constructed (,k+h)-minor packing for 𝒬. As a result, we obtain a nice (α+𝒪h,β(k),𝒪h,β(1))-protrusion decomposition of G with an (,k+h)-minor packing. Furthermore, the root bag of contains Pj. Therefore GPj is F-minor-free for each Fh𝖼𝗈𝗇𝗇 and so the above minor packing yields (k,h)-dichotomy property.

5 Uniform 𝟐-lossy polynomial compression algorithm

In this section we prove Theorem 1. Several reduction rules from the section will also come in useful in Section 6. Throughout Sections 5 and 6, we assume that the family contains a planar graph. Fix an arbitrary Fplanar which is a planar graph. The Grid Minor Theorem implies that for any -deletion set S of G, the treewidth of GS is bounded in terms of |V(Fplanar)| [26]. We shall denote by η=η() the upper bound on the treewidth of an -minor-free graph.

Following the convention from [23], we consider solution cost capped at k+1, i.e., we measure the cost of an -deletion set S in G as val(G,k)(S):=min{|S|,k+1}. This ensures that the parameter k captures the difficulty of an instance (G,k). We refer the reader to [23] and the full version of this article for more details on lossy kernelization and lossy reduction rules.

Our kernelization algorithm (and protocol) starts by constructing a near-protrusion decomposition of V(G) as done in [11, Lemma 25]. The construction is [11] is randomized because it relies on a randomized constant-factor approximation algorithm for -Deletion. This step, and hence the entire construction of [11, Lemma 25], can be made deterministic by using the deterministic constant-factor approximation for -Deletion from [15, Corollary 1.1].

Lemma 22 ([11, Lemma 25] together with [15, Corollary 1.1]).

There is a polynomial-time algorithm that given an instance (G,k) of -Deletion, when contains a planar graph, either reports correctly that (G,k) is a no-instance of -Deletion, or computes X,ZV(G), XZ= such that:

  • |X|=𝒪η(k), |Z|=𝒪η(k3), X is an -deletion set of G,

  • for each connected component C of G(XZ), |NG(C)Z|2(η+1), and

  • for each connected component C of G(XZ), and distinct u,vNG(C)X, there are at least k+η+2 vertex-disjoint paths from u to v in G.

Throughout the rest of this section, X,Z stand for the sets returned by Lemma 22 for input (G,k). We now design a (1+ϵ)-lossy strict reduction rule that bounds the size of the neighborhood of each connected component of G(XZ).

Lossy Reduction Rule 1.

Let ϵ>0 and let C be a connected component of G(XZ) such that |NG(C)X|(1+ϵ)(η+1)ϵ. In this case the reduction algorithm takes as input an instance (G,k) of -Deletion and outputs the instance (G:=G(NG(C)X),k:=k|NG(C)X|) of -Deletion.

The solution lifting algorithm takes as input instances (G,k),(G,k) and a set SV(G) and outputs the set SV(G), where S:=S(NG(C)X).

We prove that such a reduction rule is a a (1+ϵ)-lossy strict reduction rule, that is, valG,k-Del(S)𝗈𝗉𝗍-Del(G,k)max{(1+ϵ),valGmk-Del(S)𝗈𝗉𝗍-Del(G,k)}.

Lemma 23 ().

Lossy 1 is a (1+ϵ)-lossy strict reduction rule.

After an application of Lossy 1, some vertices from X may get deleted. But the remaining set X, together with Z, still satisfies the properties of Lemma 22 in the resulting graph. We keep the variable X to denote this set in the new graph.

Lemma 24 ().

When Lossy 1 is no longer applicable, then there is an (α,𝒪(η/ϵ))-protrusion decomposition (P0,P1,,P) of G for some α, where P0:=XZ and for each i[1,], Pi is a connected component of G(XZ). Furthermore, (P0,P1,,P) can be computed in polynomial time.

Let (P0,,P) be the protrusion decomposition obtained from Lemma 24. We now define the augmented graph Gflow of G which is a supergraph of G on the same vertex set as G, and which is obtained by additionally adding the edge set {uv:u,vP0, there exist at least k+η+2 internally vertex-disjoint paths from u to v in G} in G.

Lemma 25 ().

The following two (in)equalities hold:

  1. 1.

    𝗈𝗉𝗍Tw-η-Del((G,k))=𝗈𝗉𝗍Tw-η-Del((Gflow,k)),

  2. 2.

    𝗈𝗉𝗍-Del((G,k))𝗈𝗉𝗍Tw-η-Del((Gflow,k)).

We partition {P1,,P} into two groups based on the neighborhood of Pi in Gflow. Let 𝒫simp={Pi:Gflow[N(Pi)] is a clique or N(Pi) is empty}, which we call the set of simplicial parts of the protrusion decomposition. Let 𝒫non-simp be the set of remaining parts, referred to as non-simplicial parts. Note that we cannot simply discard Pi for which N(Pi)= in the case of -Deletion when contains disconnected graphs. Observe that when u,vP0 and uvE(Gflow) then {u,v} can belong to at most k+η+1 sets N(Pi).

Lemma 26 ().

|𝒫non-simp|=𝒪η(k5).

We show that ignoring the simplicial parts yields a 2-lossy compression reduction rule. To this end, we need an algorithm solving -Deletion exactly on bounded-treewidth graphs.

Proposition 27 ([1, Theorem 4]).

When is a finite family of graphs and contains at least one planar graph, then -Deletion can be solved in time 2𝒪(twlogtw)n on an n-vertex graph of treewidth tw.

Lossy Reduction Rule 2.

Suppose we are given an instance (G,k) of -Deletion with the corresponding protrusion decomposition (P0,P1,,P). The reduction algorithm outputs (G:=Gflow[V(G)Pi𝒫simpPi],k:=k).

The solution lifting algorithm takes a solution S of the Treewidth-η-Deletion problem on the instance (G,k). It computes an optimum-sized -deletion set S′′ of GS in 𝒪,η(n𝒪(1)) time using the algorithm of Proposition 27 (we argue in Lemma 28 that this is possible). It then outputs S:=SS′′ as a solution on -Deletion for the instance (G,k).

Specifically, we prove that the simplicial parts can be added to GS while keeping the treewidth bounded by 𝒪(η). Hence S′′ can be computed in polynomial time.

Lemma 28 ().

Lossy 2 is a 2-lossy compression reduction rule.

After the exhaustive application of Lossy 1 and 2, it only remains to bound the size of each part in 𝒫non-simp, which can be done using Lemma 14. The formal proof of Theorem 1 is given next.

Theorem 1 (Uniform lossy kernel). [Restated, see original statement.]

Let be a finite family of graphs containing at least one planar graph. Then -Deletion admits a 2-lossy compression with 𝒪(k5) vertices and of size 𝒪(k6). Moreover, Treewidth-η-Deletion admits a 2-lossy kernel with 𝒪(k5) vertices and of size 𝒪(k6).

Proof.

We describe a polynomial time 2-lossy compression algorithm below. Given an instance (G,k) of -Deletion, first compute a near-protrusion decomposition on the instance (G,k) in polynomial time using Lemma 22. This gives sets X,Z with the properties listed in Lemma 22. Set ϵ=1 and for each connected component C of G(XZ), it checks whether Lossy 1 is applicable. Let (G1,k1) be the instance returned by the reduction algorithm of Lossy 1 at the end of its exhaustive application. From Lemma 24, G1 has an (α,𝒪(η))-protrusion decomposition (P0,,P) for some (unbounded) α and |P0|=𝒪η(k3).

Let 𝒫non-simp be the set of non-simplicial parts of (P1,,P). From Lemma 26, |𝒫non-simp|=𝒪η(k5). Run the reduction algorithm of Lossy 2 on the instance (G1flow[V(G1)Pi𝒫simpPi],k1) of -Deletion. It returns an instance (G2,k1) of Treewidth-η-Deletion such that G2 has an (𝒪η(k5),𝒪(η))-protrusion decomposition. Let (G3,k1) be the instance returned by the algorithm of Lemma 14 on input (G2,k1). Observe that k1k. From Lemma 14 the number of vertices of G3 is bounded by 𝒪(k5). Observe that if G3 indeed has an at most k-sized vertex set whose deletion results in a graph of treewidth at most η, then treewidth of G3 has to be at most k+η. Thus, the number of edges of G3, and hence the size of G3, is at most (k+η) times the number of vertices of G3. Thus, the size of G3 is 𝒪(k6), otherwise G3 has no k-sized solution.

For any β1, run the β-compression oracle for Treewidth-η-Deletion on the instance (G3,k1) and let S3 be the returned β-approximate solution of the instance (G3,k1) of Treewidth-η-Deletion. The algorithm of Lemma 14 provides a lifting algorithm that, in polynomial time, outputs a β-approximate solution S2 for the instance (G2,k1) of Treewidth-η-Deletion. Given the β-approximate solution S2 for the instance (G2,k1) of Treewidth-η-Deletion, from Lemma 28, the solution lifting algorithm of Lossy 2, outputs a 2β-approximate solution S1 for the instance (G1,k1) of the -Deletion problem. Finally since Lossy 1 is a (1+ϵ)-lossy strict reduction rule and ϵ=1, using the solution lifting algorithm of Lossy 1 and S1, one can obtain a 2-approximate solution for the instance (G,k) of -Deletion. Clearly, in the special case of Treewidth-η-Deletion the above constitutes a 2-lossy kernelization algorithm.

6 Uniform (𝟏+ϵ)-lossy polynomial compression protocol

This section is devoted to the proof of Theorem 2. Assume that we are given an instance (G,k) of -Deletion, ϵ>0, and an (α,𝒪(η/ϵ))-protrusion decomposition (P0,P1,,P) of G from Lemma 24, for some unbounded α, with |P0|=𝒪η(k3). Recall that the parts {P1,,P} of this protrusion decomposition were partitioned into two sets: 𝒫simp (simplicial parts) and 𝒫non-simp (non-simplicial parts). Lemma 26 estimates |𝒫non-simp| as 𝒪η(k5).

Refer to caption
Figure 3: Illustration to Lemma 29. The protocol starts by finding a β-approximate solution S1 to the Treewidth-η-Deletion problem in G[P0]. Then Q1 is the set obtained after deleting S1 from P0; note that tw(G[Q0])η. It then repeats the process of finding a solution to the Treewidth-η-Deletion problem inside the old solution S1 and continues doing so until the obtained new solution is a large fraction of the previous solution. Afterwards, Lossy 3 removes the final solution from the graph and compresses the remaining graph using Lemma 32.
Lemma 29.

Consider ϵ>0 and β. Let r=1+log1+ϵ(1ϵ). There exists a polynomial-time protocol which has access to a β-approximate kernelization oracle 𝖮 for Treewidth-η-Deletion of capacity |P0|, and when given (Gflow[P0],k) as input, it makes at most r calls to the oracle 𝖮, and outputs a partition of P0=(Q0,,Qr), such that

  1. 1.

    for each i[1,r], treewidth of Gflow[Qi] is at most η (Qi is allowed to be empty), and

  2. 2.
    1. (a)

      |Q0|(1+ϵ)β𝗈𝗉𝗍Tw-η-Del((Gflow[Q0],k)) or

    2. (b)

      |Q0|ϵβ𝗈𝗉𝗍Tw-η-Del((Gflow[P0],k)).

Proof.

We design an iterative procedure with at most r steps. See Figure 3 for a visualization. Initialize Q0:=P0 and for each i[1,r], set Qi:=. Let S1 be the set returned by the oracle 𝖮 on input (Gflow[P0],k). Then S1 is a β-approximate solution to the instance (Gflow[P0],k) of Treewidth-η-Deletion, and so |S1|β𝗈𝗉𝗍Tw-η-Del((G[P0],k)).

In each iteration, we maintain the following invariants: (i) (Q0,Q1,,Qr) is a partition of P0, (ii) for each i[1,r], the treewidth of Gflow[Qi] is at most η, and (iii) at the end of the j-th iteration, |Q0|(11+ϵ)j1|S1|.

In the j-th iteration, j[1,r], the protocol calls the oracle 𝖮 on the instance (Gflow[Q0],k) and receives a β-approximate solution Sj to Treewidth-η-Deletion on (Gflow[Q0],k). Then |Sj|β𝗈𝗉𝗍Tw-η-Del((Gflow[Q0],k)). It proceeds with the following case distinction.

  1. 1.

    If |Q0|(1+ϵ)|Sj|, then the protocol terminates and outputs the partition (Q0,,Qr) which satisfies condition (2a).

  2. 2.

    Otherwise, |Q0|>(1+ϵ)|Sj|. In this case, we set Qj:=Q0Sj. Clearly, the treewidth of Gflow[Qj] is at most η. Next, we set Q0:=Sj.

    We now verify that the invariants are satisfied. Clearly (Q0,Q1,,Qr) is a partition of P0 and the treewidth of each Gflow[Qi], i[1,r], is at most η. If j=1 then the invariant (iii) holds trivially. Otherwise, due to case distinction, the size of Q0 drops by factor (1+ε), implying |Q0|(11+ϵ)j1|S1|.

If the first case occurs before the r-th iteration, then we are done. Otherwise, the protocol terminates after the r-th iteration. The invariant (iii) implies |Q0|(11+ϵ)r1|S1|. Substituting the definitions of r and S1 yields condition (2b): |Q0|ϵβ𝗈𝗉𝗍Tw-η-Del((Gflow[P0],k)).

We argue that one can remove Q0 from the graph while paying a small loss in accuracy.

Lossy Reduction Protocol 3.

Let (G,k) be an instance of -Deletion where Lossy 1 has been exhaustively applied. Let (P0,,P) be the protrusion decomposition of (G,k) from Lemma 24. Let (Q0,Q1,,Qr) be the partition of P0 obtained from Lemma 29, on input (Gflow[P0],k). The reduction protocol outputs (G:=GQ0,k:=k|Q0|).

The solution lifting algorithm takes as input the instances (G,k),(G,k) and SV(G) which is a β-approximate solution for the instance (G,k) of -Deletion  and outputs S:=SQ0 as a solution for (G,k) of -Deletion.

Lemma 30 ().

Lossy 3 is a (1+ϵ)-lossy reduction protocol.

On the other hand, discarding Q0 allows us to bound the number of simplicial parts. For this, we first need to bound the number of cliques in a graph of bounded treewidth.

Proposition 31.

An n-vertex graph of treewidth tw has 𝒪(2twtwn) distinct cliques.

Proof.

An n-vertex graph G of treewidth tw has a tree decomposition of width tw and 𝒪(twn) nodes [5, Lemma 7.4]. Since each clique of G is contained inside some bag of this tree decomposition [6, Lemma 12.3.5], the number of distinct cliques are at most 2tw+1 times the number of nodes in a tree decomposition.

Lemma 32.

After the application of Lossy 3, the number of distinct cliques in Gflow[P0] is 𝒪η(k3r), where r is as defined in Lemma 29.

Proof.

Let (Q0,Q1,,Qr) be the partition of P0 obtained from Lemma 29. After the application of Lossy 3, we can assume that Q0=. Recall that for each i[1,r], treewidth of Gflow[Qi] is at most η. From Proposition 31, the number of distinct cliques in Gflow[Qi] is 𝒪η(|Qi|)𝒪η(|P0|)𝒪η(k3). Therefore, the number of distinct cliques in Gflow[P0] is at most i=1r𝒪η(k3)=𝒪η(k3r).

Theorem 2 (Uniform lossy protocol). [Restated, see original statement.]

Let be a finite family of graphs containing at least one planar graph. For any ϵ>0, -Deletion admits a (1+ϵ)-lossy compression protocol of call size 𝒪(k6+k3r+1), and at most 1+r rounds, where r=1+log1+ϵ(1ϵ).

For the special case of Treewidth-η-Deletion, there is a (1+ϵ)-lossy kernelization protocol with same call size and number of rounds.

Proof.

Fix any ϵ>0. We describe a polynomial time (1+ϵ)-lossy compression protocol of capacity 𝒪η(k7)+𝒪η(k3r) and 1+r rounds. For any β1 it has access to β-kernelization oracles for -Deletion and Treewidth-η-Deletion of capacities 𝒪η(k6)+𝒪η(k3r+1).

Given an instance (G,k) of -Deletion, first compute a near-protrusion decomposition on the instance (G,k) in polynomial time using Lemma 22. This gives sets X,Z with the properties listed in Lemma 22. For each connected component C of G(XZ), it checks whether Lossy 1 is applicable. Let (G1,k1) be the instance returned by the reduction algorithm of Lossy 1 at the end of its exhaustive application. From Lemma 24, G1 has an (α,𝒪(η/ϵ))-protrusion decomposition (P0,,P) for some (unbounded) α and |P0|=𝒪η(k3). Run Lossy 3 on the instance (G1,k1) to compute (G2,k2).

Consider the augmented graph Gflow2 of G2. The number of Pi, i[1,], those neighborhood in Gflow2 is non-empty and not a clique is bounded by 𝒪η(k7) from Lemma 26. For the remaining Pi, we partition them into sets such that each part in a fixed set has the same neighborhood in Gflow2 and any two sets have distinct neighborhood in Gflow2. Let the resulting sets be R1,,Rρ. Note that for each i[1,r], N[Ri] is an 𝒪(η/ϵ)-protrusion in G and NGflow2(Ri) is a clique in Gflow2. From Lemma 32 we infer that ρ=𝒪η(k3r). Then G2 has a (δ,γ)-protrusion decomposition, where δ=𝒪η(k5)+𝒪η(k3r) and γ=𝒪(η/ϵ).

Let (G3,k3) be the instance obtained from Lemma 14 on input (G2,k2), with 𝒪(δ) vertices. If G3 has a k-sized solution then the treewidth of G3 is at most k+η and therefore the number of edges of G3 is at most 𝒪(kδ). Finally run the β-kernelization algorithm for the problem -Deletion on the instance (G3,k3). Let S3 be a β-approximate solution for the problem -Deletion on the instance (G3,k3).

Using the polynomial-time algorithm of Lemma 14, compute a β-approximate solution S2 for the instance (G2,k2) of -Deletion. We use the solution lifting algorithm of Lemma 30 with S2: let S1 be the corresponding (1+ϵ)β-approximation solution obtained for the instance (G1,k1) of -Deletion. Finally, the solution lifting algorithm of Lemma 23 takes S1 and gives a (1+ϵ)β-approximation solution for the instance (G,k).

7 Conclusion

We have presented new techniques to turn a near-protrusion decomposition into a protrusion decomposition (by sacrificing accuracy) and to process the latter in the presence of disconnected forbidden minors. A main follow-up question is whether one really needs multiple calls to the oracle to obtain a uniform (1+ε)-approximate kernel for Treewidth-η-Deletion (and other cases of -Deletion). In other words, can we improve the uniform lossy kernelization protocol to uniform lossy kernelization? Secondly, our protocol requires the oracle to handle instances of size 𝒪η,ε(kf(ε)) for some function f. Can we obtain a lossy kernel/protocol that is uniform also with respect to ε?

References

  • [1] Julien Baste, Ignasi Sau, and Dimitrios M. Thilikos. Hitting minors on bounded treewidth graphs. I. General upper bounds. SIAM J. Discret. Math., 34(3):1623–1648, 2020. doi:10.1137/19M1287146.
  • [2] Hans L. Bodlaender. A linear-time algorithm for finding tree-decompositions of small treewidth. SIAM J. Comput., 25(6):1305–1317, 1996. doi:10.1137/S0097539793251219.
  • [3] Hans L. Bodlaender, Rodney G. Downey, Michael R. Fellows, and Danny Hermelin. On problems without polynomial kernels. J. Comput. Syst. Sci., 75(8):423–434, 2009. doi:10.1016/J.JCSS.2009.04.001.
  • [4] Hans L. Bodlaender, Fedor V. Fomin, Daniel Lokshtanov, Eelko Penninkx, Saket Saurabh, and Dimitrios M. Thilikos. (Meta) Kernelization. J. ACM, 63(5):44:1–44:69, 2016. doi:10.1145/2973749.
  • [5] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [6] Reinhard Diestel. Graph Theory, 4th Edition, volume 173 of Graduate texts in mathematics. Springer, 2012.
  • [7] Eduard Eiben, Diptapriyo Majumdar, and M. S. Ramanujan. On the lossy kernelization for connected treedepth deletion set. In Michael A. Bekos and Michael Kaufmann, editors, Graph-Theoretic Concepts in Computer Science - 48th International Workshop, WG 2022, Tübingen, Germany, June 22-24, 2022, Revised Selected Papers, volume 13453 of Lecture Notes in Computer Science, pages 201–214. Springer, 2022. doi:10.1007/978-3-031-15914-5_15.
  • [8] Fedor Fomin, Daniel Lokshtanov, Saket Saurabh, and Meirav Zehavi. Kernelization: theory of parameterized preprocessing. Cambridge University Press, 2019. doi:10.1017/9781107415157.
  • [9] Fedor V. Fomin, Tien-Nam Le, Daniel Lokshtanov, Saket Saurabh, Stéphan Thomassé, and Meirav Zehavi. Lossy kernelization for (implicit) hitting set problems. In Inge Li Gørtz, Martin Farach-Colton, Simon J. Puglisi, and Grzegorz Herman, editors, 31st Annual European Symposium on Algorithms, ESA 2023, September 4-6, 2023, Amsterdam, The Netherlands, volume 274 of LIPIcs, pages 49:1–49:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.ESA.2023.49.
  • [10] Fedor V. Fomin, Daniel Lokshtanov, Neeldhara Misra, Geevarghese Philip, and Saket Saurabh. Hitting forbidden minors: Approximation and kernelization. SIAM J. Discret. Math., 30(1):383–410, 2016. doi:10.1137/140997889.
  • [11] Fedor V. Fomin, Daniel Lokshtanov, Neeldhara Misra, and Saket Saurabh. Planar F-Deletion: Approximation, kernelization and optimal FPT algorithms. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS 2012, New Brunswick, NJ, USA, October 20-23, 2012, pages 470–479. IEEE Computer Society, 2012. doi:10.1109/FOCS.2012.62.
  • [12] Fedor V. Fomin, Daniel Lokshtanov, Saket Saurabh, and Dimitrios M. Thilikos. Bidimensionality and kernels. SIAM J. Comput., 49(6):1397–1422, 2020. doi:10.1137/16M1080264.
  • [13] Valentin Garnero, Christophe Paul, Ignasi Sau, and Dimitrios M. Thilikos. Explicit linear kernels via dynamic programming. SIAM J. Discret. Math., 29(4):1864–1894, 2015. doi:10.1137/140968975.
  • [14] Archontia C. Giannopoulou, Bart M. P. Jansen, Daniel Lokshtanov, and Saket Saurabh. Uniform kernelization complexity of hitting forbidden minors. ACM Trans. Algorithms, 13(3):35:1–35:35, 2017. doi:10.1145/3029051.
  • [15] Anupam Gupta, Euiwoong Lee, Jason Li, Pasin Manurangsi, and Michal Wlodarczyk. Losing treewidth by separating subsets. In Timothy M. Chan, editor, Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019, pages 1731–1749. SIAM, 2019. doi:10.1137/1.9781611975482.104.
  • [16] Eva-Maria C. Hols, Stefan Kratsch, and Astrid Pieterse. Approximate turing kernelization for problems parameterized by treewidth. In Fabrizio Grandoni, Grzegorz Herman, and Peter Sanders, editors, 28th Annual European Symposium on Algorithms, ESA 2020, September 7-9, 2020, Pisa, Italy (Virtual Conference), volume 173 of LIPIcs, pages 60:1–60:23. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.ESA.2020.60.
  • [17] Bart M. P. Jansen, Marcin Pilipczuk, and Marcin Wrochna. Turing kernelization for finding long paths in graph classes excluding a topological minor. Algorithmica, 81(10):3936–3967, 2019. doi:10.1007/S00453-019-00614-4.
  • [18] Bart M. P. Jansen and Michal Wlodarczyk. Lossy planarization: A constant-factor approximate kernelization for planar vertex deletion. SIAM J. Comput., 54(1):1–91, 2025. doi:10.1137/22M152058X.
  • [19] Eun Jung Kim, Alexander Langer, Christophe Paul, Felix Reidl, Peter Rossmanith, Ignasi Sau, and Somnath Sikdar. Linear kernels and single-exponential algorithms via protrusion decompositions. ACM Trans. Algorithms, 12(2), December 2015. doi:10.1145/2797140.
  • [20] Tuukka Korhonen, Michal Pilipczuk, and Giannos Stamoulis. Minor containment and disjoint paths in almost-linear time. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 53–61. IEEE, 2024. doi:10.1109/FOCS61266.2024.00014.
  • [21] Stefan Kratsch and Pascal Kunz. Approximate turing kernelization and lower bounds for domination problems. In Neeldhara Misra and Magnus Wahlström, editors, 18th International Symposium on Parameterized and Exact Computation, IPEC 2023, September 6-8, 2023, Amsterdam, The Netherlands, volume 285 of LIPIcs, pages 32:1–32:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.IPEC.2023.32.
  • [22] William Lochet and Roohani Sharma. Uniform polynomial kernel for deletion to K2,p minor-free graphs. In Julián Mestre and Anthony Wirth, editors, 35th International Symposium on Algorithms and Computation, ISAAC 2024, December 8-11, 2024, Sydney, Australia, volume 322 of LIPIcs, pages 46:1–46:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.ISAAC.2024.46.
  • [23] Daniel Lokshtanov, Fahad Panolan, M. S. Ramanujan, and Saket Saurabh. Lossy kernelization. In Hamed Hatami, Pierre McKenzie, and Valerie King, editors, Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 224–237. ACM, 2017. doi:10.1145/3055399.3055456.
  • [24] M. S. Ramanujan. On approximate compressions for connected minor-hitting sets. In Petra Mutzel, Rasmus Pagh, and Grzegorz Herman, editors, 29th Annual European Symposium on Algorithms, ESA 2021, September 6-8, 2021, Lisbon, Portugal (Virtual Conference), volume 204 of LIPIcs, pages 78:1–78:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.ESA.2021.78.
  • [25] Jean-Florent Raymond and Dimitrios M. Thilikos. Recent techniques and results on the Erdős-Pósa property. Discret. Appl. Math., 231:25–43, 2017. doi:10.1016/J.DAM.2016.12.025.
  • [26] Neil Robertson and Paul D. Seymour. Graph minors. V. Excluding a planar graph. J. Comb. Theory B, 41(1):92–114, 1986. doi:10.1016/0095-8956(86)90030-4.
  • [27] Neil Robertson and Paul D. Seymour. Graph minors .xiii. the disjoint paths problem. J. Comb. Theory B, 63(1):65–110, 1995. doi:10.1006/JCTB.1995.1006.
  • [28] Ignasi Sau, Giannos Stamoulis, and Dimitrios M. Thilikos. k-apices of minor-closed graph classes. II. Parameterized algorithms. ACM Trans. Algorithms, 18(3):21:1–21:30, 2022. doi:10.1145/3519028.