1 Introduction
Set Cover and Subgraph Isomorphism are two of the most wellresearched problems in theoretical computer science. In this paper we show a strong connection between their time complexity. We first discuss each, and then show our results.
Set Cover.
In the Set Cover problem, the input is a ground set and a collection of sets, and the goal is to find the smallest subcollection of sets whose union is the entire ground set. An exhaustive search takes time, and a dynamicprogramming algorithm has running time [FKW04], which is faster when , a common assumption that we will make throughout. In spite of extensive effort, no algorithm that runs in time is known, although some improvements are known in special cases [Koi09, BHK09, Ned16, BHPK17]. Here and throughout, hides polynomial factors in the instance size, and unless stated otherwise, denotes a fixed constant (and similarly ). Thus, it was conjectured that the above running time is optimal [CDL16], even if the input sets are small. To state this more formally, let Set Cover denote the Set Cover problem where all sets have size at most .
Conjecture 1.1 (Set Cover Conjecture (SeCoCo) [Cdl16]).
For every fixed there is , such that no algorithm (even randomized) solves Set Cover in time .
This conjecture clearly implies that for every , no algorithm solves Set Cover in time . Several conditional lower bounds were based on this conjecture (by reducing Set Cover to it) in the recent decade, including for Steiner Tree, Set Partitioning, and more [CDL16, BKK16, BHH15, KL16, KST17]. The authors of [CDL16] asked whether the problems they reduce Set Cover to can be reduced back to Set Cover
, so that their running time complexity would stand and fall with SeCoCo. They believed it would be hard to do, since it would probably provide for those problems an alternative algorithm with running time that matches the currently fastest one, which is very complex and took decades to achieve for some (e.g., for
Steiner Tree).Connection to SETH.
No formal connection is known to date between the SeCoCo conjecture and the Strong Exponential Time Hypothesis (SETH) of [IP01], which asserts that for every there exists , such that kSAT on variables and clauses cannot be solved in time . Cygan et al. [CDL16] provided a partial answer by showing a SETHbased lower bound for a certain variant of Set Cover (that counts the number of solutions). It is known that the weaker assumption ETH implies a time lower bound for Set Cover, even if , and that SAT can be solved in time if and only if Set Cover can be solved in time , see [CDL16]. Some researchers hesitate to rely on SeCoCo as a conjecture, and prefer other, more popular conjectures such as SETH. For example, a running time lower bound for Subset Sum was recently shown [ABHS17] based on SETH, even though a lower bound based on SeCoCo was already known [CDL16].
We address the necessity of SeCoCo by proposing a weaker assumption, and showing an independent justification for it. Our conjecture deals with Set Cover for , as follows.
Conjecture 1.2 (Logarithmic Set Cover Conjecture (LogSeCoCo)).
For every fixed , there is such that no algorithm (even randomized) solves Set Cover in time .
The fastest algorithm known for Set Cover runs in time [Koi09] for , where the inequality assumes , hence this running time is slightly faster than for general Set Cover. All known hardness results that are based on SeCoCo can be based also on our conjecture, with appropriate adjustments related to the set sizes in Set Cover parameterized by the universe size plus the solution size [CDL16] and in Parity of Set Covers [BHH15].
Subgraph Isomorphism with a tree pattern.
The Subgraph Isomorphism problem asks whether a host graph contains a copy of a pattern graph as a subgraph. It is well known to be NPhard since it generalizes hard problems such as Maximum Clique and Hamiltonicity [Kar72], but unlike many natural NPhard problems, it requires time where is the total number of vertices, assuming the exponential time hypothesis (ETH) [CFG16]. Hence, most past research addressed its special cases that are in , including the case where the pattern graph is of constant size [MP14], or when both graphs are trees [AVY15], biconnected outerplanar graphs [Lin89], twoconnected seriesparallel graphs [LP09], and more [DLP00, MT92]. We will focus on a version called kTree, where the pattern is a tree on nodes. In the directed version of the problem, denoted Directed kTree, the edges of and are orientated, allowing also antiparallel edges in ^{1}^{1}1 need not be an arborescence, only its underlying undirected graph is a tree.. Throughout, unless accompanied with the word directed, kTree and nTree refer to their undirected versions. Directed kTree can only be harder than kTree  even when the directed tree is an arborescence, as one can reduce the undirected version to it with only a polynomial loss^{2}^{2}2This could be done in the following way. Define the host graph to be with edges in both directions, and direct the edges in away from an arbitrary vertex to create the directed tree , which is thus an arborescence. Clearly, the directed instance is a yesinstance if and only if the undirected instance also is.. A couple of different techniques were used in order to design algorithms for Directed kTree. The colorcoding method, designed by Alon, Yuster, and Zwick [AYZ95], yields an algorithm with running time . Later, a new method utilized kMLD (stands for Multilinear Monomial Detection – the problem of detecting multilinear monomials of degree in polynomials presented as circuits) to design a Directed kTree algorithm with running time [KW16].
Our Results.
The first result connects our conjecture to the Directed nTree problem (see Figure 1), which is Directed kTree with . This problem includes as a special case the well known Directed Hamiltonicity problem, which asks to determine whether a directed graph contains a simple path (or cycle) that visits all the nodes (the Hamiltonian cycle and path problems are easily reducible to each other with only small overhead). Next, we show that an algorithm that breaks LogSeCoCo implies a fast algorithm for Directed nTree.
Theorem 1.3.
Suppose LogSeCoCo fails, namely, there is such that for every , Set Cover can be solved in time . Then for some , Directed nTree on nodes can be solved in time . This holds even when in Set Cover, every optimal solution is of size and consists of disjoint sets.
In the special case of Directed Hamiltonicity, we actually reduce to rather constrained instances of Set Cover.
Theorem 1.4.
Suppose LogSeCoCo fails, namely, there is such that for every , Set Cover can be solved in time . Then for some , Directed Hamiltonicity on nodes can be solved in time . This holds even when in Set Cover, all sets are of the same size and every optimal solution is of size and consists of disjoint sets.
We can also show that even moderate improvements to the fastest known running time for Set Cover, namely, to the time algorithm of [Koi09], implies improvements for Directed nTree and for Directed Hamiltonicity (Appendix A).
Our next result, whose proof appears in Section 3, shows that the running time of kTree by [KW16] is actually optimal (up to exponential improvements) even when considering the undirected version, assuming SeCoCo or even weaker hypotheses such as LogSeCoCo.
Theorem 1.5.
If for some fixed , kTree can be solved in time , then for some , Set Cover on elements and sets can be solved in time .
In fact, our reduction also works from the more general pPartial Cover problem, whose input is similar to the Set Cover problem but with an additional integer , and the goal is to find the smallest subcollection of sets whose union contains at least elements (rather than all elements). For simplicity, we first present the reduction from Set Cover to kTree (Section 3), and then we show how to adjust it to be from pPartial Cover (Appendix B). Our techniques also yield a new algorithm for the pPartial Cover problem, improving over the previously fastest algorithm which runs in time [Zeh15].
Theorem 1.6.
For every fixed , pPartial Cover can be solved in time .
Observe that an time algorithm for pPartial Cover would violate SeCoCo (because Set Cover is a special case of pPartial Cover with ), hence our algorithm’s running time is almost optimal.
Discussion.
Our first result (Theorem 1.3) supports the validity of LogSeCoCo based on the Directed nTree problem, which we believe does not admit an algorithm with running time , for two reasons. First, this problem includes the wellknown Directed Hamiltonicity problem, and for the last years no algorithm significantly faster than was found for it, despite extensive efforts [Bel60, HK61, Bel62, Woe03], in contrast to the progress on its undirected version [Bjo14]. Second, for the generalization of nTree and kTree variants that is the Subgraph Isomorphism problem, where the pattern graph can be any graph and with any number of nodes, a running time lower bound is known assuming ETH [CFG16], even when the host and pattern graphs have the same number of nodes. We see it as an evidence that also Directed kTree does not become easier as the size of the pattern graph increases all the way to , which would imply that the conditional lower bound in Theorem 1.5 which shows that kTree cannot be solved in time , extends to . If true, then by our results, solving Set Cover significantly faster than is equivalent to achieving the same running time in the special case of Set Cover with , which can be seen as an analogue to the SETH sparsification lemma [IPZ01]. Another interesting consequence of our results is that if kTree can be solved significantly faster than than Directed nTree can be solved significantly faster than . Such kind of reduction from a directed problem to its undirected version is not obvious, even when the latter has the extra freedom in the form of parameterization. See Figure 1 for an overview of new and known reductions, where a problem is above problem implies that there is a path, and a reduction, from to . The following open problem formalizes the above.
Open Problem 1.7.
Does an algorithm for Set Cover with with running time imply an algorithm for Set Cover with running time ?
Perhaps surprisingly, in the special but common case , we can resolve this open problem positively.
Observation 1.8.
If for some constants and , Set Cover with can be solved in time , then for some , Set Cover with can be solved in time .
To see this, simply guess which sets of size larger than participate in an optimal solution, using an exhaustive search over at most choices, and then apply the assumed algorithm for the remaining sets. This leads to a more general observation: if for some increasing function and all , Set Cover can be solved in time then Set Cover with can be solved in time . As also the case can be solved in time (in fact, in time ), the focus should be on the case where is both superpolynomial and subexponential in .
We note that the results can be easily generalized to weighted Directed Hamiltonicity (i.e., TSP) and Directed nTree by using a generalized conjecture about the weighted version of Set Cover, whose input is similar to the Set Cover only with a positive weight for each set, and the goal is to find a minimumweight subcollection whose union is the entire ground set. The generalized conjecture then states that for every fixed , weighted Set Cover with the cardinality of every set bounded by cannot be solved in time .
Prior Work.
Relevant stateoftheart algorithms to Set Cover and Subgraph Isomorphism variants are as follows. Set Cover can be solved in time [BHK09], which for is faster than the aforementioned algorithm of [FKW04]. The case where all sets are of size and the goal is to determine whether pairwisedisjoint sets can be packed, can be solved in time for [BHPK17]. Determining whether a Set Cover instance has a solution of size at most can be done in time [Ned16]. The fastest known running time for Directed Hamiltonicity is [Bjö16]. Finally, several problems, including Directed Hamiltonicity and Set Cover
, were shown to belong to the class EPNL, defined as all problems that can be solved by a nondeterministic turing machine with space
bits [IY15].Techniques.
To demonstrate our basic technique for Theorems 1.3 and 1.4, let us present an extremely simple reduction from Directed Hamiltonicity to Set Cover with . Given a directed graph , first guess (by exhaustive search) a relatively small set of nodes (“representatives”), and an ordering for them in a potential Hamiltonian cycle. Then construct a Set Cover instance whose ground set is the nodes of and has the following sets: for every possible path of length in from some to without visiting any representative in between, there is a set that with all the path nodes except for . A Hamiltonian cycle in clearly corresponds to a set cover using exactly sets, and vice versa. The main challenge we deal with when reducing from the more general Directed nTree is that the pattern tree does not decompose easily into appropriate subgraphs.
The intuition for Theorem 1.5 is as follows. In the reduction from Set Cover to kTree we first guess a partition of (the number of elements) that represents how an optimal solution covers the elements, by exhaustive search over partitions of . Then, we represent the Set Cover instance using a Subgraph Isomorphism instance, whose pattern tree succinctly reflects the guessed partition of , and the idea is that this tree is isomorphic to a subgraph of the Set Cover graph if and only if the Set Cover instance has a solution that agrees with our guess. The main difficulty here is that we reduce to the undirected version of kTree, and thus additional attention is required to make the tree fit only in specific locations in the host graph.
2 Reduction from Directed nTree to Set Cover
In this section we prove Theorem 1.3. The heart of the proof is actually the following lemma.
Lemma 2.1.
For every integer , Directed nTree on nodes can be reduced to instances of Set Cover with elements in time
Proof of Theorem 1.3.
Given an algorithm with runtime for Set Cover on elements and , we reduce the Directed nTree instance by applying Lemma 2.1 with
and then solve each of the instances in the assumed time of
to a total runtime of
which concludes the proof for . ∎
Let us outline the proof of Lemma 2.1. Consider an instance of Directed nTree, and for ease of exposition, assume that the tree is rooted at some node , and all edges are directed away from it; the general case of an arbitrarily directed tree is similar, where subtrees are defined with respect to a designated root vertex, and the edge orientations are taken into account when comparing subtrees. The idea is to create at most instances of Set Cover on elements, such that if at least one of them has a sized solution then the answer to Directed nTree is positive. The first step is to process the tree to create subtrees of it, each of size at most , such that the union of their nodes is and they may intersect only at their roots, which are labeled according to the subtrees they are in. Then, we guess which nodes in are the images of the roots of our subtrees of . For every such choice, we enumerate over every possibility for the intended subtree and add a set to the Set Cover instance being constructed, but only for those that do not violate the global structure of the tree, taking into account the edges between the subtrees. On the one hand, if there exists a solution of size to the Set Cover instance, then there is a one to one correspondence between the sets in the solution and the labeled roots. Hence, such a solution corresponds to a copy of the tree in . On the other hand, if the Directed nTree instance has a solution, then after the tree is partitioned into subtrees as above, we can make all the guesses in correctly.
We begin with an auxiliary lemma that will be used to prove Lemma 2.1.
Lemma 2.2.
There is a polynomialtime algorithm (see Algorithm 1) that given a tree on nodes and an integer , finds a collection of rooted subtrees of such that:

The number of rooted subtrees is .

The number of nodes in each subtree is at most .

Every node in is in some subtree.

Two subtrees may only intersect in their roots.
Note that in the collection returned from Algorithm 1, for every the subgraph of that corresponds to , which we also refer to as , is a connected subtree of and so it has a root which we call .
Lemma 2.3.
The set returned by Algorithm 1 is of size (and item a is satisfied).
Proof.
Denote the collection of sets of size smaller than in (that were added in lines 12 and 15) , and otherwise. Sets in were created only if at the time of their creation was the root of at least one (other) set in (line 12) or was the last traversed node in the DFS search 15. Together with the fact that each root has at most one set from , we conclude that each set excluding at most one, can be associated with a unique set in . (e.g. with one of those containing ).
Hence, is bounded by the . Each set has at least one node, and at most one of its nodes is contained in other sets. We have reached the following equation regarding unique nodes:
and so
which implies
Thus, we get
and the proof of Lemma 2.3 is completed.
∎
Lemma 2.4.
Items b–d are satisfied by the output of Algorithm 1.
Proof.
Since in the worst case we add a subtree in the first time the accumulated number of nodes crossed , the number of nodes of each subtree is bounded by . In addition, every node is in some subtree since for every node , is initiated to , and will be the child node at some point, where it will go up the tree until added to . To see why the last requirement holds, consider the fact that whenever an accumulated set goes up the tree and encounter an existing root, it will be added to rather than continue its path up the tree. ∎
Proof of Lemma 2.1.
We describe the reduction in stages.

Then, we guess nodes in that will function as the image of the nodes in in a potential subgraph isomorphism function and denote them by , and then guess a bijection from to . The guessing is done by exhaustive search over choices of nodes, and together with the number of ways to choose a bijection it can be done in time .

Finally, we enumerate all sets of nodes of size at most in , and denote by the graph induced from each on . For every subtree , we look for an isomorphic copy of in subgraphs that contain as a root and no other node in , and that satisfy . For each one that we found, we add to the constructed Set Cover instance a set with the root labeled where corresponds to the subtree of whose copy found to be in . Note that the number of elements in the Set Cover instance is exactly .
Now we show that the size constraints follow. We bound the number of instances using a factorial bound that is derived from Stirling approximation. As , the number of Set Cover instances is bounded by
as required.
We now prove that at least one of the Set Cover instances has solution of size at most (in fact exactly as no smaller solutions available) if and only if the Directed nTree instance is a yes instance. For the first direction, assume that the Directed nTree instance is a yes instance. Considering the isomorphic copy of in , its subtrees as Algorithm 1 outputs on will be sets in the Set Cover instance the reduction outputs, and so it has a solution of size at most . For the second direction, if a Set Cover instance has a solution of size at most and since the number of labeled roots is , it must be that for each subtree its labeled root is in exactly one set in , and so . Since is a legal solution and covers all the nodes, no node in appears twice in . The conclusion is that these sets together form the required tree, concluding the proof of Lemma 2.1. ∎
We note that in the case of Theorem 1.4 for Directed Hamiltonicity, we do not have to use Algorithm 1, but simply guess representative nodes in and their ordering in the potential cycle, and then enumerate all paths of size to represent paths between consecutive representatives. Hence we obtain a Set Cover instance with the additional constraints of Theorem 1.4.
3 Reduction from Set Cover to kTree
In this section we prove Theorem 1.5. In order to make the proof simpler, we will have an assumption regarding the Set Cover instance, as follows. For a constant to be determined later, we can assume that all the sets in the Set Cover instance are of size at most , as otherwise such instance can already be solved significantly faster than , proving the theorem in a degenerate manner. We formalize it as follows.
Assumption 3.1.
All the sets in the Set Cover instance are of size at most .
To justify this assumption, notice that one can remove all sets of size more than from the Set Cover instance. Indeed, if some optimal solution for the Set Cover instance contains a set of size at least , we can find such optimal solution by simply guessing one set of at least this size (using exhaustive search over at most choices) and then applying the known dynamic programming algorithm on the still uncovered elements (at most of them), and return the optimal solution in total time . We continue to the following lemma, which is the heart of the proof.
Lemma 3.2.
For every fixed , Set Cover on a ground set and a collection of sets that satisfies assumption 3.1, can be reduced to instances of kTree with .
Theorem 1.5 (restated).
If for some fixed , kTree can be solved in time , then for some , Set Cover on elements and sets can be solved in time .
Proof of Theorem 1.5.
Assume that for some , kTree can be solved in time . We reduce the Set Cover instance by applying Lemma 3.2 with , and then solve each of the instances of kTree in the assumed time of , where are the constants implicit in the terms and in the lemma, respectively. The total running time is , which concludes the proof for . ∎
To outline the proof of Lemma 3.2, we will need the following definition. For an integer , let be the set of all unordered partitions of , where a partition of is a way of writing as a sum of positive integers, and unordered means that the order of the summands is insignificant. The asymptotic behaviour of (as tends to infinity) is known [HR18] to be
It is possible to enumerate all the partitions of with constant delay between two consecutive partitions, exclusive of the output [NW78, Chapter 9].
Now the intuition for our reduction of Set Cover to kTree is that we first guess a partition of (the number of elements) that represents how an optimal solution covers the elements, as follows. Associate each element arbitrarily with one of the sets that contain it (so in effect, we assume each element is covered only once) and count how many elements are covered by each set in the optimal solution. This guessing is done by exhaustive search over partitions of . Then, we represent the Set Cover instance using a Subgraph Isomorphism instance, whose pattern tree succinctly reflects the guessed partition of . The idea is that the tree is isomorphic to a subgraph of the Set Cover graph if and only if the Set Cover instance has a solution that agrees with our guess.
Lemma 3.2 (restated).
For every fixed , Set Cover on a ground set and a collection of sets that satisfies assumptions 3.1, can be reduced to instances of kTree with .
Proof of Lemma 3.2.
Given a Set Cover instance on elements and sets and an , we construct instances of kTree as follows. For a constant to be determined later, the host graph is the same for all the instances, and is built on the bipartite graph representation of the Set Cover instance, with some additions. This is done in a way that a constructed tree will fit in if and only if the Set Cover instance has a solution that corresponds to the structure of the tree, as follows (see Figure 2). The set of nodes is , where and . Intuitively, the role of is to keep the size of the trees small by representing multiple vertices in (multiple sets in Set Cover) at once as the "powering" technique for Set Cover done in [CDL16]^{3}^{3}3note that we can slightly simplify this step in the construction by using as a black box the equivalence from [CDL16] between solving Set Cover in time and in time where is the solution size. However, we preferred to reduce directly from Set Cover for compatibility with our parameters and generality reasons., and the role of and is to enforce that the trees we construct will fit only in certain ways.
The set of edges is constructed as follows. Edges between and are the usual bipartite graph representation of Set Cover (i.e., connect vertices and whenever ). We also connect vertex to vertex if at least one of the sets in contains . Additionally, we add edges between and every vertex in , and for , between and for every and , and finally between and every vertex , , and for .
Next, we construct trees such that identifying those that are isomorphic to a subgraph of will determine the optimum of the Set Cover instance.
For every partition (with possible repetitions) where is as defined above, we construct a tree . This tree has the same set of edges and vertices as , except for the vertices in and the edges incident to them, which we replace by a set of new vertices , and connect these new vertices to the rest in a way that the resulting graph is a tree. In more detail, where are tagged copies of the originals, and are initialized to be .
We define to be a partition of which is also a shrinked representation of by partitioning into sums of numbers for a total of such sums, and a remaining of less than numbers. Formally,
Note that all the numbers in are a sum of numbers in , except (maybe) for the last numbers in , a (multi)set which we denote . For every (with possible repetitions) we add a star on vertices to the constructed tree . If , we add the center vertex to , connect it to , and add the rest vertices to . Else, if we add the center vertex to , connect it to , and again add the rest vertices to . We return the minimum cardinality of for which is a yesinstance. To see that this construction is small enough, note that the size of is at most which is polynomial in , and the size of the tree is at most
where the last equality holds for , and so the size constraint follows.
We now prove that at least one of the trees returns yes and satisfies , if and only if the Set Cover instance has a solution of size at most . For the first direction, assume that the Set Cover instance has a solution with . Consider a partition of that corresponds to in the following way. Associate every element with exactly one of the sets in that contains it, and then consider the list of sizes of the sets in according to this association (eliminating zeroes). Clearly, is a yesinstance and so we will return a number that is at most .
For the second direction, assume that every solution to the Set Cover instance is of size at least . We need to prove that for every tree with , is a noinstance. Assume for the contrary that there exists such for which is a yesinstance with the isomorphism function from to . We will show that the only way is feasible is if , , , and also , which together allows us to extract a corresponding solution for the Set Cover instance, leading to a contradiction. We start with the vertex . Since its degree is at least and by Assumption 3.1 and the construction of , it holds that . Moreover, if it was the case that then , however, the degree of and in is , and the degree of the vertices in in is at most , so it must be that . Our next claim is that . Observe that Assumption 3.1 implies that every solution for the Set Cover instance is of size at least and so , which means in the tree has vertices in distance from it and away from , a structural constraint that cannot be satisfied by any vertex in . Furthermore, the degree of is at least and so again by Assumption 3.1 it is also impossible that , and hence it must be that . Finally, by the same Assumption and the degrees of and , and must be in . Altogether, it must be that , and that , and therefore we can extract a feasible solution to the Set Cover instance that has at most sets in it, which is a contradiction, concluding the proof of Lemma 3.2.
∎
Appendix A Moderate Improvements to Set Cover Imply New Algorithms for Directed nTree and Directed Hamiltonicity
In this section we show how moderate improvements for variants of Set Cover imply new algorithms for Directed nTree. Given any algorithm for Set Cover with runtime , by Lemma 2.1 Directed nTree admits an algorithm with running time . We now demonstrate how this algorithm behaves with different regimes of .
If there exists such that for every , then by considering for , Directed nTree has an algorithm with runtime
Considering larger regimes, if for some fixed , , and , then Directed nTree can be solved in time
Note that to break the fastest known algorithm for Directed Hamiltonicity by [Bjö16], it is enough to have either for with every fixed , or for , taking into account that most algorithms for variants of Set Cover that have the factor in their runtime, do not have it with higher power than one.
Appendix B Algorithm and Reduction from pPartial Cover
In this section we prove Theorem 1.6 and using that, we show how to extend Theorem 1.5 be from pPartial Cover. We first prove Theorem 1.6.
Theorem 1.6 (restated).
For every fixed , pPartial Cover can be solved in time .
Proof.
To design an algorithm for pPartial Cover, we reduce it to Directed kTree similarly to Lemma 3.2 with the adjustments ahead, and then apply an algorithm for Directed kTree by [KW16]. First, we simplify Lemma 3.2 by dealing with (directed) rooted trees, as follows. now contains only the nodes and the edges therein, directed away from the root and towards . Note that Assumption 3.1 is not needed here, and that for any chosen the size of is . We proceed to the description of the adjustments.
Instead of enumerating over all the partitions of , we do it only for and hence the number of partitions is with each partition inducing a tree in a similar way to Lemma 3.2, of size at most . From here onwards, the proof of correctness is similar to Lemma 3.2, and thus we omit it. By solving each Directed kTree instance in time using the algorithm of [KW16], where is the constant derived from there such that Directed kTree can be solved in time , and setting for where is the chosen parameter, we get a total running time of
since for , and where is the constant implicit in the term , as required. ∎
As the above proof already implies a reduction from pPartial Cover to directed kTree, we now show that this reduction could also work from pPartial Cover to (undirected) kTree.
Lemma B.1.
For every fixed , pPartial Cover on a ground set and a collection of sets can be reduced to instances of kTree with .
Proof.
Note that Assumption 3.1 adjusted to the pPartial Cover case hold also here, since we can use the algorithm for pPartial Cover described above after removing large sets of size with small enough . ∎
We thus proved the following theorem.
Theorem B.2.
If for some fixed , kTree can be solved in time , then for some , pPartial Cover on elements and sets can be solved in time .
References
 [ABHS17] A. Abboud, K. Bringmann, D. Hermelin, and D. Shabtay. SETHbased lower bounds for subset sum and bicriteria path. CoRR, 2017. Available from: http://arxiv.org/abs/1704.04546.

[AVY15]
A. Abboud, V. VassilevskaWilliams, and H. Yu.
Matching triangles and basing hardness on an extremely popular
conjecture.
In
Proceedings of the Fortyseventh Annual ACM Symposium on Theory of Computing
, STOC ’15, pages 41–50. ACM, 2015. doi:10.1145/2746539.2746594.  [AYZ95] N. Alon, R. Yuster, and U. Zwick. Colorcoding. J. ACM, 42(4):844–856, July 1995. doi:10.1145/210332.210337.
 [Bel60] R. Bellman. Combinatorial processes and dynamic programming. In Combinatorial analysis, Proceedings of symposia in applied mathematics, pages 217–249. American mathematical society, 1960. doi:10.1090/psapm/010.
 [Bel62] R. Bellman. Dynamic programming treatment of the travelling salesman problem. J. ACM, 9(1):61–63, 1962. doi:10.1145/321105.321111.
 [BHH15] A. Björklund, D. Holger, and T. Husfeldt. The parity of set systems under random restrictions with applications to exponential time problems. In 42nd International Colloquium on Automata, Languages and Programming (ICALP 2015), volume 9134, pages 231–242. Springer, 2015. doi:10.1007/9783662476727_19.
 [BHK09] A. Björklund, T. Husfeldt, and M. Koivisto. Set partitioning via inclusionexclusion. SIAM J. Comput., 39(2):546–563, July 2009. doi:10.1137/070683933.
 [BHPK17] A. Björklund, T. Husfeldt, K. Ptteri, and M. Koivisto. Narrow sieves for parameterized paths and packings. Journal of Computer and System Sciences, 87:119 – 139, 2017. doi:10.1016/j.jcss.2017.03.003.
 [Bjo14] A. Bjorklund. Determinant sums for undirected hamiltonicity. SIAM Journal on Computing, 43(1):280–299, 2014. doi:10.1137/110839229.
 [Bjö16] A. Björklund. Below All Subsets for Some Permutational Counting Problems . In 15th Scandinavian Symposium and Workshops on Algorithm Theory (SWAT 2016), volume 53 of Leibniz International Proceedings in Informatics (LIPIcs), pages 17:1–17:11, 2016. doi:10.4230/LIPIcs.SWAT.2016.17.
 [BKK16] A. Björklund, P. Kaski, and Ł. Kowalik. Constrained multilinear detection and generalized graph motifs. Algorithmica, 74(2):947–967, 2016. doi:10.1007/s0045301599811.
 [CDL16] M. Cygan, H. Dell, D. Lokshtanov, D. Marx, J. Nederlof, Y. Okamoto, R. Paturi, S. Saurabh, and M. Wahlström. On problems as hard as CNFSAT. ACM Transactions on Algorithms, 12(3):41:1–41:24, 2016. doi:10.1145/2925416.
 [CFG16] M. Cygan, F. V. Fomin, A. Golovnev, A. S. Kulikov, I. Mihajlin, J. Pachocki, and A. Socała. Tight bounds for graph homomorphism and subgraph isomorphism. In 27th Annual ACMSIAM Symposium on Discrete Algorithms, SODA ’16, pages 1643–1649. SIAM, 2016. doi:10.1137/1.9781611974331.ch112.
 [DLP00] A. Dessmark, A. Lingas, and A. Proskurowski. Faster algorithms for subgraph isomorphism of connected partial trees. Algorithmica, 27(3):337–347, January 2000. doi:10.1007/s004530010023.
 [FKW04] F. V. Fomin, D. Kratsch, and G. J. Woeginger. Exact (exponential) algorithms for the dominating set problem. In 30th International Conference on GraphTheoretic Concepts in Computer Science, WG’04, pages 245–256. SpringerVerlag, 2004. doi:10.1007/9783540305590_21.
 [HK61] M. Held and R. M. Karp. A dynamic programming approach to sequencing problems. In Proceedings of 16th ACM National Meeting, ACM ’61, pages 71.201–71.204. ACM, 1961. doi:10.1145/800029.808532.
 [HR18] G. H. Hardy and S. Ramanujan. Asymptotic formulaæ in combinatory analysis. Proceedings of the London Mathematical Society, s217(1):75–115, 1918. doi:10.1112/plms/s217.1.75.
 [IP01] R. Impagliazzo and R. Paturi. On the complexity of kSAT. Journal of Computer and System Sciences, 62(2):367–375, March 2001. doi:10.1006/jcss.2000.1727.
 [IPZ01] R. Impagliazzo, R. Paturi, and F. Zane. Which problems have strongly exponential complexity? Journal of Computer and System Sciences, 63(4):512–530, 2001. doi:10.1006/jcss.2001.1774.
 [IY15] Y. Iwata and Y. Yoshida. On the equivalence among problems of bounded width. In 23rd Annual European Symposium on Algorithms (ESA 2015), pages 754–765. Springer, 2015. doi:10.1007/9783662483503_63.
 [Kar72] R. M. Karp. Reducibility among Combinatorial Problems, pages 85–103. The IBM Research Symposia Series. Springer US, 1972. doi:10.1007/9781468420012_9.
 [KL16] Ł. Kowalik and J. Lauri. On finding rainbow and colorful paths. Theoretical Computer Science, 628(C):110–114, 2016. doi:10.1016/j.tcs.2016.03.017.
 [Koi09] M. Koivisto. Partitioning into sets of bounded cardinality. In Parameterized and Exact Computation (IWPEC 2009), volume 5917 of Lecture Notes in Computer Science, pages 258–263. SpringerVerlag, 2009. doi:10.1007/9783642112690_21.
 [KST17] R. Krithika, A. Sahu, and P. Tale. Dynamic parameterized problems. In 11th International Symposium on Parameterized and Exact Computation (IPEC 2016), volume 63 of Leibniz International Proceedings in Informatics (LIPIcs), pages 19:1–19:14. Schloss Dagstuhl–LeibnizZentrum fuer Informatik, 2017. doi:10.4230/LIPIcs.IPEC.2016.19.
 [KW16] I. Koutis and R. Williams. LIMITS and applications of group algebras for parameterized problems. ACM Trans. Algorithms, 12(3):31:1–31:18, May 2016. doi:10.1145/2885499.
 [Lin89] A. Lingas. Subgraph isomorphism for biconnected outerplanar graphs in cubic time. Theoretical Computer Science, 63(3):295–302, 1989. doi:10.1016/03043975(89)90011X.
 [LP09] L. Lovász and M. D. Plummer. Matching theory, volume 367. American Mathematical Society, 2009.
 [MP14] D. Marx and M. Pilipczuk. Everything you always wanted to know about the parameterized complexity of Subgraph Isomorphism (but were afraid to ask). In 31st International Symposium on Theoretical Aspects of Computer Science (STACS 2014), volume 25 of Leibniz International Proceedings in Informatics (LIPIcs), pages 542–553. Schloss Dagstuhl–LeibnizZentrum fuer Informatik, 2014. doi:10.4230/LIPIcs.STACS.2014.542.
 [MT92] J. Matoušek and R. Thomas. On the complexity of finding iso and other morphisms for partial trees. Discrete Mathematics, 108(1):343 – 364, 1992. doi:10.1016/0012365X(92)90687B.
 [Ned16] J. Nederlof. Finding large set covers faster via the representation method. In 24th Annual European Symposium on Algorithms (ESA 2016), volume 57 of Leibniz International Proceedings in Informatics (LIPIcs), pages 69:1–69:15. Schloss Dagstuhl–LeibnizZentrum fuer Informatik, 2016. doi:10.4230/LIPIcs.ESA.2016.69.
 [NW78] A. Nijenhuis and H. S. Will. Combinatorial Algorithms: For Computers and Hard Calculators. Academic Press, 2nd edition, 1978.
 [Woe03] G. J. Woeginger. Exact algorithms for NPhard problems: A survey. In M. Jünger, G. Reinelt, and G. Rinaldi, editors, Combinatorial Optimization  Eureka, You Shrink!, pages 185–207. SpringerVerlag, 2003. doi:10.1007/3540364781.
 [Zeh15] M. Zehavi. Mixing color codingrelated techniques. In 23rd Annual European Symposium on Algorithms (ESA 2015), pages 1037–1049. Springer Berlin Heidelberg, 2015. doi:10.1007/9783662483503_86.