Revisiting the Set Cover Conjecture

In the Set Cover problem, the input is a ground set of n elements and a collection of m sets, and the goal is to find the smallest sub-collection of sets whose union is the entire ground set. In spite of extensive effort, the fastest algorithm known for the general case runs in time O(mn2^n) [Fomin et al., WG 2004]. In 2012, as progress seemed to halt, Cygan et al. [TALG 2016] have put forth the Set Cover Conjecture (SeCoCo), which asserts that for every fixed ε>0, no algorithm with runtime 2^(1-ε)n poly(m) can solve Set Cover, even if the input sets are of arbitrary large constant size. We propose a weaker conjecture, which we call Log-SeCoCo, that is similar to SeCoCo but allows input sets of size O( n). To support Log-SeCoCo, we show that its failure implies an algorithm that is faster than currently known for the famous Directed Hamiltonicity problem. Even though Directed Hamiltonicity has been studied extensively for over half a century, no algorithm significantly faster than 2^n poly(n) is known for it. In fact, we show a fine-grained reduction to Log-SeCoCo from a generalization of Directed Hamiltonicity, known as the nTree problem, which too can be solved in time 2^n poly(n) [Koutis and Williams, TALG 2016]. We further show an equivalence between solving the parameterized versions of Set Cover and of nTree significantly faster than their current known runtime. Finally, we show that even moderate runtime improvements for Set Cover with bounded-size sets would imply new algorithms for nTree and for Directed Hamiltonicity. Our technical contribution is to reinforce Log-SeCoCo (and arguably SeCoCo) by reductions from other famous problems with known algorithmic barriers, and hope it will lead to more results in this vein, particularly reinforcing the Strong Exponential-Time Hypothesis (SETH) by reductions from other well-known problems.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

08/12/2020

Tight Bounds on Subexponential Time Approximation of Set Cover and Related Problems

We show that Set Cover on instances with N elements cannot be approximat...
11/02/2018

On subexponential running times for approximating directed Steiner tree and related problems

This paper concerns proving almost tight (super-polynomial) running time...
02/25/2020

Dynamic Set Cover: Improved Amortized and Worst-Case Update Time

In the dynamic minimum set cover problem, a challenge is to minimize the...
09/06/2020

On Hardness of Approximation of Parameterized Set Cover and Label Cover: Threshold Graphs from Error Correcting Codes

In the (k,h)-SetCover problem, we are given a collection 𝒮 of sets over ...
05/14/2021

Fully Dynamic Set Cover via Hypergraph Maximal Matching: An Optimal Approximation Through a Local Approach

In the (fully) dynamic set cover problem, we have a collection of m sets...
02/22/2018

Complexity of the Steiner Network Problem with Respect to the Number of Terminals

In the Directed Steiner Network problem we are given an arc-weighted dig...
06/15/2021

Learning-based Support Estimation in Sublinear Time

We consider the problem of estimating the number of distinct elements in...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Set Cover and Subgraph Isomorphism are two of the most well-researched 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 sub-collection of sets whose union is the entire ground set. An exhaustive search takes time, and a dynamic-programming 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 SETH-based 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 (Log-SeCoCo)).

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 NP-hard since it generalizes hard problems such as Maximum Clique and Hamiltonicity [Kar72], but unlike many natural NP-hard 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], two-connected series-parallel 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 anti-parallel edges in 111 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 loss222This 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 yes-instance 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 color-coding 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 Log-SeCoCo implies a fast algorithm for Directed nTree.

Theorem 1.3.

Suppose Log-SeCoCo 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 Log-SeCoCo 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).

Figure 1: An arrow from a box with to represents a reduction from problem to problem , such that if can be solved in time then can be solved in time . We denote by the size of the solution in Steiner Tree, and by the number of bits required to represent the integers in Subset Sum. The problems we focus on are drawn in thick frames.

 

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 Log-SeCoCo.

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 p-Partial Cover problem, whose input is similar to the Set Cover problem but with an additional integer , and the goal is to find the smallest sub-collection 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 p-Partial Cover (Appendix B). Our techniques also yield a new algorithm for the p-Partial Cover problem, improving over the previously fastest algorithm which runs in time  [Zeh15].

Theorem 1.6.

For every fixed , p-Partial Cover can be solved in time .

Observe that an -time algorithm for p-Partial Cover would violate SeCoCo (because Set Cover is a special case of p-Partial Cover with ), hence our algorithm’s running time is almost optimal.

Discussion.

Our first result (Theorem 1.3) supports the validity of Log-SeCoCo 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 well-known 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 super-polynomial and sub-exponential 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 minimum-weight sub-collection 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 state-of-the-art 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 pairwise-disjoint 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 non-deterministic 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 polynomial-time algorithm (see Algorithm 1) that given a tree on nodes and an integer , finds a collection of rooted subtrees of such that:

  1. The number of rooted subtrees is .

  2. The number of nodes in each subtree is at most .

  3. Every node in is in some subtree.

  4. Two subtrees may only intersect in their roots.

1:a tree rooted at , a size parameter
2:a partition of into subtrees of size at most , two of which may intersect only in their roots.
3:initialize , and for all let .
4:traverse the tree using a search starting from , and whenever returning from a node with a parent in , do the following:
5:let .
6:if  then
7:     add to .
8:     if  has uncovered children then
9:         let .
10:     else      
11:else if  and does not have uncovered children and for some  then
12:     add to .
13:     let
14:else if  and does not have uncovered children and for every  then
15:     add to . is the last node traversed in the tree return
Algorithm 1

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.

  • We apply the aforementioned Algorithm 1 for partition into subtrees that satisfy the conditions in Lemma 2.2. By picking , we obtain that each set is bounded by and that . Hence, the cardinality of is bounded by . For returned by Algorithm 1, let (note that may be smaller than ).

  • 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 .

We will use this lemma to prove Theorem  1.5, the proof of Lemma 3.2 will be given after.

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]333note 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 .

Figure 2: An illustration of part of the reduction. The Set Cover instance is depicted in blue, and sets of vertices are indicated by dashed curves.

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 yes-instance. 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 yes-instance 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 no-instance. Assume for the contrary that there exists such for which is a yes-instance 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 p-Partial Cover

In this section we prove Theorem 1.6 and using that, we show how to extend Theorem 1.5 be from p-Partial Cover. We first prove Theorem 1.6.

Theorem 1.6 (restated).

For every fixed , p-Partial Cover can be solved in time .

Proof.

To design an algorithm for p-Partial 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 p-Partial Cover to directed kTree, we now show that this reduction could also work from p-Partial Cover to (undirected) kTree.

Lemma B.1.

For every fixed , p-Partial 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 p-Partial Cover case hold also here, since we can use the algorithm for p-Partial 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 , p-Partial Cover on elements and sets can be solved in time .

References

  • [ABHS17] A. Abboud, K. Bringmann, D. Hermelin, and D. Shabtay. SETH-based lower bounds for subset sum and bicriteria path. CoRR, 2017. Available from: http://arxiv.org/abs/1704.04546.
  • [AVY15] A. Abboud, V. Vassilevska-Williams, and H. Yu. Matching triangles and basing hardness on an extremely popular conjecture. In

    Proceedings of the Forty-seventh 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. Color-coding. 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/978-3-662-47672-7_19.
  • [BHK09] A. Björklund, T. Husfeldt, and M. Koivisto. Set partitioning via inclusion-exclusion. 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/s00453-015-9981-1.
  • [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 CNF-SAT. 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 ACM-SIAM 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 Graph-Theoretic Concepts in Computer Science, WG’04, pages 245–256. Springer-Verlag, 2004. doi:10.1007/978-3-540-30559-0_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, s2-17(1):75–115, 1918. doi:10.1112/plms/s2-17.1.75.
  • [IP01] R. Impagliazzo and R. Paturi. On the complexity of k-SAT. 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/978-3-662-48350-3_63.
  • [Kar72] R. M. Karp. Reducibility among Combinatorial Problems, pages 85–103. The IBM Research Symposia Series. Springer US, 1972. doi:10.1007/978-1-4684-2001-2_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. Springer-Verlag, 2009. doi:10.1007/978-3-642-11269-0_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–Leibniz-Zentrum 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/0304-3975(89)90011-X.
  • [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–Leibniz-Zentrum 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/0012-365X(92)90687-B.
  • [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–Leibniz-Zentrum 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 NP-hard problems: A survey. In M. Jünger, G. Reinelt, and G. Rinaldi, editors, Combinatorial Optimization - Eureka, You Shrink!, pages 185–207. Springer-Verlag, 2003. doi:10.1007/3-540-36478-1.
  • [Zeh15] M. Zehavi. Mixing color coding-related techniques. In 23rd Annual European Symposium on Algorithms (ESA 2015), pages 1037–1049. Springer Berlin Heidelberg, 2015. doi:10.1007/978-3-662-48350-3_86.