Fine-grained Complexity Research Articles

The Fine-Grained Complexity of Graph Homomorphism Parameterized by Clique-Width

The generic homomorphism problem, which asks whether an input graph \(G\) admits a homomorphism into a fixed target graph \(H\) , has been widely studied in the literature. In this article, we provide a fine-grained complexity classification of the running time of the homomorphism problem with respect to the clique-width of \(G\) (denoted \({\operatorname{cw}}\) ) for virtually all choices of \(H\) under the Strong Exponential Time Hypothesis. In particular, we identify a property of \(H\) called the signature number \(s(H)\) and show that for each \(H\) , the homomorphism problem can be solved in time \(\mathcal{O^{*}}(s(H)^{{\operatorname{cw}}})\) . Crucially, we then show that this algorithm can be used to obtain essentially tight upper bounds. Specifically, we provide a reduction that yields matching lower bounds for each \(H\) that is either a projective core or a graph admitting a factorization with additional properties—allowing us to cover all possible target graphs under long-standing conjectures.

Counting Answers to Unions of Conjunctive Queries: Natural Tractability Criteria and Meta-Complexity

We study the problem of counting answers to unions of conjunctive queries (UCQs) under structural restrictions on the input query. Concretely, given a class C of UCQs, the problem #UCQ (C) provides as input a UCQ Ψ ∈ C and a database D and the problem is to compute the number of answers of Ψ in D. Chen and Mengel [PODS'16] have shown that for any recursively enumerable class C, the problem #UCQ (C) is either fixed-parameter tractable or hard for one of the parameterised complexity classes W[1] or #W[1]. However, their tractability criterion is unwieldy in the sense that, given any concrete class C of UCQs, it is not easy to determine how hard it is to count answers to queries in C. Moreover, given a single specific UCQ Ψ, it is not easy to determine how hard it is to count answers to Ψ. In this work, we address the question of finding a natural tractability criterion: The combined conjunctive query of a UCQ Ψ=φ 1 ∨ ... ∨ φ l is the conjunctive query ^ Ψ = φ_1 ∧ ... ∧ φ l . We show that under natural closure properties of C, the problem #UCQ (C) is fixed-parameter tractable if and only if the combined conjunctive queries of UCQs in C, and their contracts, have bounded treewidth. A contract of a conjunctive query is an augmented structure, taking into account how the quantified variables are connected to the free variables --- if all variables are free, then a conjunctive query is equal to its contract; in this special case the criterion for fixed-parameter tractability of #UCQ (C) thus simplifies to the combined queries having bounded treewidth. Finally, we give evidence that a closure property on C is necessary for obtaining a natural tractability criterion: We show that even for a single UCQ Ψ, the meta problem of deciding whether #UCQ (Ψ) can be solved in time O(|D| d ) is NP-hard for any fixed d ≥ 1. Moreover, we prove that a known exponential-time algorithm for solving the meta problem is optimal under assumptions from fine-grained complexity theory. As a corollary of our reduction, we also establish that approximating the Weisfeiler-Leman-Dimension of a UCQ is NP-hard.

Fine-Grained Complexity of Regular Path Queries

A regular path query (RPQ) is a regular expression q that returns all node pairs (u, v) from a graph database that are connected by an arbitrary path labelled with a word from L(q). The obvious algorithmic approach to RPQ-evaluation (called PG-approach), i.e., constructing the product graph between an NFA for q and the graph database, is appealing due to its simplicity and also leads to efficient algorithms. However, it is unclear whether the PG-approach is optimal. We address this question by thoroughly investigating which upper complexity bounds can be achieved by the PG-approach, and we complement these with conditional lower bounds (in the sense of the fine-grained complexity framework). A special focus is put on enumeration and delay bounds, as well as the data complexity perspective. A main insight is that we can achieve optimal (or near optimal) algorithms with the PG-approach, but the delay for enumeration is rather high (linear in the database). We explore three successful approaches towards enumeration with sub-linear delay: super-linear preprocessing, approximations of the solution sets, and restricted classes of RPQs.

Fine-Grained Complexity Analysis of Multi-Agent Path Finding on 2D Grids

Multi-Agent Path Finding (MAPF) is a fundamental motion coordination problem arising in multi-agent systems with a wide range of applications. The problem's intractability has led to extensive research on improving the scalability of solvers for it. Since optimal solvers can struggle to scale, a major challenge that arises is understanding what makes MAPF hard. We tackle this challenge through a fine-grained complexity analysis of time-optimal MAPF on 2D grids, thereby closing two gaps and identifying a new tractability frontier. First, we show that 2-colored MAPF, i.e., where the agents are divided into two teams, each with its own set of targets, remains NP-hard. Second, for the flowtime objective (also called sum-of-costs), we show that it remains NP-hard to find a solution in which agents have an individually optimal cost, which we call an individually optimal solution. The previously tightest results for these MAPF variants are for (non-grid) planar graphs. We use a single hardness construction that replaces, strengthens, and unifies previous proofs. We believe that it is also simpler than previous proofs for the planar case as it employs minimal gadgets that enable its full visualization in one figure. Finally, for the flowtime objective, we establish a tractability frontier based on the number of directions agents can move in. Namely, we complement our hardness result, which holds for three directions, with an efficient algorithm for finding an individually optimal solution if only two directions are allowed. This result sheds new light on the structure of optimal solutions, which may help guide algorithm design for the general problem.

Parameterized Complexity Classes Defined by Threshold Circuits and Their Connection with Sorting Networks

The main complexity classes of the Parameterized Intractability Theory are based on weighted Boolean circuit satisfiability problems and organized into a hierarchy so-called W-hierarchy. The W-hierarchy enables fine-grained complexity analyses of parameterized problems that are unlikely to belong to the FPT class. In this paper, we introduce the Th-hierarchy, a natural generalization of the W-hierarchy defined by unweighted threshold circuit satisfiability problems. Investigating the relationship between Th-hierarchy and W-hierarchy, we discuss the complexity of transforming Threshold circuits into Boolean circuits, and observe that sorting networks are powerful tools to handle such transformations. First, we show that these hierarchies collapse at the last level (W[P][Formula: see text][Formula: see text][Formula: see text]Th[P]). After that, we present a time complexity analysis of an AKS sorting network construction, which supports some of our results. Finally, we prove that Th[[Formula: see text]] [Formula: see text] W[SAT] for every [Formula: see text]. As a by-product, our studies suggest that it is relevant to consider a new class based on logarithmic depth circuits in the W-hierarchy.

Improved Merlin–Arthur Protocols for Central Problems in Fine-Grained Complexity

In a Merlin–Arthur proof system, the proof verifier (Arthur) accepts valid proofs (from Merlin) with probability 1, and rejects invalid proofs with probability arbitrarily close to 1. The running time of such a system is defined to be the length of Merlin’s proof plus the running time of Arthur. We provide new Merlin–Arthur proof systems for some key problems in fine-grained complexity. In several cases our proof systems have optimal running time. Our main results include:Certifying that a list of n integers has no 3-SUM solution can be done in Merlin–Arthur time tilde{O}(n). Previously, Carmosino et al. [ITCS 2016] showed that the problem has a nondeterministic algorithm running in tilde{O}(n^{1.5}) time (that is, there is a proof system with proofs of length tilde{O}(n^{1.5}) and a deterministic verifier running in tilde{O}(n^{1.5}) time).Counting the number of k-cliques with total edge weight equal to zero in an n-node graph can be done in Merlin–Arthur time {tilde{O}}(n^{lceil k/2rceil }) (where kge 3). For odd k, this bound can be further improved for sparse graphs: for example, counting the number of zero-weight triangles in an m-edge graph can be done in Merlin–Arthur time {tilde{O}}(m). Previous Merlin–Arthur protocols by Williams [CCC’16] and Björklund and Kaski [PODC’16] could only count k-cliques in unweighted graphs, and had worse running times for small k.Computing the All-Pairs Shortest Distances matrix for an n-node graph can be done in Merlin–Arthur time tilde{O}(n^2). Note this is optimal, as the matrix can have Omega (n^2) nonzero entries in general. Previously, Carmosino et al. [ITCS 2016] showed that this problem has an tilde{O}(n^{2.94}) nondeterministic time algorithm.Certifying that an n-variable k-CNF is unsatisfiable can be done in Merlin–Arthur time 2^{n/2 - n/O(k)}. We also observe an algebrization barrier for the previous 2^{n/2}cdot textrm{poly}(n)-time Merlin–Arthur protocol of R. Williams [CCC’16] for #SAT: in particular, his protocol algebrizes, and we observe there is no algebrizing protocol for k-UNSAT running in 2^{n/2}/n^{omega (1)} time. Therefore we have to exploit non-algebrizing properties to obtain our new protocol.Certifying a Quantified Boolean Formula is true can be done in Merlin–Arthur time 2^{4n/5}cdot textrm{poly}(n). Previously, the only nontrivial result known along these lines was an Arthur–Merlin–Arthur protocol (where Merlin’s proof depends on some of Arthur’s coins) running in 2^{2n/3}cdot textrm{poly}(n) time. Due to the centrality of these problems in fine-grained complexity, our results have consequences for many other problems of interest. For example, our work implies that certifying there is no Subset Sum solution to n integers can be done in Merlin–Arthur time 2^{n/3}cdot textrm{poly}(n), improving on the previous best protocol by Nederlof [IPL 2017] which took 2^{0.49991n}cdot textrm{poly}(n) time.

The Fine-Grained Complexity of CFL Reachability

Many problems in static program analysis can be modeled as the context-free language (CFL) reachability problem on directed labeled graphs. The CFL reachability problem can be generally solved in time O ( n 3 ), where n is the number of vertices in the graph, with some specific cases that can be solved faster. In this work, we ask the following question: given a specific CFL, what is the exact exponent in the monomial of the running time? In other words, for which cases do we have linear, quadratic or cubic algorithms, and are there problems with intermediate runtimes? This question is inspired by recent efforts to classify classic problems in terms of their exact polynomial complexity, known as fine-grained complexity. Although recent efforts have shown some conditional lower bounds (mostly for the class of combinatorial algorithms), a general picture of the fine-grained complexity landscape for CFL reachability is missing. Our main contribution is lower bound results that pinpoint the exact running time of several classes of CFLs or specific CFLs under widely believed lower bound conjectures (e.g., Boolean Matrix Multiplication, k -Clique, APSP, 3SUM). We particularly focus on the family of Dyck- k languages (which are strings with well-matched parentheses), a fundamental class of CFL reachability problems. Remarkably, we are able to show a Ω( n 2.5 ) lower bound for Dyck-2 reachability, which to the best of our knowledge is the first super-quadratic lower bound that applies to all algorithms, and shows that CFL reachability is strictly harder that Boolean Matrix Multiplication. We also present new lower bounds for the case of sparse input graphs where the number of edges m is the input parameter, a common setting in the database literature. For this setting, we show a cubic lower bound for Andersen’s Pointer Analysis which significantly strengthens prior known results.

The Fine-Grained Complexity of Multi-Dimensional Ordering Properties

We define a class of problems whose input is an n-sized set of d-dimensional vectors, and where the problem is first-order definable using comparisons between coordinates. This class captures a wide variety of tasks, such as complex types of orthogonal range search, model-checking first-order properties on geometric intersection graphs, and elementary questions on multidimensional data like verifying Pareto optimality of a choice of data points. Focusing on constant dimension d, we show that any such k-quantifier, d-dimensional problem is solvable in $$O(n^{k-1} \log ^{d-1} n)$$ time. Furthermore, this algorithm is conditionally tight up to subpolynomial factors: we show that assuming the 3-uniform hyperclique hypothesis, there is a k-quantifier, $$(3k-3)$$ -dimensional problem in this class that requires time $$\Omega (n^{k-1-o(1)})$$ . Towards identifying a single representative problem for this class, we study the existence of complete problems for the 3-quantifier setting (since 2-quantifier problems can already be solved in near-linear time $$O(n\log ^{d-1} n)$$ , and k-quantifier problems with $$k>3$$ reduce to the 3-quantifier case). We define a problem Vector Concatenated Non-Domination $$\mathsf {VCND}_d$$ (Given three sets of vectors X, Y and Z of dimension d, d and 2d, respectively, is there an $$x \in X$$ and a $$y \in Y$$ so that their concatenation $$x \circ y$$ is not dominated by any $$z \in Z$$ , where vector u is dominated by vector v if $$u_i \le v_i$$ for each coordinate $$1 \le i \le d$$ ), and determine it as the “unique” candidate to be complete for this class (under fine-grained assumptions).

Answering (Unions of) Conjunctive Queries using Random Access and Random-Order Enumeration

As data analytics becomes more crucial to digital systems, so grows the importance of characterizing the database queries that admit a more efficient evaluation. We consider the tractability yardstick of answer enumeration with a polylogarithmic delay after a linear-time preprocessing phase. Such an evaluation is obtained by constructing, in the preprocessing phase, a data structure that supports polylogarithmic-delay enumeration. In this article, we seek a structure that supports the more demanding task of a “random permutation”: polylogarithmic-delay enumeration in truly random order. Enumeration of this kind is required if downstream applications assume that the intermediate results are representative of the whole result set in a statistically meaningful manner. An even more demanding task is that of “random access”: polylogarithmic-time retrieval of an answer whose position is given.We establish that the free-connex acyclic CQs are tractable in all three senses: enumeration, random-order enumeration, and random access; and in the absence of self-joins, it follows from past results that every other CQ is intractable by each of the three (under some fine-grained complexity assumptions). However, the three yardsticks are separated in the case of aunion of CQs (UCQ): while a union of free-connex acyclic CQs has a tractable enumeration, it may (provably) admit no random access. We identify a fragment of such UCQs where we can guarantee random access with polylogarithmic access time (and linear-time preprocessing) and a more general fragment where we can guarantee tractable random permutation. For general unions of free-connex acyclic CQs, we devise two algorithms with relaxed guarantees: one has logarithmic delay in expectation, and the other provides a permutation that is almost uniformly distributed. Finally, we present an implementation and an empirical study that show a considerable practical superiority of our random-order enumeration approach over state-of-the-art alternatives.

General Lower Bounds and Improved Algorithms for Infinite–Domain CSPs

We study the fine-grained complexity of NP-complete, infinite-domain constraint satisfaction problems (CSPs) parameterised by a set of first-order definable relations (with equality). Such CSPs are of central importance since they form a subclass of any infinite-domain CSP parameterised by a set of first-order definable relations over a relational structure (possibly containing more than just equality). We prove that under the randomised exponential-time hypothesis it is not possible to find c > 1 such that a CSP over an arbitrary finite equality language is solvable in O(c^n) time (n is the number of variables). Stronger lower bounds are possible for infinite equality languages where we rule out the existence of 2^{o(n log n)} time algorithms; a lower bound which also extends to satisfiability modulo theories solving for an arbitrary background theory. Despite these lower bounds we prove that for each c > 1 there exists an NP-hard equality CSP solvable in O(c^n) time. Lower bounds like these immediately ask for closely matching upper bounds, and we prove that a CSP over a finite equality language is always solvable in O(c^n) time for a fixed c, and manage to extend this algorithm to the much broader class of CSPs where constraints are formed by first-order formulas over a unary structure.

Approximately Counting and Sampling Small Witnesses Using a Colorful Decision Oracle

In this paper, we design efficient algorithms to approximately count the number of edges of a given $k$-hypergraph, and to sample an approximately uniform random edge. The hypergraph is not given explicitly and can be accessed only through its colorful independence oracle: The colorful independence oracle returns yes or no depending on whether a given subset of the vertices contains an edge that is colorful with respect to a given vertex-coloring. Our results extend and/or strengthen recent results in the graph oracle literature due to Beame et al. [ACM Trans. Algorithms, 16 (2020), 52], Dell and Lapinskas [Proceedings of STOC, ACM, 2018, pp. 281--288], and Bhattacharya et al. [Proceedings of ISAAC, 2019]. Our results have consequences for approximate counting/sampling: We can turn certain kinds of decision algorithms into approximate counting/sampling algorithms without causing much overhead in the running time. We apply this approximate counting/sampling-to-decision reduction to key problems in fine-grained complexity (such as $k$-SUM, $k$-OV, and weighted $k$-Clique) and parameterized complexity (such as induced subgraphs of size $k$ or weight-$k$ solutions to constraint satisfaction problems).

SETH-based Lower Bounds for Subset Sum and Bicriteria Path

Subset Sumand k -SAT are two of the most extensively studied problems in computer science, and conjectures about their hardness are among the cornerstones of fine-grained complexity. An important open problem in this area is to base the hardness of one of these problems on the other. Our main result is a tight reduction from k -SAT to Subset Sum on dense instances, proving that Bellman’s 1962 pseudo-polynomial O * ( T )-time algorithm for Subset Sum on n numbers and target T cannot be improved to time T 1-ε · 2 o(n) for any ε > 0, unless the Strong Exponential Time Hypothesis (SETH) fails. As a corollary, we prove a “Direct-OR” theorem for Subset Sum under SETH, offering a new tool for proving conditional lower bounds: It is now possible to assume that deciding whether one out of N given instances of Subset Sum is a YES instance requires time ( N T ) 1-o(1) . As an application of this corollary, we prove a tight SETH-based lower bound for the classical Bicriteria s,t -Path problem, which is extensively studied in Operations Research. We separate its complexity from that of Subset Sum: On graphs with m edges and edge lengths bounded by L , we show that the O ( Lm ) pseudo-polynomial time algorithm by Joksch from 1966 cannot be improved to Õ( L + m ), in contrast to a recent improvement for Subset Sum (Bringmann, SODA 2017).

The (Coarse) Fine-Grained Structure of NP-Hard SAT and CSP Problems

We study the fine-grained complexity of NP-complete satisfiability (SAT) problems and constraint satisfaction problems (CSPs) in the context of the strong exponential-time hypothesis (SETH) , showing non-trivial lower and upper bounds on the running time. Here, by a non-trivial lower bound for a problem SAT (Γ) (respectively CSP (Γ)) with constraint language Γ, we mean a value c 0 > 1 such that the problem cannot be solved in time O ( c n ) for any c < c 0 unless SETH is false, while a non-trivial upper bound is simply an algorithm for the problem running in time O ( c n ) for some c < 2. Such lower bounds have proven extremely elusive, and except for cases where c 0 =2 effectively no such previous bound was known. We achieve this by employing an algebraic framework, studying constraint languages Γ in terms of their algebraic properties. We uncover a powerful algebraic framework where a mild restriction on the allowed constraints offers a concise algebraic characterization. On the relational side we restrict ourselves to Boolean languages closed under variable negation and partial assignment, called sign-symmetric languages. On the algebraic side this results in a description via partial operations arising from system of identities, with a close connection to operations resulting in tractable CSPs, such as near unanimity operations and edge operations . Using this connection we construct improved algorithms for several interesting classes of sign-symmetric languages, and prove explicit lower bounds under SETH. Thus, we find the first example of an NP-complete SAT problem with a non-trivial algorithm which also admits a non-trivial lower bound under SETH. This suggests a dichotomy conjecture with a close connection to the CSP dichotomy theorem: an NP-complete SAT problem admits an improved algorithm if and only if it admits a non-trivial partial invariant of the above form.

Computing maximum independent set on outerstring graphs and their relatives

A graph G with n vertices is called an outerstring graph if it has an intersection representation with a set of n curves inside a disk such that one endpoint of every curve is attached to the boundary of the disk. Given an outerstring graph representation of G with s segments, a Maximum Independent Set (MIS) of G can be computed in O(s3) time (Keil et al. (2017) [22]).We examine the fine-grained complexity of the MIS problem on some well-known outerstring representations (e.g., line segments, L-shapes, etc.), where the strings are of constant size. We show that computing MIS on grounded segment and grounded square-L representations is at least as hard as computing MIS on circle graph representations. Note that no O(n2−δ)-time algorithm, δ>0, is known for computing MIS on circle graphs. For the grounded string representations, where the strings are y-monotone simple polygonal paths of constant length with segments at integral coordinates, we solve MIS in O(n2) time and show this to be the best possible under the Strong Exponential Time Hypothesis. For the intersection graph of nL-shapes in the plane, we give a (4⋅log⁡OPT)-approximation algorithm for MIS (where OPT denotes the size of an optimal solution), improving the previously best-known (4⋅log⁡n)-approximation algorithm of Biedl and Derka (WADS 2017).

Fine-grained complexity of rainbow coloring and its variants

For a graph G and cR:E(G)→[k], a path P between u,v∈V(G) is a rainbow path if for distinct e,e′∈E(P), we have cR(e)≠cR(e′). Rainbowk-Coloring takes a graph G and the objective is to check if there is cR:E(G)→[k] such that for all u,v∈V(G) there is a rainbow path between u and v. Two variants of the above problem are Subset Rainbowk-Coloring and Steiner Rainbowk-Coloring, where we are additionally given a subset S⊆V(G)×V(G) and S′⊆V(G), respectively. Moreover, the objective is to check if there is cR:E(G)→[k], such that there is a rainbow path for each (u,v)∈S and u,v∈S′, respectively. Under ETH, we obtain that for each k≥3:1.Rainbowk-Coloring has no 2o(|E(G)|)nO(1)-time algorithm.2.Steiner Rainbowk-Coloring has no 2o(|S|2)nO(1)-time algorithm. We also obtain that Subset Rainbowk-Coloring and Steiner Rainbowk-Coloring admit 2O(|S|)nO(1)- and 2O(|S|2)nO(1)-time algorithms, respectively.

The [formula omitted]-Matching problem in distance-hereditary graphs and beyond

We make progress on the fine-grained complexity of Maximum-Cardinality Matching within graphs of bounded clique-width. Quasi linear-time algorithms for this problem have been proposed for the important subclasses of bounded-treewidth graphs (Fomin et al., SODA’17) and graphs of bounded modular-width (Coudert et al., SODA’18). We present such algorithm for bounded split-width graphs — a broad generalization of graphs of bounded modular-width, of which an interesting subclass is the distance-hereditary graphs. Specifically, we solve Maximum-Cardinality Matching in O((klog2k)⋅(m+n)⋅logn)-time on graphs with split-width at most k. We stress that the existence of such algorithm was not even known for distance-hereditary graphs until our work. Doing so, we answer an open question of Coudert et al. (SODA’18). Our work brings more insights on the relationships between matchings and splits, a.k.a., join operations between two vertex-subsets in different connected components. Furthermore, our analysis can be extended to the more general (unit cost) b-Matching problem. On the way, we introduce new tools for b-Matching and dynamic programming over split decompositions, that can be of independent interest.

The Average-Case Complexity of Counting Cliques in Erdös--Rényi Hypergraphs

Related DatabasesWeb of Science You must be logged in with an active subscription to view this.Article DataHistorySubmitted: 30 January 2020Accepted: 07 June 2021Published online: 14 September 2021Keywordsaverage-case complexity, fine-grained complexity, worst-case-to-average-case reductions, graph algorithms, random graphsAMS Subject Headings68Q17, 68Q87, 60C05Publication DataISSN (print): 0097-5397ISSN (online): 1095-7111Publisher: Society for Industrial and Applied MathematicsCODEN: smjcat

A note on the fine-grained complexity of MIS on regular graphs

We show that there is no subexponential time algorithm for computing the exact solution of the maximum independent set problem in d-regular graphs, unless ETH fails. We expand our method to show that it helps to provide lowerbounds for other covering problems such as vertex cover and clique. We utilize the construction to show the NP-hardness of MIS on 5-regular planar graphs, closing the exact complexity status of the problem on regular planar graphs.

Fine-Grained Reductions from Approximate Counting to Decision

In this article, we introduce a general framework for fine-grained reductions of approximate counting problems to their decision versions. (Thus, we use an oracle that decides whether any witness exists to multiplicatively approximate the number of witnesses with minimal overhead.) This mirrors a foundational result of Sipser (STOC 1983) and Stockmeyer (SICOMP 1985) in the polynomial-time setting, and a similar result of Müller (IWPEC 2006) in the FPT setting. Using our framework, we obtain such reductions for some of the most important problems in fine-grained complexity: the Orthogonal Vectors problem, 3SUM, and the Negative-Weight Triangle problem (which is closely related to All-Pairs Shortest Path). While all these problems have simple algorithms over which it is conjectured that no polynomial improvement is possible, our reductions would remain interesting even if these conjectures were proved; they have only polylogarithmic overhead and can therefore be applied to subpolynomial improvements such as the n 3 / exp(Θ (√ log n ))-time algorithm for the Negative-Weight Triangle problem due to Williams (STOC 2014). Our framework is also general enough to apply to versions of the problems for which more efficient algorithms are known. For example, the Orthogonal Vectors problem over GF( m ) d for constant m can be solved in time n · poly ( d ) by a result of Williams and Yu (SODA 2014); our result implies that we can approximately count the number of orthogonal pairs with essentially the same running time. We also provide a fine-grained reduction from approximate #SAT to SAT. Suppose the Strong Exponential Time Hypothesis (SETH) is false, so that for some 1 < c < 2 and all k there is an O ( c n )-time algorithm for k -SAT. Then we prove that for all k , there is an O (( c + o (1)) n )-time algorithm for approximate # k -SAT. In particular, our result implies that the Exponential Time Hypothesis (ETH) is equivalent to the seemingly weaker statement that there is no algorithm to approximate #3-SAT to within a factor of 1+ɛ in time 2 o ( n )/ ɛ 2 (taking ɛ > 0 as part of the input).

Fine-Grained Complexity of the Graph Homomorphism Problem for Bounded-Treewidth Graphs

For a fixed graph $H$, by Hom($H$) we denote the computational problem which asks whether a given graph $G$ admits a homomorphism to $H$, i.e., an edge-preserving mapping from $V(G)$ to $V(H)$. As ...