Implications of the Exponential Time Hypothesis

Anant Dhayal May 14, 2018

Abstract The Exponential Time Hypothesis (ETH) [14] states that for k ≥ 3, k-SAT doesn’t δn have a sub-exponential time algorithm. Let sk = inf{δ | ∃ 2 time algorithm for solving k-SAT}, then ETH is equivalent to s3 > 0. Strong ETH (SETH) [13] is a stronger conjecture which states that lim sk = 1. k→∞ In this report we survey lower bounds based on ETH. We describe a reduction from k-SAT to NP-complete CSP’s [5]. In particular this implies that no NP-complete CSP has a sub-exponential time algorithm. We also survey lower bounds implied by SETH.

1 Introduction

CNF-SAT is the canonical NP-complete problem [9, 17]. A literal is a boolean variable or its negation, and a clause is a disjunction of literals. The input of CNF-SAT is a boolean formula in conjunctive normal form (CNF), i.e., conjunction of clauses. The goal is to check if there is an assignment to the variables which satisfies all the clauses. k-SAT is a special case of CNF-SAT where the clause width (the number of literals in a clause) is bounded by the constant k. When k = 2 the problem has a polynomial time algorithm. However for k ≥ 3 it is proved to be NP-complete [9, 17], hence there is no polynomial time algorithm unless P = NP. When k ≥ 4 there is a simple clause width reduction from k-SAT to (k−1)-SAT wherein we replace a k-clause (x1 ∨x2 ∨...∨xk) by two clauses (x1 ∨x2 ∨...∨xk−2 ∨y)∧(xk−1 ∨xk ∨y) by introducing a new variable y. Unfortunately this reduction doesn’t work for k = 3. Hereafter let’s assume k ≥ 3. The best known algorithm for k-SAT runs in exponential time [20]. One of the central goals of complexity theory is to figure out whether k-SAT has a sub-exponential time algorithm. To study this let us define the time complexity class sub-exponential (SE). Definition 1 (SE: Sub-exponential time complexity). Let P be a decision problem and m be a parameter function defined on the input space of P. The tuple (P, m) belongs to the complexity class SE if for every > 0, and for every input x, there is a deterministic algorithm which runs in time O(poly(|x|)2m(x)). Let n denote the number of variables (vertices) and m denote the number of clauses (edges) in a CNF formula (graph). We abuse notation to write k-SAT ∈ SE to mean (k- SAT,n) ∈ SE. Similarly for any graph problem P we write P ∈ SE to mean (P, n) ∈ SE.

1 Two natural questions to consider are:

1. What role does the parameter k play in terms of inclusion of k-SAT in SE? What implications will a sub-exponential time algorithm for 3-SAT have on k-SAT for k ≥ 4?

2. What role does the parameter n play? Does changing the parameter from n to m place k-SAT in SE? Or does the existence of a sub-exponential time algorithm in the latter case also imply the existence of a sub-exponential time algorithm in the former case?

The Sparsiﬁcation Lemma (subsection 1.1) answers the above questions. This helped establish connections between complexity of many natural problems (across natural parameters). These connections motivated a stronger conjecture than “P 6= NP”, namely ETH (subsection 1.2).

1.1 SERF Reductions and the Sparsification Lemma Sparse-k-SAT is a special case of k-SAT where the number of clauses is a linear function of the number of variables. Note that (sparse-k-SAT,m) ∈ SE is equivalent to (sparse-k-SAT,n) ∈ SE. The Sparsification Lemma [14] shows that a sub-exponential time algorithm for sparse- k-SAT implies a sub-exponential time algorithm for k-SAT. This proves that (k-SAT,m) ∈ SE if and only if (k-SAT,n) ∈ SE. Any reduction in the standard “P vs NP” theory needs to preserve polynomial time complexity. To reduce problem A to problem B, one needs to give a polynomial time algorithm that solves problem B given oracle access to problem A. In this paper we look at reductions which preserve sub-exponential time complexity. These reductions are different from polynomial-time preserving reductions in the following ways:

1. The output parameter of the reduction should be a linear function (instead of a polynomial function) of the input parameter.

2. The reduction can run in sub-exponential time (instead of polynomial time) in the input parameter.

Let us deﬁne this formally.

Deﬁnition 2 (SERF: Sub-exponential Reduction Family). A SERF reduction from (P1, m1) to (P2, m2) is a collection of reductions from P1 to P2. For every > 0 the collection has a m1(x) Turing reduction R, that runs in time O(poly(|x|)2 ) on an input x and makes queries {y1, . . . , yl} to P2. The reduction computes R(x) which satisﬁes the following conditions:

• l ∈ O(poly(|x|)2m1(x)) (implied by running time),

• x ∈ P1 ⇐⇒ R(x) = 1,

•∀ i m2(yi) ∈ O(m1(x)).

We say that (P1, m1) SERF reduces to (P2, m2).

2 We say that (P1, m1) and (P2, m2) are SERF equivalent if (P1, m1) SERF reduces to (P2, m2) and (P2, m2) SERF reduces to (P1, m1). For the special case of k-SAT (graph problem) we omit the parameter when it is the number of variables (vertices). Fact 1. [14] Two useful properties of SERF reductions are:

1. SERF reductions are SE time preserving. That is, if (P1, m1) SERF reduces to (P2, m2) and (P2, m2) ∈SE, then (P1, m1) ∈ SE.

2. Transitivity: If (P1, m1) SERF reduces to (P2, m2) and (P2, m2) SERF reduces to (P3, m3), then (P1, m1) SERF reduces to (P3, m3). Now we are in a position to formalize the Sparsification Lemma. Theorem 1 (Sparsification Lemma [14]). There is an algorithm Sparse(k, ), that takes as input a k-SAT formula x and an > 0. It runs in time O(poly(|x|2n) and outputs a set of k-SAT instances {x1, . . . , xl} which satisfy the following conditions: • l ∈ O(poly(|x|)2n), W • x is satisfiable ⇐⇒ [xi is satisifable], i

•∀ i mi ≤ c(k, )n, where mi is the number of clauses in xi and c(k, ) is a constant independent of n. Having deﬁned this we are in a position to answer the questions posed earlier. The Spar- siﬁcation Lemma addresses the latter question, that is the parameters n and m are equivalent as far as inclusion of k-SAT in SE is concerned (fact 1.1). To answer the former question we consider a reduction that takes as input a k-SAT formula and outputs 3-SAT formulae. The reduction comprises of two steps - Sparse(k, ) followed by clause width reduction. The clause width reduction adds a new variable for each input clause. Since the output formulae of Sparse(k, ) are sparse, we only need to add linearly many new variables in each 3-SAT formula instead of O(nk) variables. This gives a SERF reduction from k-SAT to 3-SAT (fact 1.2).

1.2 ETH and SETH Due to the Sparsiﬁcation Lemma existence of a sub-exponential time algorithm is equivalent for the following problems: • k-SAT • Sparse-k-SAT • NP-complete problems that are SERF equivalent to k-SAT For some of the above problems, clever algorithms with time complexity exponentially better than brute-force search have been designed. However, there has been no substantial improvement in the time complexity in the past few years. The algorithmic paradigms used presently have failed to improve the running time to sub-exponential time for the problems. This has lead us to conjecture exponential time hypothesis (ETH).

3 Conjecture 1 (ETH: Exponential Time Hypothesis). k-SAT doesn’t belong to SE.

The CNF-SAT problem is non-trivial because the set of variables in one clause intersects with the sets of variables in other clauses. This results in a correlation between the satisfia- bility of two clauses. Thus the task of finding a satisfying assignment becomes difficult. The (1− c )n best known algorithm for k-SAT [20] runs in time O(2 k ), where c is a constant independent of n. This algorithm exploits the structure of k-SAT which results in considerable saving (compared to brute-force) for small k. However, the saving falls quickly as the value of k increases. There has been no further progress in the past two decades to remove (change) the dependence on k. Based on the saving patterns discussed above, a stronger conjecture can be formulated. δn Let sk = inf{δ | ∃ 2 time algorithm for solving k-SAT} and let s∞ = limk→∞ sk. In [13] it was proved that sk ≤ (1 − d/k)s∞ for d > 0, independent of k. This equation along with ETH (s3 > 0) implies that the series {sk}k≥3 is increasing infinitely often. This equation also shows that any improvement in the time complexity of CNF-SAT will decrease the sk values. This in turn suggests an improvement in the time complexity of k-SAT. However, the improvement in the time complexity does not seem possible, as discussed above. This motivated the formulation of a stronger conjecture – Strong ETH (SETH).

Conjecture 2 (SETH: Strong Exponential Time Hypothesis). For every > 0 there exists (1−)n a k such that k-SAT can’t be solved in time less than O(2 ) , that is s∞ = 1. It also implies that for any > 0 CNF-SAT has no algorithm that runs in time O(2(1−)n).

SETH is stronger than ETH because failure of ETH implies failure of SETH as the series {sk}k≥3 will contain only zeros. On the other hand, if ETH is true, we don’t have any proof of SETH. For example, it might be possible that s3 = 0.1 and s∞ = 0.9.

1.3 Structure of the Paper In this paper our main focus will be on the implications of ETH and SETH. In particular, we will discuss reductions from k-SAT and CNF-SAT to a set of natural problems. A reduction from k-SAT (CNF-SAT) to a problem P can be seen in two diﬀerent ways:

1. (Evidence of a lower bound) If ETH (SETH) is true then we get a lower bound for P.

2. (Improved SAT algorithm) If we a design a better algorithm for P then ETH (SETH) fails and we get a better algorithm for k-SAT (CNF-SAT).

In section 2 we discuss reductions from k-SAT to other problems. k-SAT can also be formulated as a constraint satisfaction problem (CSP). CSP’s form an important sub-class of NP. In section 3 we deﬁne CSP’s and their basic properties. We also present the Dichotomy Theorem [6, 25], which characterizes all CSP’s that are NP-complete. This was proved via a reduction from k-SAT in [5]. In section 4 we discuss this reduction and its implications in full detail. In section 5 we discuss ﬁne grained reductions from CNF-SAT to some well-studied polynomial time problems. We conclude in section 6 by discussing possible future directions.

4 2 Implications of ETH k-SAT is one of the first problems proven to be NP-complete [9, 17] and “reducing from k-SAT” is one important tool used in NP-hardness proofs of many problems. One straight- forward implication of ETH is that no NP-hard problem has a npoly(log n) (quasi-polynomial) time algorithm. Note that P 6= NP doesn’t exclude this possibility. For many natural problems the classical reductions given in the “P vs NP” literature are SERF. This excludes the possibility of a sub-exponential time algorithm for these problems. In this section we state some of these reductions. We give full details of a reduction for helping the reader to develop a contrast between the two notions – polynomial-time reductions and SERF reductions. We also state one other reduction which has implications of slightly different flavor. Note that this is a far from exhaustive list of SERF reductions from k-SAT.

Deﬁnition 3 (k-Hitting Set). The input is a collection S of k-sets of a universe U, and a number l. A hitting-set of S is a set S ⊆ U such that T ∈ S implies S ∩ T 6= φ. The goal is to check if there exists a hitting-set of S of size l.

Lemma 1. k-SAT SERF reduces to (k-Hitting Set, |U|).

Proof. For a k-SAT instance on n variables the reduction outputs an instance of k-Hitting Set where l = n and the universe U contains the 2n literals. For each variable x, S contains {x, x}, and for each clause C, S contains the set of all literals in C. From a satisfying assignment of the k-SAT instance we can construct a hitting-set S of size n. S contains x if x is set to true. S contains x if x is set to false. Since each clause C has a true literal, and S contains all true literals, the intersection of S with the set corresponding to C is non-empty. Construction of S ensures that the intersection of S with any set corresponding to a variable x is non-empty. From a hitting-set S of size n we can construct a satisfying assignment of the k-SAT instance. Since {x, x} ∈ S for each variable x, any hitting-set of size n should contain exactly one of x and x. If x ∈ S then set x to true. If x ∈ S then set x to false. In this assignment each clause has atleast one true literal because S intersects with all the sets in S that correspond to a clause.

Corollary 1. ETH implies that (k-Hitting Set, |U|) doesn’t belong to SE. Role of the Sparsiﬁcation Lemma: A typical reduction from k-SAT to a graph problem outputs vertex set whose size is a linear function of the number of clauses in the input. Sparsiﬁcation Lemma allows us to start any reduction with sparse-k-SAT formula. In this case the size of the vertex set becomes a linear function of the number of variables and thus ETH implies tighter lower bounds. When compared to the earlier lower bounds, these lower bounds are substantially closer to the known upper bounds. For example, if we start with a formula of n2 clauses then the output graph contains O(n2) vertices. An O(2|V |0.5 ) time algorithm doesn’t refute ETH in this case. Whereas starting with a sparse formula removes the possibility of an O(2|V |0.99 ) time algorithm, assuming ETH.

Deﬁnition 4 (Independent Set). Input is an undirected graph G(V,E) and a number k ∈ [n]. The goal is to ﬁnd S ⊆ V of size k such that u, v ∈ S implies (u, v) ∈/ E.

5 Deﬁnition 5 (Clique). Input is an undirected graph G(V,E) and a number k ∈ [n]. The goal is to ﬁnd S ⊆ V of size k such that u, v ∈ S and u 6= v implies (u, v) ∈ E.

Deﬁnition 6 (k-Coloring). Input is an undirected graph G(V,E). The goal is to ﬁnd a mapping φ : V → [k] such that (u, v) ∈ E implies φ(u) 6= φ(v).

Deﬁnition 7 (Vertex Cover). Input is an undirected graph G(V,E) and a number k ∈ [n]. The goal is to ﬁnd S ⊆ V of size k such that (u, v) ∈ E and u∈ / S implies v ∈ S.

Deﬁnition 8 (Hamiltonian Circuit). Input is an undirected graph G(V,E). The goal is to ﬁnd a cycle which visits each vertex exactly once.

Lemma 2. [11] Sparse-k-SAT SERF reduces to Independent Set, Clique, k-Coloring, Vertex Cover and Hamiltonian Circuit. Corollary 2. ETH implies that Independent Set, Clique, k-Coloring, Vertex Cover and Hamiltonian Circuit doesn’t belong to SE. The most obvious brute-force algorithm for Clique is – for each subset of V check whether it forms a clique (complete sub-graph). This algorithm takes O(n22n) time. Corollary 2 implies that there is no algorithm for Clique that runs in time 2o(n), for all values of k, unless ETH fails. If we use a slightly diﬀerent brute-force algorithm where we only consider k+2 n subsets of size k, we get an O(n ) run time. For the case k ∈ o( log n ) this runs in time 2o(n). The next lemma gives a better lower-bound for such restricted cases. Lemma 3 (Theorem 5.7 of [8]). Let µ(n) be a non-decreasing and unbounded function which satisﬁes µ(2n) ≤ 2µ(n) and µ(n) ≤ n for 0 < < 1. ETH implies that Clique and Independent Set with the restriction k ∈ Θ(µ(n)) doesn’t have a no(k)-time algorithm.

3 Basics of CSP’s and the Dichotomy Theorem

In this section we take a brief digression from ETH based lower-bounds and discuss the basics of a very widely studied sub-class of NP, called CSP’s. Later in section 4 we use these basics to describe ETH based lower-bounds for NP-complete CSP’s. In subsection 3.1 we give the formal deﬁnition of CSP’s. In subsection 3.2 we deﬁne universal algebra and its few special types. In subsection 3.3 we describe some connections between CSP’s and universal algebras. In subsection 3.4 we describe the Dichotomy Theorem using these connections. In this entire section we borrow the terminology from [5].

3.1 Relations and CSP’s Deﬁnition 9 (Relation). For set D, any ρ ⊆ Dk is called k-ary relation over D.

For example, {(a, a) | a ∈ D} is a binary relation over the set D. This is denoted by =D. RD denotes the set of ﬁnitary relations over D.

Deﬁnition 10 (Constraint Language). Any Γ ⊆ RD is called constraint language. We say that D is the domain of Γ.

6 In this paper we only talk about ﬁnite domain constraint languages.

Deﬁnition 11 (Constraint). A k-ary constraint C deﬁned over a variable set V is a pair hs, ρi where:

• ρ is a k-ary relation over D known as constraint relation.

k • s = (s1, s2, . . . , sk) ⊆ V is known as constraint scope.

φ : V → D is the satisfying assignment of C if the tuple (φ(s1), φ(s2), . . . , φ(sk)) is an element of ρ. We also say “φ satisﬁes C” or “C is satisﬁed by φ”.

Deﬁnition 12 (Constraint Satisfaction Problem or CSP). For constraint language Γ over domain D, CSP(Γ) is the following decision problem:

• Input instance: The triple (V,D, C), where V is a variable set and C is a set of ﬁnitary constraints over V whose constraint relations are elements of Γ.

• Output: “Yes” if there exists φ : V → D which satisﬁes all the constraints in C. Otherwise “No”.

In context of CSP’s: let n denote the number of variables, m denote the number of constraints and the preﬁx ‘sparse’ denote that m ∈ O(n). We abuse the notation to write CSP(Γ) ∈ SE to mean (CSP(Γ),n) ∈ SE, and write “CSP(Γ) SERF reduces to CSP(∆)” to mean “(CSP(Γ), n) SERF reduces to (CSP(∆), n)”.

l k-SAT as a CSP: k-SAT can be viewed as CSP(∪l≤kSl) where Sl = {{0, 1} \{s} | s ∈ {0, 1}l}. An l-ary clause has a corresponding l-ary constraint – which restricts its constraint scope from attaining exactly one l-tuple. For example, the constraint corresponding to the clause (x1 ∨ x2 ∨ ... ∨ xl) doesn’t allow (x1, x2, . . . , xl) to attain (0, 0,..., 0) in any satisfying assignment that might exist.

Definition 13 (Relational clone). Primitive positive (pp) formulae are first-order formulae that involve only conjunction and existential quantification. A constraint language Γ ⊆ RD is called a relational clone if it contains every relation expressible by a pp-formula involving relations from Γ ∪ {=D}. For any constraint language Γ there is a unique smallest relational clone that contains Γ. It is denoted by hΓi. It consists of all relations expressible by pp- formulae over the relations in the set Γ ∪ {=D}. Lemma 4. [15] Let Γ be a constraint language. Then for any finite ∆ ⊆ hΓi, CSP(∆) reduces to CSP(Γ) in polynomial time.

Proof. Let ∆ = {ρ1, . . . , ρl}, where ρi is a relation over some set D. Any relation in hΓi is expressible by a pp-formula involving relations from R = [Γ ∪ {=D}]. An instance (V,D, C) of CSP(∆) can be reduced to an instance of CSP(R) by the following transformations. 1 1 Pick all hs, ρi ∈ C. Let s = (x1, . . . , xt) and ρ(x1, . . . , xt) = ∃y1, . . . , yn(r1(z1, . . . , zt1 ) ∧ m m 1 1 m m ... ∧ rm(z1 , . . . , ztm )). Here each ri is a relation from R and z1, . . . , zt1 , . . . , z1 , . . . , ztm ∈ {x1, . . . , xt, y1, . . . , yn}. Do the following:

7 1. V = V ∪ {y1, . . . , yn} (renaming if needed)

1 1 m m 2. C = C ∪ {h(z1, . . . , zt1 ), r1i,..., h(z1 , . . . , ztm ), rmi} 3. C = C \ hs, ρi For reducing this instance of CSP(R) to CSP(Γ) we only have to remove the constraints of the form h(x1, x2), =Di. This can be done by replacing any occurrence of x1 by x2. Corollary 3. Let Γ be a constraint language. Then for any ﬁnite ∆ ⊆ hΓi, sparse-CSP(∆) SERF reduces to sparse-CSP(Γ). Proof. In the reduction of lemma 4 the number of constraints is only multiplied by a constant. So if we start with an instance of sparse-CSP(∆) the output of the reduction will be an instance of sparse-CSP(Γ). This is a SERF reduction as the number of new variables is linear in the number of original variables plus the number of original constraints.

3.2 Operations and Algebras Deﬁnition 14 (Operation). A k-ary operation f over a set D is a mapping from Dk to D.

OD denotes the set of ﬁnitary operations over D. Following is a list of few special types of operations:

1. Idempotent: An operation f ∈ OD is called idempotent if it satisfies f(x, . . . , x) = x for all x ∈ D. 2. Essentially unary: An operation f : Dn → D is called essentially unary if there exists a (nonconstant) unary operation g : D → D and an index i ∈ {1, 2, . . . , n} such that f(d1, d2, . . . , dn) = g(di) for all choices of d1, d2, . . . , dn. 3. Projection: In the above definition of essentially unary operation if g is the identity operation, then f is called a projection. Definition 15 (Algebra). An algebra is an ordered pair A = (D,F ) where: • D is a nonempty set called the universe of A.

• F ⊆ OD is called the basic operations of A. Definition 16 (Composition of Operations). Composition of an n-ary operations f with a n- set of k-ary operations {g1, g2, . . . , gn} is the k-ary operation h, defined by h(d1, d2, . . . , dk) = f(g1(d1, . . . , dk), . . . , gn(d1, . . . , dk)). Definition 17 (Term Operations). For any algebra A = (D,F ) the set of all operations that can be obtained from the operations in F and the set of all finitary projection operations, by forming arbitrary compositions, is called the term operations of A. It is denoted by T erm(A). Following is a list of few special types of algebras: 1. Finite: An algebra over a finite universe. 2. Surjective: An algebra whose term operations are surjective. 3. Idempotent: An algebra whose term operations are idempotent. In this paper we only look at finite algebras.

8 3.3 Relational Cones vs Term Operations

Deﬁnition 18 (Polymorphism). An m-ary operation f ∈ OD is a polymorphism of an n-ary relation ρ ∈ RD if f(d1, . . . , dm) ∈ ρ for all d1, . . . , dm ∈ ρ, where f is applied co-ordinate wise on the input tuples. We say “f preserves ρ” or “ρ is invariant under f”.

For a Γ ⊆ RD and a F ⊆ OD:

• P ol(Γ) = {f ∈ OD | f preserves each relation in Γ}.

• Inv(F ) = {ρ ∈ RD | ρ is invariant under each operation in F }. Fact 2. [12] Following are some connections between term operations and relational cones:

1. For algebra A = (D,F ), P ol(Inv(F )) = T erm(A).

2. For constraint language Γ, Inv(P ol(Γ)) = hΓi.

3. For relational cone hΓi ⊆ RD there exists an F ⊆ OD that satisﬁes Inv(F ) = hΓi.

4. For F ⊆ OD the set Inv(F ) is a relational clone.

3.4 Tractability of CSP’s and the Dichotomy Theorem The Dichotomy Theorem states that a CSP is etiher in P or is NP-complete. In 1978 Schaefer proved the Dichotomy Theorem [21] for boolean CSP’s. The classification was based on the properties of the constraint languages. For CSP’s over larger domains the properties of the relations didn’t seem to to provide a clear classification. This lead to the study of the properties of the algebras associated with the constraint languages. In lemma 4 and corollary 3 we saw how a constraint language Γ is related to the relational clone hΓi. Fact 2 provides an alternate perspective of hΓi, which is, the set of operations F that satisfy Inv(F ) = hΓi. Twenty nine years after the establishment of the boolean Dichotomy Theorem, in 2017 Bulatov [6] and Zhuk [25] used this dual perspective to successfully classify the constraint languages of the higher domain. [7] contains a biref survey of the history of the Dichotomy Theorem. Let us formally define the notion of tractability and hardness for CSP’s.

Deﬁnition 19 (Tractability of CSP’s). In general, by tractability we mean solvability in polynomial time. Following is a list of diﬀerent representations of CSP’s and the corresponding notions of tractability.

1. A ﬁnite constraint language Γ ⊆ RA tractable (NP-complete) if the corresponding CSP(Γ) is tractable (NP-complete).

2. An infinite constraint language Γ ⊆ RA is tractable (NP-complete) if all of its finite subsets are tractable (it has a NP-complete finite subset).

3. For F ⊆ OA, CSP(F ) denotes CSP(Inv(F )). F is tractable (NP-complete) if the corresponding CSP(F ) is tractable (NP-complete).

9 4. For A = (A, F ), CSP(A) denotes CSP(Inv(F )). A is tractable (NP-complete) if the corresponding CSP(A) is tractable (NP-complete).

Let us first define some special types of algebras. Then using these definitions we describe the Dichotomy Theorem. Let g|U denote the restriction of g to U, where g ⊆ OA and U ⊆ A.

Deﬁnition 20 (Term Induced Algebra). Let A = (A, F ) then Term(A)|U = {g|U : g ∈ Term(A) and g preserves U}. The algebra A|U = (U, Term(A)|U ) is a term induced algebra of A.

Deﬁnition 21 (Full Idempotent Reduct). The full idempotent reduct of an algebra A = (A, F ) is the algebra (A, Termid(A)), where Termid(A) consists of all idempotent operations in Term(A).

Deﬁnition 22 (Subalgebra). Let A = (A, F ) and B ⊆ A. If for all n, for all n-arity functions f ∈ F , for all b1, . . . , bn ∈ B, f(b1, . . . , bn) ∈ B, then B = (B,F |B) is a subalgebra of A, where F |B = {f|B | f ∈ F }. Note that a subalgebra is also a term induced algebra. Whereas a term induced algebra is a subalgebra only when all the original operations preserve the subset of the domain on which the term induced algebra is deﬁned.

Deﬁnition 23 (Homomorphic Image). Let A1 = (A1,F1) and A2 = (A2,F2), where F1 = i i {f1 | i ∈ I} and F2 = {f2 | i ∈ I}. A map φ : A1 → A2 is called a homomorphism from A1 i i i to A2 if for all i ∈ I, φf1(a1 . . . , ani ) = f2(φ(a1), . . . , φ(ani )), where ni is the arity of both f1 i and f2. If φ is surjective then A2 is called a homomorphic image of A1. Deﬁnition 24 (Factor of an Algebra). A homomorphic image of a subalgebra of an algebra A is called a factor of A. A factor of size one universe is called a trivial factor.

Theorem 2 (Dichotomy Theorem). [6, 25] A ﬁnite idempotent algebra A is NP-complete if it has a nontrivial factor B all of whose operations are projections. Otherwise it is tractable.

The next corollary shows why the above theorem is stated in terms of idempotent algebras.

Corollary 4. If a constraint language ∆ ⊆ RA is NP-complete then: 1. (Deﬁnition 19) There exists a ﬁnite NP-complete constraint language Λ ⊆ ∆.

2. (Fact 2) There exists A = (A, F ) such that Inv(F ) = hΛi.

3. (Theorem 4.4 of [5]) There exists a unary term operation f over S ⊆ A, and the S corresponding term reduced algebra A|S = (S, T erm(A)|S) (denoted by A = (S,FS)) is surjective and NP-complete.

S I 4. (Theorem 4.7 of [5]) A ’s full idempotent reduct A = (S,FI ) is NP-complete.

5. (Corollary 7.3 of [5]) AI has a non-trivial factor B = (B,FB) whose term operations are projections.

10 4 Lower Bounds for NP-complete CSP’s

In this section we describe a SERF reduction from sparse-k-SAT to sparse-CSP(∆) for constraint language ∆ satisfying the hardness condition of the Dichotomy Theorem (corollary 4). Since ETH implies that sparse-k-SAT is not in SE this reduction implies that sparse-CSP(∆) is not in SE. We use the conditions stated in corollary 4 (in reverse order) to describe a chain of SERF reductions (subsections 4.1,4.2,4.3,4.4,4.5) from sparse-k-SAT to sparse-CSP(∆). For consistency we denote algebras in these reductions by the same symbols that are used in the corollary. Subsection 4.6 states the main result. Before illustrating the details of the reduction we give a few examples of some widely studied NP-complete CSP’s. • 1-in-3-SAT: Input is a set of 3-clauses. A clause is satisfied if exactly one of the three variables is assigned one. The corresponding constraint language Γ1/3 contains only the relation {(0, 0, 1), (0, 1, 0), (1, 0, 0)}. • k-NAE-SAT or k-not-all-equal-SAT: Input is a set of k-clauses. A clause is satisfied by any assignment except, (0, 0,..., 0) and (1, 1,..., 1). The corresponding constraint l language is ∪l≤kSl where Sl = {{0, 1} \{(0, 0,..., 0), (1, 1,..., 1)}}. • k-Coloring: We have already seen this problem in definition 6. Its corresponding constraint language contains only the relation {(a, b) | a, b ∈ [k] ∧ a 6= b}.

4.1 k-SAT → Non-trivial Factor B

Lemma 5. Let B be a set of size atleast two, and let B = (B,FB) be an algebra. If FB contains only projections then sparse-k-SAT SERF reduces to sparse-CSP(β), where β ⊆ Inv(FB) is some ﬁnite constraint language. Proof. If B is a set of size atleast two, then the binary relations corresponding to the k-SAT problem are contained in Inv(FB) (as all relations are invariant under projections). Let β be the set of these binary relations. Then the identity map serves as a reduction from k-SAT to CSP(β). Note that the output instance is sparse and the reduction is SERF.

4.2 Non-trivial Factor B → Full Idempotent Reduct AI Recall that a factor is a homomorphic image of a subalgebra. Lemma 6 gives the reduction from factor (homomorphic image) to subalgebra and lemma 7 gives the reduction from subalgebra to the original idempotent algebra.

Lemma 6 (Theorem 5.4 of [5]). Let B = (B,FB) be a homomorphic image of some algebra AU = (U, FU ). Then for any ﬁnite set β ⊆ Inv(FB), sparse-CSP(β) SERF reduces to sparse- CSP(Γ), where Γ ⊆ Inv(FU ) is some ﬁnite constraint language.

Proof. Let ψ : U → B be the corresponding homomorphism map. For ρ ∈ Inv(FB) deﬁne −1 −1 −1 ψ (ρ) = {a | ψ(a) ∈ ρ}. ψ (ρ) ∈ Inv(FA) and the set Γ = {ψ (ρ) | ρ ∈ β} is a ﬁnite subset of Inv(FU ). For an instance X = (V,B, C) of sparse-CSP(β) we output an instance Y = (V, U, C0) of CSP(Γ), where C0 = {hs, ψ−1(ρ)i | hs, ρi ∈ C}. If s : V → U is a satisfying assignment of Y

11 then ψs is a satisfying assignment of X. If s : V → B is a satisfying assignment of X then s0 : V → U such that ψs0 = s is a satisfying assignment of Y . Since the number of constraints remains the same Y is an instance of sparse-CSP(Γ). This is a SERF reduction as the number of variables doesn’t change.

Lemma 7 (Theorem 5.2 of [5]). Let AI = (S,FI ) be an algebra and let AU = (U, FU ) be its subalgebra, where FU = FI |U . Then for any ﬁnite Γ ⊆ Inv(FU ), sparse-CSP(Γ) SERF reduces to sparse-CSP(Π), where Π ⊆ Inv(FI ) is some ﬁnite constraint language.

Proof. As Inv(FI |U ) ⊆ Inv(FI ), the identity map serves as a reduction with Π = Γ. Note that the output instance is sparse and the reduction is SERF.

4.3 Full Idempotetnt Reduct AI → Surjective Algebra AS We give the desired reduction in two stages – lemma 8 and 9. Lemma 8 uses fact 3 and lemma 9 uses fact 4 and proposition 1.

Fact 3. Let ΓCON = {{(s)} | s ∈ S} be the set of all unary relations over S. An operation φ over S is idempotent if and only if it preserves all the relations in ΓCON = {{(s)} | s ∈ S}. S S Hence for any algebra A = (S,FS), Inv(T ermid(A )) is the relational clone generated by Inv(FS) ∪ ΓCON .

S I I Lemma 8. Let A = (S,FS) be a surjective algebra and A = (S, T ermid(A )) be its full S idempotent reduct. Then for any ﬁnite set Π ⊆ Inv(T ermid(A )), sparse-CSP(Π) SERF 0 0 reduces to sparse-CSP(Π ), where Π ⊆ Inv(FS) ∪ ΓCON is some ﬁnite constraint language.

S Proof. By fact 3 we know that Inv(T ermid(A )) is the relational clone generated by the constraint language Inv(FS) ∪ ΓCON . The rest of the proof follows from the corollary 3. Fact 4. A ﬁnite algebra is surjective if and only if all its unary term operations are surjective. Hence they form a group of permutations.

S Proposition 1 (Proposition 1.3 of [22]). Let S = {s1, s2, . . . , s|S|} and A = (S,FS) be a ﬁnite surjective algebra whose unary term operations form a permutation group G. Then the relation ρG, deﬁned by ρG = {(g(s1), . . . , g(s|S|)) | g ∈ G} is contained in Inv(FS).

S Lemma 9 (Theorem 4.7 of [5]). Let S = {s1, s2, . . . , s|S|} and A = (S,FS) be a finite surjective algebra whose unary term operations form a permutation group G. Then for any 0 0 finite set Π ⊆ Inv(FS) ∪ ΓCON , sparse-CSP(Π ) SERF reduces to sparse-CSP(Σ), where Σ ⊆ Inv(FS) is some finite constraint language.

0 Proof. Let Σ = [(Π ) − (ΓCON ) + (=S) + (ρG)]. By fact 4 and proposition 1 we know that Σ ⊆ Inv(FS). Constraints in any instance X = (V,S, C) of sparse-CSP(Π0) will have constraint relations 0 0 0 from Inv(FS) ∪ ΓCON . We output Y = (V , S, C ), where V = V ∪ {vs | s ∈ S}. To construct 0 C we replace any constraint in C of the form hv, {(s)}i by the constraint h(v, vs), =Si. Finally 0 we add the constraint h(v1, v2, . . . , v|S|), ρGi to C . If φ satisﬁes Y then ∀s ∈ S [φ(vs) = g(s)] for some g ∈ G. As G is a group we have g−1 ∈ G and thus g−1 ∈ T erm(AS). This implies that relations in Σ are invariant under

12 −1 −1 −1 g . So g φ is also a satisfying assignment of Y . As ∀s ∈ S [g φ(vs) = s], the restriction of g−1φ to V is a satisfying assignment of X. If φ satisﬁes X then φ with an extension ∀s ∈ S [φ(vs) = s] satisﬁes Y . Increase in the number of variables and the number of constraints is only a constant. Thus Y is an instance of sparse-CSP(Σ) and the reduction is SERF.

4.4 Surjective Algebra AS → Algebra A / Relational Clone hΛi The reduction uses propositions 2 and 3. For a relational cone hΛi and unary operation f let f(hΛi) = {f(ρ) | ρ ∈ hΛi}, where f(ρ) = {f(a) | a ∈ ρ}. Proposition 2 ([23]). If A = (A, F ), Inv(F ) = hΛi and f ∈ P ol(hΛi) is an unary operation with range S, then A|S = (S, T erm(A)|S) satisfies Inv(T erm(A)|S) = f(hΛi). Proposition 3 (Proposition 4.4 of [15]). Let hΛi be a relational cone and f ∈ P ol(hΛi) be an unary operation with range S. Then for any finite set Σ ⊆ f(hΛi), sparse-CSP(Σ) SERF reduces to sparse-CSP(Υ), where Υ ⊆ hΛi is some finite constraint language. Proof. For a relation ρ ∈ f(hΛi) define f −1(ρ) = {σ ∈ hΛi | f(σ) = ρ}. Then Υ = {σ ∈ f −1(ρ) | ρ ∈ Σ} is a finite subset of hΛi. For an instance X = (V,S, C) of sparse-CSP(Σ) we construct Y = (V, A, f −1(C)), where −1 −1 f (C) = {h(x1, . . . , xt), ρi | ρ ∈ f (σ) ∧ h(x1, . . . , xt), σi ∈ C}. For a satisfying assignment s of Y , fs is a satisfying assignment of X. For a satisfying assignment s of X, s is also a satisfying assignment of Y since f(ρ) ⊆ ρ for any relation ρ. Y is an instance of sparse-CSP(Υ) as the number of constraints is only multiplied by a constant. This reduction is SERF as it preserves the number of variables.

Lemma 10. Let A = (A, F ) and A|S = (S, T erm(A)|S), where S is the range of a unary function f ∈ Inv(F ). Then for any ﬁnite set Σ ⊆ Inv(T erm(A)|S), sparse-CSP(Σ) SERF reduces to sparse-CSP(Υ), where Υ ⊆ hΛi is some ﬁnite constraint language. Proof. The proof directly follows from propositions 2 and 3.

4.5 Relational Clone hΛi → Constraint Language Λ Lemma 11. Let Λ be a constraint language, then for any ﬁnite set Υ ⊆ hΛi, sparse-CSP(Υ) SERF reduces to sparse-CSP(Λ). Proof. The proof directly follows from corollary 3.

4.6 k-SAT → Constraint Language ∆ Theorem 3. For any NP-complete CSP (∆) there is a SERF reduction from sparse-k-SAT to sparse-CSP(Λ), where Λ ⊆ ∆ is some ﬁnite constraint language. Thus ETH implies that sparse-CSP(∆) is not in SE. Proof. The proof directly follows by combining corollary 4 with lemmas 5,6,7,8,9,10,11.

13 5 Implications of SETH

In this section we state reductions from CNF-SAT to some well studied natural problems. These reductions imply that an improvement in the best known algorithms for these problems will lead to a better SAT algorithm, falsifying SETH. We explain one of the reductions in detail in order to introduce the reader to reductions that are stronger than SERF reductions. Note that this is a far from exhaustive list of ﬁne-grained reductions from CNF-SAT. Deﬁnition 25 (Dominating Set). The input is an undirected graph G(V,E) and a number k. A dominating set of G is S ⊆ V such that a node v ∈ V is either in S or have an edge from some node in S. The goal is to check if there exists a k-size dominating set. The brute-force approach wherein we check all the k-sets runs in time O(nk+1). The best algorithm known so far runs in time nk+o(1) for the case k ≥ 7. It was described in [19] using Coppersmith’s rectangular matrix multiplication [10]. In [8] it was shown that k- Dominating Set doesn’t have a no(k) time algorithm unless ETH is false. The next lemma leads to a tighter lower bound based on SETH. It shows that the best known algorithm is optimal unless SETH is false. Lemma 12. [19] Let k ≥ 3 be a integer and f be a function. If k-Dominating Set can be f(k) n f(k) solved in O(n ) time then CNF-SAT can be solved in O((m + k2 k ) ) time.

Proof. For a CNF formula F construct a graph GF as follows:

• Vertex Set V (GF ): Partition the set of variables into k disjoint parts of size n/k each. Create a node corresponding to each of the 2n/k partial assignments of each of the k parts. Let us call these k2n/k nodes “partial assignment” nodes. For each part create a “dummy” node. Create m “clause” nodes corresponding to each of the m clauses.

• Edge Set E(GF ): Create edges to make each of the k parts a clique. For each part connect the corresponding “dummy” node to each of the 2n/k “partial assignment” nodes. Create an edge from a “partial assignment” node to a “clause” node if and only if the corresponding partial assignment satisﬁes the corresponding clause.

From a satisfying assignment of F we can can easily construct a k-dominating set of GF . Include the “partial assignment” nodes corresponding to the satisfying assignment. This will cover all the k parts (including the “dummy” nodes) and all the “clause” nodes. Let S be a k-dominating set of GF . S should have one node from each of the k parts because any “dummy” node only has edges from “partial assignment” nodes of the corresponding part. Since S has edges from all the “clause” nodes the assignment constructed by combining the corresponding k partial assignments (arbitrary partial assignment in case of “dummy” node) is a satisfying assignment of F . Corollary 5. For k ≥ 3 and > 0, k-Dominating Set requires at least Ω(nk−) time unless SETH is false. Definition 26 (k-Set Cover). The input is a universe U of size n and a collection C of S its subsets. A S ⊆ C is called a set-cover of U if it satisfies S∈S S = U. The goal is to find a k-size set-cover of U.

14 A k-Dominating Set instance G({v1, . . . , vn},E) can also be viewed as a k-Set Cover instance where U = {v1, . . . , vn} and C = {S1,...,Sn}, where Si = {vj| (j = i)∨(vi, vj) ∈ E}.

Corollary 6. For k ≥ 3 and > 0, k-Set Cover requires at least Ω(nk−) time unless SETH is false.

Deﬁnition 27 (2Sat+2Clauses). Input instance is an instance of 2-SAT with two addi- tional clauses of arbitrary width. The goal is to ﬁnd a satisfying assignment.

2-SAT is solvable in linear time [3]. The generalization 2Sat+2Clauses has a O(mn+n2) time algorithm [19]. Assuming SETH, a reduction from CNF-SAT to 2Sat+2Clauses described in [19] removes the possibility of a sub-quadratic time algorithm.

Corollary 7. For > 0, 2Sat+2Clauses has no O(m+n)2− time algorithm unless SETH is false.

Deﬁnition 28 (Orthogonal Vectors or OV). Input is two sets of n vectors A, B in {0, 1}d. The goal is to ﬁnd a pair of orthogonal vectors a ∈ A and b ∈ B.

(2− 1 ) The most obvious brute force approach gives a O(n2d) time algorithm. A n O(log n) time algorithm for the case d = c log n is described in [2]. Note that, this too is not a sub-quadratic time algorithm. The savings in time goes arbitrary close to zero as n increases. Assuming SETH, a reduction from CNF-SAT to OV described in [24] removes the possibility of a truly sub-quadratic time algorithm.

Corollary 8. For > 0, OV has no O(n2−) time algorithm unless SETH is false.

Deﬁnition 29 (Longest Common Subsequence or LCS). Input is a pair of sequences S1,S2 of length n over an alphabet Σ. LCS(S1,S2) is the the size of the longest sequence S that appears in both S1,S2 as a subsequence. The goal is to compute LCS(S1,S2).

LCS has a classical quadratic time dynamic programming algorithm. For the constant size alphabet set the best known algorithm runs in time O(n2/ log2 n) [18]. A reduction from OV to LCS is described in [1]. Assuming SETH, corollary 8 and this reduction removes the possibility of a sub-quadratic time algorithm for LCS.

Corollary 9. For > 0, LCS has no O(n2−) time algorithm unless SETH is false.

6 Future Directions

There are some problems which have lower bounds based on ETH but not SETH. These problems have SERF reductions from SAT. One interesting pursuit would be to come up with alternate reductions to get better lower bounds based on SETH. One important and well-studied candidate in this category is k-Coloring. It has a 2Ω(n) lower bound due to ETH and the best known algorithm runs in time O(poly(n)2n) [4, 16]. A more general unresolved question is - “Does ETH imply SETH?”.

15 References

[1] Amir Abboud, Arturs Backurs, and Virginia Vassilevska Williams. Tight hardness results for LCS and other sequence similarity measures. In IEEE 56th Annual Symposium on Foundations of Computer Science, FOCS 2015, Berkeley, CA, USA, 17-20 October, 2015, pages 59–78, 2015.

[2] Amir Abboud, Ryan Williams, and Huacheng Yu. More Applications of the Polynomial Method to Algorithm Design, pages 218–230.

[3] Bengt Aspvall, Michael F. Plass, and Robert Endre Tarjan. A linear-time algorithm for testing the truth of certain quantiﬁed boolean formulas. Inf. Process. Lett., 8(3):121–123, 1979.

[4] Andreas Bjorklund and Thore Husfeldt. Inclusion–exclusion algorithms for counting set partitions. In Proceedings of the 47th Annual IEEE Symposium on Foundations of Computer Science, FOCS ’06, pages 575–582, Washington, DC, USA, 2006. IEEE Computer Society.

[5] Andrei Bulatov, Peter Jeavons, and Andrei Krokhin. Classifying the complexity of constraints using ﬁnite algebras. SIAM Journal on Computing, 34(3):720–742, 2005.

[6] Andrei A. Bulatov. A dichotomy theorem for nonuniform csps. In 58th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October 15-17, 2017, pages 319–330, 2017.

[7] Andrei A. Bulatov. Constraint satisfaction problems: Complexity and algorithms. In Language and Automata Theory and Applications - 12th International Conference, LATA 2018, Ramat Gan, Israel, April 9-11, 2018, Proceedings, pages 1–25, 2018.

[8] Jianer Chen, Xiuzhen Huang, Iyad A. Kanj, and Ge Xia. Strong computational lower bounds via parameterized complexity. J. Comput. Syst. Sci., 72(8):1346–1367, 2006.

[9] Stephen A. Cook. The complexity of theorem-proving procedures. In Proceedings of the 3rd Annual ACM Symposium on Theory of Computing, May 3-5, 1971, Shaker Heights, Ohio, USA, pages 151–158, 1971.

[10] Don Coppersmith. Rectangular matrix multiplication revisited. J. Complexity, 13(1):42– 49, 1997.

[11] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Cliﬀord Stein. Intro- duction to Algorithms, 3rd Edition. MIT Press, 2009.

[12] D. Geiger. Closed systems of functions and predicates. Paciﬁc Journal of Mathematics, 27(1):95–100, 1968.

[13] Russell Impagliazzo and Ramamohan Paturi. Complexity of k-sat. In Proceedings of the 14th Annual IEEE Conference on Computational Complexity, Atlanta, Georgia, USA, May 4-6, 1999, pages 237–240, 1999.

16 [14] Russell Impagliazzo, Ramamohan Paturi, and Francis Zane. Which problems have strongly exponential complexity? In 39th Annual Symposium on Foundations of Com- puter Science, FOCS ’98, November 8-11, 1998, Palo Alto, California, USA, pages 653–663, 1998.

[15] Peter Jeavons. On the algebraic structure of combinatorial problems. Theor. Comput. Sci., 200(1-2):185–204, June 1998.

[16] Mikko Koivisto. An o*(2ˆn ) algorithm for graph coloring and other partitioning problems via inclusion–exclusion. In 47th Annual IEEE Symposium on Foundations of Com- puter Science (FOCS 2006), 21-24 October 2006, Berkeley, California, USA, Proceed- ings, pages 583–590, 2006.

[17] Leonid A. Levin. Universal sorting problems. Problems of Information Transmission, 9:265–266, 1973.

[18] William J. Masek and Mike Paterson. A faster algorithm computing string edit distances. J. Comput. Syst. Sci., 20(1):18–31, 1980.

[19] Mihai Patrascu and Ryan Williams. On the possibility of faster SAT algorithms. In Proceedings of the Twenty-First Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2010, Austin, Texas, USA, January 17-19, 2010, pages 1065–1075, 2010.

[20] Ramamohan Paturi, Pavel Pudl´ak,Michael E. Saks, and Francis Zane. An improved exponential-time algorithm for k-sat. J. ACM, 52(3):337–364, May 2005.

[21] Thomas J. Schaefer. The complexity of satisﬁability problems. In Proceedings of the Tenth Annual ACM Symposium on Theory of Computing, STOC ’78, pages 216–226, New York, NY, USA, 1978. ACM.

[22] A.´ Szendrei. Clones in universal algebra. Séminairede mathématiquessupérieures. Presses de l’Universitéde Montréal,1986.

[23] A.´ Szendrei. Term minimal algebras. algebra universalis, 32(4):439–477, Dec 1994.

[24] Ryan Williams. A new algorithm for optimal 2-constraint satisfaction and its implications. Theor. Comput. Sci., 348(2-3):357–365, 2005.

[25] Dmitriy Zhuk. A proof of CSP dichotomy conjecture. In 58th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October 15-17, 2017, pages 331–342, 2017.