Width-parameterized SAT: Time-Space Tradeoffs

Width parameterizations of SAT, such as tree-width and path-width, enable the study of computationally more tractable and practical SAT instances. We give two simple algorithms. One that runs simultaneously in time-space $(O^*(2^{2tw(\phi)}), O^*(2^{tw(\phi)}))$ and another that runs in time-space $(O^*(3^{tw(\phi)\log{|\phi|}}),|\phi|^{O(1)})$, where $tw(\phi)$ is the tree-width of a formula $\phi$ with $|\phi|$ many clauses and variables. This partially answers the question of Alekhnovitch and Razborov, who also gave algorithms exponential both in time and space, and asked whether the space can be made smaller. We conjecture that every algorithm for this problem that runs in time $2^{tw(\phi)\mathbf{o(\log{|\phi|})}}$ necessarily blows up the space to exponential in $tw(\phi)$. We introduce a novel way to combine the two simple algorithms that allows us to trade \emph{constant} factors in the exponents between running time and space. Our technique gives rise to a family of algorithms controlled by two parameters. By fixing one parameter we obtain an algorithm that runs in time-space $(O^*(3^{1.441(1-\epsilon)tw(\phi)\log{|\phi|}}), O^*(2^{2\epsilon tw(\phi)}))$, for every $0<\epsilon<1$. We systematically study the limitations of this technique, and show that these algorithmic results are the best achievable using this technique. We also study further the computational complexity of width parameterizations of SAT. We prove non-sparsification lower bounds for formulas of path-width $\omega(\log|\phi|)$, and a separation between the complexity of path-width and tree-width parametrized SAT modulo plausible complexity assumptions.


Introduction
Satisfiability (SAT) is the prototypical NP-complete problem extensively studied in theoretical and empirical works.Previous work in SAT-solving deals with exact algorithms, special cases, heuristics, and parameterizations.In particular, width-parameterizations have received significant attention.Consider a formula φ in Conjunctive Normal Form (CNF), and also fix a graph describing its structure.Previous research gave algorithms with running time exponential in width parameters, e.g.tree-width, measured on this graph.One reason to care about this is because many real-world instances tend to have small width.In this paper we take a further step and we study time-space tradeoffs for width-based SAT-solvers.
In an influential paper Alekhnovitch and Razborov [AR02] gave algorithms that work in time 2 O(T W(φ)) and in space 2 O(T W(φ)) , where T W(φ) is the tree-width of a CNF formula φ; assume that T W(φ) = Ω(log |φ|).The authors state their results in terms of the branch-width of the formula, which is within a constant factor of the tree-width.They conclude: " The first important problem is to overcome the main difficulty of the practical implementation which is the huge amount of space used by width-based algorithms... Thus we ask if one can do anything intelligent in polynomial space to check satisfiability of formulas with small branch-width?" The question raised by Alekhnovitch and Razborov is a major issue in practical SAT-solving.It is well-known in the SAT-solving community that in many common cases SAT-solvers abort due to lack of space.
We devise two baseline algorithms for SAT instances in CNF.These two algorithms will be used later on as building blocks of much more involved ones.One is similar to [AR02], and it runs in time O * (2 2T W(φ) ) and space O * (2 T W(φ) ).The other runs in time O * (3 T W(φ) log |φ| ) and space |φ| O(1) , and it is the first algorithm for deciding arbitrary CNF instances that runs in space polynomial and time related exponentially in the tree-width.Unfortunately this does not fully answer the [AR02] question since we suffer a log |φ| factor in the exponent of the running time.In fact, our work revolves around this logarithmic factor.
Under this conjecture, for all practical purposes it makes sense to devise algorithms that improve the constant in the base of the running time and space from 3 and 2 to constants smaller than 3 and 2 respectively.At a more systematic level one might want to obtain timespace tradeoffs between constants in the exponents of the running time and space.A significant part of our contribution regards families of algorithms that achieve such tradeoffs.
Throughout this paper we assume that the tree (or path) decompositions are given in the input.That is, we mod-out the computational difficulty of computing the decomposition.This is without loss of generality for our algorithmic results since there are constant approximation algorithms for computing such decompositions in time exponential in the tree-width and space polynomial in the input length (e.g.[AR02]).Moreover, from a complexity theory point of view this is the "correct" thing to do.In particular, when the width decomposition is given in the input, under standard complexity assumptions we show that deciding SAT of a given a tree decomposition of width W is harder than deciding SAT of a given path decomposition of the same width value W.
Related work Tree-width is a popular graph parameter introduced by Robertson and Seymour [?,RS86].The smaller the tree-width of a graph, the more the graph looks like a tree (in some topological sense); for a graph of n vertices tree-width 1 means that the graph is a tree, whereas treewidth n − 1 means that it is the complete graph.There is a handful of hard computational problems on general graphs which become computationally easier when the input graph is of small tree-width; see.e.g.[?] for a survey.For SAT instances the tree-width of a CNF formula is the tree-width of its associated graph: incidence graph, primal graph, intersection graph and so on.Among those graphs, the most general one is the incidence graph (a bipartite graph where one side has variable-nodes and the other clause-nodes).In some sense, the tree-width value on the incidence graph upper bounds the tree-width value of the rest [Sze04].There is a vast literature (too large to concisely cite here) in empirical and theoretical studies in various width-parameterizations of SAT.
Improving the constant in the basis of an exponential time algorithm is a well-established goal in the field of exact computation for NP-hard problems; see e.g.[Woe03] for a survey on problems, algorithmic techniques, and see references within.In particular for k-SAT there is a line of work in algorithms that run in time α n for α < 2; e.g.[PPSZ98,Sch99,Woe03,?].Somewhat related to the threshold phenomenon conjectured early in this section, there are vertex-ordering NP-hard problems which can be solved in time-space O * (2 n ), O * (2 n ) and in time-space O * (4 n ), n O(1) ; e.g.[BFK + 11] and references within (an in particular [?]).There is no easy way to adapt these technique in our case (and thus to get rid of from the exponent the logarithmic factor).A key property of these algorithms is that is that as smaller subproblems are created the smaller the parameter (number of nodes) becomes.There is no obvious way to achieve this when the parameter is the width of the formula.Compare this to our conjecture.Our conjecture is about the width of a SAT instance per se -furthermore, in the worst case SAT can be exhaustively solved in time O * (2 n ) and space n O(1) .
Prior to our work, [GP08] addressed the question of Alekhnovitch and Razborov.The authors gave a combinatorially non-explicit algorithm only for the k-SAT problem, where the algorithm runs in time 2 O(T W(φ) log |φ|) and space |φ| O(1) .Due to the non-explicitness the constant in the exponent of the running time cannot be bounded in some easy way.[Pap09] shows that the complexity of deciding path-width parameterized instances precisely corresponds to the streaming verification (in log-space) of NP-witnesses.In particular, it is shown that deciding formulas with path decompositions of width O(log n) is complete for NL and it is asked whether the complexity of SAT instances with tree decompositions of width O(log n) is more difficult.
Lower bounds for deciding path-width parameterized SAT can be easily derived under the Exponential Time Hypothesis (ETH) and the application of the Sparsification Lemma [IPZ98].For the more general case of Constraint Satisfaction Problems, ETH has been applied in technically beautiful developments to essentially show that the time-optimal results are the standard tree-width based algorithms; see e.g.[Gro07,Mar10].
The last question on the inherent complexity of width-parameterized SAT instances regards their sparsification.In a model where a polynomial time verifier is given a formula φ of pathwidth PW(φ) and it communicates with an all-powerful oracle, how many bits can the verifier send to the oracle to decide φ?This question has been addressed before (e.g.[FS08,DvM10] -see [DvM10] for references) for NP-hard problems and in particular for SAT.In particular, for 3-SAT [DvM10] conditionally shows that if the verifier and the oracle communicate using n 3−ǫ bits, then this is not sufficient to decide satisfiability.

Our contribution and techniques
We give a dynamic programming (DP) algorithm for SAT where given a tree decomposition of the incidence graph of width T W(φ) runs in time-space O * (2 2T W(φ) ), O * (2 T W(φ) ) , and a recursive algorithm that runs in time-space O * (3 T W(φ) log |φ| ), |φ| O(1) (Section 3).The latter algorithm is the first space-efficient algorithm for widthparameterized SAT.In some sense, we are doing even harder work than [AR02], since the underlying graph in that paper is the primal graph.If we combine the DP and the recursive algorithms in the obvious way, then we gain the worst of both worlds.Here "obvious" means that we discretize the space of truth assignments during the execution of the recursive algorithm and combine using DP.Instead, we introduce an implicit infinite family of proof systems.We use two free parameters to specify an algorithm in this family.One parameter is an integer greater than 2. This controls the "complexity" of the rules applied, for performing an unbalanced type of recursion of some sort.The larger this parameter is the more space and the smaller the running time is.The second parameter is a real number in (0, 1) that controls the discretization of the truth assignment space.This family of algorithms is presented in Section 4. In the same section we show that all infinite pairs of values are of interest depending on different time-space bounds one may want to achieve.
Section 5 contains some preliminary complexity theory results for width-parameterizations.We show that the problem SAT tw , where the CNF formula is given together with the tree decomposition is computationally harder than the problem SAT pw where the CNF formula is given with a path decomposition of the same value.In particular, SAT tw for tree-width Θ(log |φ|) is harder than SAT pw of path-width Θ(log |φ|), unless NL = SAC 1 , a standard complexity assumption (e.g.[BCD + 89]).Note that this is not true in general for other width parameters.For example, although path-width and band-width combinatorially may be off by an exponential, under log-space transformations they behave the same [GP08].We also show that there is no trivial way to sparsify SAT tw unless a scaled and non-uniform version of NP = coNP fails.

Preliminaries
We introduce notation, terminology, and conventions used throughout the paper.We also provide a rather elementary introduction on how an algorithm may exploit the structure of bounded tree-width formulas.

Notation
All logarithms are of base 2, and all propositional formulas are in Conjuctive Normal Form (CNF).SAT is the decision problem where given an arbitrary CNF formula we want to decide if it is satisfiable.k-SAT denotes the restriction of SAT to CNFs where each clause has at most k literals.For a formula φ, m denotes the number of clauses, n the number of variables, and C i and x j stand for the i-th clause and j-th variable respectively.For convenience we write |φ| = m + n.The notation O * , Ω * and Θ * suppresses polynomial factors.

Tree-Width
Definition 1.Let G = (V, E) be an undirected graph.A tree decomposition of G is a tuple (T, X), where T = (W, F ) is a tree, and (3) ∀i, the set {t : i ∈ X t } forms a subtree of T .each of X i is called a bag, the width of (T, X) is defined as max t∈W |X t | − 1, and the tree-width T W(G) of graph G is defined as the minimum width over all possible tree decompositions.
When the tree decomposition T = (W, F ) is restricted to a path, the decomposition is called path decomposition, and the specific tree-width is called path-width PW(G).The following inequality holds( [Bod98]) Definition 2. The incidence graph G φ of a SAT instance φ is a bipartite graph, where in one side of the bipartization each node is associated with a distinct unsigned variable, and in the other each node is associated with a clause.There is an edge between a clause-node and a variable-node if and only if the variable appears in a literal of the clause.The tree-width of a formula φ is the tree-width of its incidence graph, T W(φ) = T W(G φ ).When it is clear from the context we may abuse notation and write T W(φ) to denote the width of a given decomposition of G φ .
We assume that a tree decomposition of the incidence graph of φ is given as input along with φ.For convenience, we assume the input tree decompositions have the following two properties. (1 (2) The tree T has bounded degree 3.
Tree decompositions satisfying the two properties are called nice.A tree decomposition can be converted to a nice one in linear time ([Klo94][Bod98]).Notation d is used to denote the maximal degree in the tree decomposition.By the property above, d ≤ 3. When the input is given with a path decomposition, d is actually upper bounded by 2.
Remark 1.The parameter d affects the performance of our algorithm significantly, to fully exploit the structure of the input decomposition, we prove most of our results parameterized by d.One may replace it by 2 or 3 when the structure of the input decomposition is guaranteed to be a path or a tree.

Truth assignments, assignments, and tree decompositions
The structure of a tree decomposition is associated with the concept of separability(e.g.[Bod98]).Intuitively, the smaller the tree-width is, the easier the graph can be broken into separate components by removing nodes.It is the separability that allows us to device more efficient algorithms for small tree-width SAT, than for general SAT.In some sense, the given tree decomposition allows us to "localize" the exhaustive search.The following example sheds some light on how this can be done.For the sake of simplicity, we make an additional assumption on the tree decompositions given in the input, that all the variables of a clause appear in the same bag with the clauses.We will see later that removing this assumption is non-trivial.
Suppose x i 's, x ′ i 's and x ′′ i 's are different sets of variables, and the tree decomposition is as in Figure 1a.Some clauses depending only x ′ i 's or only x ′′ i 's are not drawn explicitly but are placed in the bags as indicated.Suppose that we fix a truth assignment to the variables in the bag in the middle, e.g.x 1 = x 2 = x 3 = x 4 = 1.Conditioned on this truth assignment, we can simplify the instance by removing clauses that are already satisfied, and removing literals in a clause which are set to false.This will result-in multiple subproblems as shown in Figure 1b.Assured by the property of a tree decomposition, the subproblems depend on different set of variables, i.e. they are independent.Since if instead they shared a common variable, this variable must also wuld have appeared in the middle bag, e.g.x 2 .At this point this variable must have been fixed to a truth assignment, thus removed in the simplification procedure.
The satisfiability of the input instance, conditioned on the truth assignment given to the middle bag, is determined by the satisfiability of the two separate subproblems.Therefore, it suffices to enumerate all truth assignments satisfying all the clauses in the middle bag without causing empty clauses in the simplification phase.Then, solve the two resulting subproblems separately to decide the satisfiability of the original instance.Furthermore, this "splitting" operation can be invoked recursively, by carefully choosing the "middle" bag.
In each recursive step, the most time-consuming part is to enumerate all the assignments satisfying all the clauses in the chosen bag, which costs O * (2 T W(φ) log |φ| ) time, and the total running time is O * (2 T W(φ) log |φ| ), which is much better than the currently best algorithms for general SAT which run in the exponential in n.The algorithm described above will be formalized as the space-efficient algorithm in Section 3.4.

The subtle additional assumption
The assumption that all variables of a clause appear in the same bag with the clause is not a mild one (especially for CNFs of large cardinality).In general, we may have to delay the decision to satisfy a clause.In the above algorithm, we only store the truth assignments to the variables.The following example shows that only storing this information is not enough, when aiming at removing the assumption.Suppose x 5 and C 7 = x 6 .Three instances φ 1 , φ 2 and φ 3 along with their tree decompositions are given in Figure 2, where C 5 is missing).We say that a clause is satisfied by a literal under a truth assignment if the literal appears in the clause and is set to 1.If an instance is satisfiable, then there is a truth assignment where every clause is satisfied by one of its literals.Now, consider the splitting operation on the middle bag by fixing a truth assignment to it as above.For all three instances, the only possible assignment for x 6 is 0, since C 7 must be satisfied by x 6 = 0. Similarly, in the left bag, we must assign x 2 = 0 and x 3 = 0 to satisfy C 3 and C 4 .In the left bag, the only variable left is x 1 , which can satisfy either C 1 or C 2 , but not both.The three instances differ in the right part, where two variables x 4 and x 5 are left.
Satisfying C 5 requires x 4 = 0, then C 1 can not be satisfied by x 4 .Similarly, satisfying C 6 requires x 5 = 0, then C 2 can not be satisfied by x 5 .In order to find a satisfying truth assignment, when processing the right part, we need the information which of C 1 , C 2 is already satisfied in the left part.φ 1 is not satisfiable, so whichever does not affect the result.φ 2 is satisfied only when C 1 is already satisfied, while φ 3 is satisfied only when C 2 is already satisfied.This piece of information is not carried through the middle bag by just the truth assignment to the variables.
To overcome this issue we are going to use "clause-bits".In fact, the semantics of these bits is a non-obvious issue which significantly affects the running time of our algorithms.

Notation and terminology
We introduce terminology and notation to talk about truth assignment on bags.Let X be a bag in the tree decomposition, V be the variables and C be the clauses appear in X.Also, n V = |V| and m C = |C|.An assignment R X for X is a binary vector of length n V + m C .The first n V bits indicate the truth values of the corresponding variables.Note that the term "assignment" does not correspond only to a "truth assignment" on the variables in X.It is an assignment of bit values both to variables and to clauses.
What values the last m C bits have is a subtle issue explained in Section 3.For the first, dynamic programming algorithm, things are pretty clear.However, for the space-efficient and trade-off algorithms, things become more subtle.Intuitively, a bit corresponding to a clause C is 1 if we "have decided" to satisfy this clause (this has to do at which part of the execution of the algorithm we are), and it is different for different algorithms.
Actually, the most straightforward way of defining the clause bits is to let it denote whether the corresponding clause "is" satisfied.To ensure that a clause is satisfied in one of the branches in the tree decomposition, we need to enumerate all 2 d − 1 combinations that on which branches the clause is satisfied.However, if one is interested in only in the satisfiability problem (and not e.g. in #SAT) we observe that only d combinations can do the job.

Basic algorithmic results
We give the two basic algorithms.These serve as building blocks for the algorithms in Section 4. The first baseline algorithm (Section 3.1) is doing dynamic programming, and it runs simul- ) .The way this algorithm goes is standard in the literature of algorithms that compute using a tree decomposition [?].The second algorithm is recursive and it runs in time-space O * (3 T W(φ) log |φ| ), |φ| O(1) .Before presenting this space-efficient algorithm we introduce more terminology and lemmas (Sections 3.2, 3.3) dealing with truth assignments on tree-decompositions.This level of generality is not necessary if it is only used for the space-efficient algorithm.Full use of this generality is made in Section 4 where we give the time-space tradeoff algorithms.

Time-efficient algorithm
A binary array satisfiability[•, •] indexed by X and R X is defined, where X is the root of the subtree in the tree decomposition, R X is an assignment to X. satisfiability[X, R X ] = 1 means that there exists a satisfying assignment to the subtree rooted at X, such that the assignment to X is R X .
The values of the array can be computed in a bottom-up fashion.When computing values for a bag X, let Consistent means: bits corresponding to the same variable in R X and in R X i 's are the same; if a bit corresponding to a clause C in R X is assigned 0, or is assigned 1 and C is satisfied by a variable in X, the bits in all R X i 's for C are set to 0, otherwise, the bits in all R X i 's for C are set to 1.Note that the notion of consistency here is different than the notion introduced in the next section.Suppose X r is the root of the tree decomposition, if satisfiability[X r , R Xr ] = 1 for some R Xr , then the instance is satisfiable.This can be proved by induction on depth of the tree , together with the construction of the satisfiability table and the property of a tree decomposition.satisfiability table requires O * (2 T W(φ) ) space.Filling the entries as described above requires O * (2 (d−1)T W(φ) ) time, where d is the maximum degree in the tree decomposition.Recall that we have assumed a normal form on the tre decomposition where d = 3.

Splitting Node
The operation of splitting the tree at a node is an essential step for the space-efficient and tradeoff algorithms.
Definition 3 (splitting operation).Let T = (V, E) be a tree, and v ∈ V .Splitting T at v is the following operation.Let T 1 , . . ., T k be the trees after removing v from T .The splitting operation results-in a forest {v} ∪ T 1 , . . ., {v} ∪ T k , where {v} ∪ T i is the subtree induced by the nodes in T i together with v.We call v the splitting node of this operation.
The node at which we split a tree is labelled as a splitting node.Given a tree T together with a sequence of splitting operations results-in a forest where each subtree in the forest in general has many splitting nodes.The following Lemma 1 is somewhat reminiscent to the well-known " 1 3 -2 3 lemma" for binary trees.Lemma 1 together with Corollary 1, ensures that it is possible to efficiently choose a balancing splitting node in a tree of constant degree; i.e. a splitting node where the sizes of the trees in the resulted forest is linear in the number of nodes of the tree.
Lemma 1.Consider a tree of size N , a leaf s and 0 < α < 1.Then, there is a node p, where one of the trees containing s resulted after splitting at p is of size ≤ ⌈αN ⌉ and each of the rest is of size ≤ ⌈(1 − α)N ⌉. p is called an α-splitting node.Furthermore, such a p can be found in time polynomial in N .
Proof.Here is an algorithm for finding p. Root the given tree at s and construct a path s ≡ v 1 , v 2 , . . ., v l as follows.At step i, among the children of v i−1 let v 1 be the root of the largest subtree.We claim the there in v j in this path with the desired properties.
Denote by a i the size of the subtree containing s after splitting at v i .It is obvious to see that a 1 = 1, a l = N , and a i strictly increases as i increases.Therefore, there must be a j, such that, a j ≤ αN and a j+1 > αN .We claim that v j is the node we need.If a j+1 − a j = 1, then cutting v j will result in two components, where the size of the component containing s is ⌈αN ⌉, while the other one is of size ⌈(1 − α)N ⌉.If a j+1 − a j > 1, then there must be a branch at v j , meaning that v j has at least two children.Splitting at v j results-in at least three components, the one containing s is smaller than αN , and the largest one among the others is smaller than (1 − α)N .
Corollary 1.On a bounded-degree tree of size N , there exists a node p, such that after splitting at p each subtree is of size at most ⌈N/2⌉.

Splitting nodes and assignments
Consider a tree decomposition and a sequence of splitting operations.This process breaks the original tree to a forest where each subtree ha its splitting nodes.We refer to an assignment on a subtree as the assignment that corresponds only to its splitting nodes.Let T be a subtree with splitting nodes S. For a tree T with splitting nodes S, splitting at a node p results in multiple subtrees {T i }, each T i with its splitting nodes S i .Denote by X * = ∪ v i ∈S X i , and let V be the variables and C the clauses which appear in X * ; this is the set of variables and clauses on which we define assignments.Suppose R T is an assignment to T , and R T i is an assignment to the subtree T i .R T and all the R T i 's are said to be consistent if (1) for every i, the bits corresponding to a variable x in R T i is the same as in R T (2) for a clause C, a) if C appears in X * and is assigned 0, then ∀i every bit for C in R T i is assigned 0 b) otherwise, ∃ exactly one i such that in R T i the bit corresponding to C is assigned 1.
Remark 2. The latter point in the definition, where in exactly one of the subtrees we require that the corresponding bit equals to 1, is somewhat subtle.Note that it has a significant effect in the running time of the algorithms.The following lemmas crucially depend on this issue.
The following two lemmas upper bound the number of assignments in two different situations.In what follows we assume that there is an initial tree decomposition together with a sequence of splitting operations that result-in the subtrees along with their splitting nodes.
Lemma 2. For a tree T with splitting nodes S, the number of assignments is at most , the number of variables and clauses in X * are at most |S|T W(φ).So the number of assignment is at most 2 |S|T W(φ) .Lemma 3.For every assignment R T to the tree T , the number of assignments R T i to subtrees T i 's consistent with R T is at most d T W(φ) .
Proof.Let X p be the bag corresponding to the splitting node p.For each variable x in the bag X p , there are 2 possible assignments of x in the subtrees {T i }.For each clause C in X p , if C appears in R T and is assigned 0, by the definition of consistency, each appearance of C in the {T i }'s is assigned 0. Otherwise, in exactly one {T i } C is assigned to 1; in this case there are at most d valid assignments.
Definition 4. For a tree T with splitting nodes S, an assignment R T is satisfying if there exists a truth assignment A to every variable in T , such that (1) every truth value for a variable in R T agrees with the corresponding value in A.
(2) every clause C that appears in T where C does not appear in S, is satisfied by A.
(3) every clause C that appears in S and is assigned 1 by R T is such that C is satisfied by A.
The following lemma shows how to determine the satisfiability of an assignment recursively.
Lemma 4.An assignment R T is satisfying if and only if there exist assignments R T i to the subtrees T i , such that the assignments R T i are consistent with R T and each of the R T i are satisfying.
Proof.For a tree T with splitting nodes S, suppose that splitting at node p results-in the several subtrees {T i }.
Suppose that the assignment R T is satisfying, by Definition 4, there exists a truth assignment on variables within T .Using the truth assignment, we can always find assignments R T i consistent with R T , such that for these truth assignments the conditions in Definition 4 are met.
For the other direction suppose that there exist assignments R T i of the subtrees T i , such that the assignments R T i are consistent with R T and all R T i are satisfiable.For each subtree T i , there exists a truth assignment complying to Definition 4. Since all these truth assignments agree with on their common variables, we can get a truth assignment from their union, which also meets the axioms in Definition 4. Therefore, the assignment R T is satisfiable.

Space-efficient algorithm
The space efficient algorithm is based on the observation that in every degree-bounded tree we can always find a node, such that by splitting at that node every subtree has size no more than half of the original tree (Corollary 1).
Then, the recursive algorithm works as follows: find the splitting node, fix the assignments for all subtrees, and then recurse on the subtrees after the splitting.The algorithm is summarized in Algortihm 1. T is a tree with previous splitting nodes S, and R T is the assignment fixed on the tree.A subtle point that affects the running time of this algorithm is addressed in Remark 2.
Algorithm 1 SAT(T , R T ) 1: if every nodes in T are previous splitting nodes then Regarding its correctness, after the splitting, by the property of a tree decomposition, all the variables shared by different components must have been fixed at the splitting node, namely there will be no consistency problem among the components.By induction, it can be shown that SAT (T ′ , A) corresponds to the satisfiability of the (sub)tree decomposition T consistent with all assignments A. Therefore, SAT (T 0 , ∅), where T 0 is the input tree decomposition, corresponds to the satisfiability of the instance.
This algorithm requires only |φ| O(1) space, because there are only O(log |φ|) assignments to be stored during the process.The running time can be written as follows.Suppose T (N ) is the running time on a decomposition with N nodes.By Lemma 3

Algorithms for time-space tradeoffs
If we combine the baseline algorithms of the previous section in the obvious way by considering blocks of truth assignments, we obtain the worse of the two worlds (do you see why?).In this section we establish Theorem 1 below, by exhibiting a family of algorithms that achieve time-space tradeoffs.To that end, we introduce a new algorithmic technique in which we make non-black-box use of the two simple algorithms.Each algorithm in this family is identified by two parameters (ǫ, c).Moreover, we show that both of these parameters are necessary to achieve different time-space tradeoffs.Parameter 0 < ǫ < 1 corresponds to the granularity of the discretization of the assignment space, whereas the integer parameter c ≥ 2 has to do with the "complexity" of the rule applied recursively.
Theorem 1.For every integer c ≥ 2 and ǫ, where 0 < ǫ < 1, a SAT instance φ with a tree decomposition of width T W(φ) and N nodes, can be decided in time O * 3 (λc(log N −c)+c)(1−ǫ)T W(φ) and in space O * 2 cǫT W(φ) for a constant λ c .λ c is a constant depending on c.To be more specific, λ c is defined as − log x c , where x c is the root with largest absolute value of the polynomial equation:

Splitting Depth
A splitting algorithm A on a tree, computes a function where given a tree T together with previous splitting nodes S, it returns a node where the next splitting operation is going to be performed.
Definition 5. c-splitting depth SD c (A, T , S) of a splitting algorithm A on tree T with previous splitting nodes S is inductively defined as follows: where p is the output of A on T and S, C T ,S,p is the set of subtrees by splitting at p in tree T with previous splitting nodes S Intuitively, splitting depth is the recursion depth of the splitting algorithm.c-minimal splitting depth MSD c (T , S) is the minimum value of SD c (A, T , S), over all splitting algorithms.The case of ∞ is for well-definiteness.

Assignment Group
For a tree T with previous splitting at nodes S, splitting a node p results in several subtrees {T i }, each T i with splitting nodes S i .By Lemma 2, there are at most 2 |S|T W(φ) different assignments.An ǫ-assignment group (ǫ-GR T ) is a set of binary strings of length at most |S|T W(φ), in which (1 − ǫ)T W(φ) entries corresponding to each previous splitting node are fixed to some constant value.
Consider the case of a tree T with previous splitting nodes S. Suppose S contains 4 variables x 1 , x 2 , x 3 , x 4 and 3 clauses C 1 , C 2 , C 3 .An example of ǫ-GR T is as follows : x 1 , x 4 , C 2 , C 3 are fixed to 1,1,0,1, and x 2 , x 3 , C 1 are not fixed.The ǫ-GR T contains 8 = 2 3 binary strings.
ǫ-GR T and ǫ-GR T i 's are said consistent if and only if there exists a way to assign a value to each of the unfixed values in T (as R T ) and T i 's(as R T i 's), such that R T and R T i 's are consistent.
For a tree T and ǫ-GR T , fix (1−ǫ)T W(φ) bits correspond to variables and clauses contained in the splitting node p, one can derive ǫ-GR T i for each subtree T i .Note that the fixed entries for the splitting node p may be different among subtrees, and the unfixed entries in T need not to be fixed in subtrees.For the number of different combinations, the following important lemma holds.
Lemma 5.The number of distinct of ǫ-GR T i 's consistent with ǫ-GR T is at most d (1−ǫ)T W(φ) .
Proof.For each variable x, there are 2(≤ d) possible values.For each clause C, let d 0 (≤ d) be the number of subtrees created by splitting at p.There are three different cases.
Suppose that C does not appear in any previous splitting node.This implies that C only appears in T , then there are d 0 possible way of assigning values to the bit for C, s.t.exactly one of T i 's whose bit for C is set to 1.
Suppose that C appears in some previous splitting nodes, and its value is fixed in ǫ-GR T .If the bit for C is assigned 1, then there are d 0 possible assignments to C similar as above, otherwise, the only possible way is to set all bits for C to 0.
Suppose that C appears in some previous splitting nodes, but its value is unfixed.C must appear as unfixed in at least one subtree.Without loss of generality, we assume that C appears in subtrees T 1 , T 2 • • • T e 0 , where e 0 ≥ 1.The values of C in T 1 , T 2 • • • T e 0 are still unfixed, so there are d 0 − e 0 + 1 ≤ d 0 possible assignments of C in the subtrees T e 0 +1 , • • • , T d 0 , the first one sets all to 0, and the i(≥ 2)-th one sets the bit of C in the subtree T i+e 0 −1 to 1 and the rest to 0.
Since there are at most (1 − ǫ)T W(φ) unfixed values in p, the number of different combinations of ǫ-GR T i consistent with ǫ-GR T is at most d (1−ǫ)T W(φ)

Warm-up: a tradeoff algorithm for a given path decomposition
Here we are dealing with the simpler case where we are given a path decomposition of the incidence graph of a formula, together with the formula (the main complication occurs for tree decompositions).Algorithm 2 depicts the framework of a tradeoff algorithm, where T is a path decomposition, S is a set of previous splitting nodes, ǫ-GR T is an assignment for T with S. This family of algorithms is parameterized with (i) ǫ and (ii) the splitting algorithm in line 10.
Let PW(φ) be the width of the given decomposition.The splitting algorithm chooses the node in the center of the corresponding path segment such that the splitting operation results-in two almost same-length segments.
Each segment will contain at most 2 previous splitting nodes throughout this procedure.By Lemma 3, the number of assignments in each segment is at most 2 2PW(φ) .Now, we consider a ǫ-GR T of T .There are at most 2 2ǫPW(φ) assignments R T ∈ ǫ-GR T .Number them from 1 to |ǫ-GR T |.Denote by M (T , ǫ-GR T ) a 2 2ǫPW(φ) array, where the i-th entry indicates whether the i-th assignments of ǫ-GR T can be satisfied.M (T , ǫ-GR T ) can be computed by Algorithm 2. This algorithm has structure similar to the recursive algorithm, but instead of fixing an assignment of two sub-segments it fixes only (1 − ǫ)PW(φ) bits and recurses on the two components with two ǫ-assignment groups.Intermediate results are stored to save time as in the dynamic-programming algorithm.
Algorithm 2 SAT-hybrid(T , S, ǫ-GR T ) 1: M (T , ǫ-GR T ) ← all zero matrix 2: if all nodes in T are previous splitting nodes then 3: Let R T be the jth assignment in ǫ-GR T

5:
if all entries for a clause in R T assigned 1 are satisfied by some variables in T then 6: end for 9: else 10: Split at the node returned by a splitting algorithm given T , S 11: Denote the subtrees after the splitting as T i 's

12:
for all ǫ-group assignments ǫ-GR T i ∀i, which are all consistent with ǫ-GR T by fixing (1 − ǫ)T W(φ) entries do Let R T be the jth assignment in ǫ-GR T 16: end for 23: end if 24: return M (T , ǫ-GR T ) The algorithm will recurse log |φ| times.In each recursive step, we only need O(2 2ǫPW(φ) ) bits to store the array M .Hence, we use space O * (2 2ǫPW(φ) ).At every step of the recursion, we need to call the algorithm recursively O(2 (1−ǫ)PW (φ) ) times.So, the running time is The correctness follows from the correctness of the recursive algorithm given in Section 3.4.Basically, this algorithm enumerates all the assignments as in the recursive algorithm except that some intermediate results are stored to reduce running time.

A tradeoff algorithm for a given tree decomposition
The tradeoff algorithm for the given tree decomposition is again Algorithm 2, where we implement line 10 differently than in the case of a given path decomposition.
The main technical complication.The idea of splitting at the center node as in the previous section does not work any more.Such splittings may create subtrees with more than 2 previous splitting nodes.In fact, the way we dealt with this in Section 3.4 was not to do anything.But now, we have to deal with assignment groups and thus the space requirement may be as bad as Ω * (2 cǫT W(φ) ), where c is the maximum number of previous splitting nodes in the recursion.Overcoming this issue requires a new idea.Implementing this idea results-in an algorithm with the property that throughout its execution the number of splitting nodes in the recursive procedure is ≤ 2, or more generally a constant.
Let α be a parameter satisfying 0 < α < 1/2.A type ℓ tree is defined to be a tree with ℓ previous splitting nodes.Here is a splitting algorithm H 2 satisfying the restriction mentioned above.This specific splitting algorithm is an implementation of line 10 (i.e.replace the box in line 10 with Algorithm 3).
Algorithm 3 Splitting algorithm H 2 with T , S as parameters return the 1/2-splitting node 3: else if T with S is a type 1 tree then 4: consider the previous splitting node as the root 5: return the α-splitting node 6: else if T with S is a type 2 tree then Putting everything together Utilizing this splitting algorithm, we obtain an algorithm for tree decompositions.Denote by T 1 (N ), T 2 (N ) the running time of H 2 on type 1 or type 2 tree each of N nodes respectively.
Splitting a type 1 tree will result in multiple type 1 trees with size at most (1 − α)N and one type 2 tree with size at most αN , so we have Splitting a type 2 tree, when the 1/2-splitting is on the path between p 1 and p 2 will result in two type 2 trees with size at most N/2 and multiple type 1 trees.Otherwise, the splitting operation will result in two type 2 trees with size at most N/2 and several type 1 trees.So, we have By solving these recurrences, the running time and space of the hybrid algorithm can be summarized as follows.
2 , we have Therefore, we have Since type i , i ≥ 3 trees are not allowed, the space requirement is O * (2 2ǫT W(φ) ) Optimality of the splitting procedures The splitting algorithm presented above is a specific one without creating type i , ∀i ≥ 3 trees.Actually, it can be shown that this specific splitting algorithm is optimal modulo our technique.
Definition 6. Denote by A c (∀c ≥ 2) the family of algorithms for SAT with bounded tree-width following the framework in Algorithm 2 which use a splitting algorithm without creating type i trees ∀i > c.
We lower bound the running time of all algorithms in A 2 .The hard instance comes from fibonacci trees.Definition 7.For any positive integer h, a h-fibonacci tree(denoted as F h ) is recursively defined as following, (1) if h = 1, F h contains only 1 node; (2) if h = 2, F h contains 2 nodes and one edge between them; (3) if h > 2, F h is constructed by a root connecting two subtrees F h−2 and F h−1 .
An extended (h, r)-fibonacci tree (denote as F * h,r ) is constructed by adding one edge between the root r and the root of subtree F h .

Figure 5: An h-fibonacci tree (F h ).
An h-fibonacci tree is indeed the worst-case for splitting algorithms without creating type i trees ∀i ≥ 3. Formally, we have the following lemma.Lemma 6.For each h ≥ 1, in an extended (h, r)-fibonacci tree, suppose r is a splitting node, let N be the size of the tree.Then every splitting algorithm which does not create type i trees ∀i ≥ 3 runs in Ω * (d 1.441(1−ǫ)T W(φ) log N ) time.
Before getting into the proof, we define two special type 1 and type 2 trees : T 1,h and T 2,h .A T 1,h tree is constructed by a splitting node connected to a subtree F h , and a T 2,h tree constructed by two splitting nodes connected to another node which has a subtree F h .
Claim 1.The lower bound of processing time for tree T 1,h is Ω * (d (1−ǫ)T W(φ)h ), and for tree T 2,h , the lower bound is Proof.We proceed by induction.Base cases are trivial where h ≤ 2. Suppose the statement is correct for any h 0 < h.For tree T 1,h , by inductive hypothesis, if we split at the root of F h , the processing time is at least Ω * (d (1−ǫ)T W(φ)(1+(h−1)) ), if we split at some node inside the subtrees ).So the lower bound for tree T 1,h is Ω * (d (1−ǫ)T W(φ)h ).For tree T 2,h , we must split at the node connecting two splitting nodes, so again by inductive hypothesis the lower bound is Ω * (2 (1−ǫ)T W(φ)(1+h) ).
Combining the above lemma and the algorithmic result, the following theorem can be proved, which states that our algorithm is optimal within A 2 .Theorem 3.For fixed ǫ, 0 < ǫ < 1, the running time of an optimal algorithm in A 2 is Θ * (3 1.441(1−ǫ)T W(φ) log N ).

Generalized tradeoff algorithm for a given tree decomposition
It is natural to ask if the algorithm can be generalized to allow up to type c trees for some c ≥ 3. Indeed, as c increases the running time decreases while the space requirement increases.If we want the tradeoff to make sense, the parameter ǫ must be restricted to some specific range.
First, we need to generalize the splitting algorithm to allow type i trees for i up to c.For arbitrary 1 ≤ i ≤ c, consider splitting a type i tree: suppose the splitting node is p.If p is on the path between some pair of previous splitting nodes, splitting at it will result-in several type j (j ≤ i) trees, otherwise, splitting will result-in several type 1 trees and one type i+1 tree.Formally, when splitting a type i tree, we invoke algorithm H c to determine the splitting node, which can be seen as an implementation of line 10 in Algorithm 2. suppose T with S is a type i tree 5: if the number of nodes in T is less than 2 c−i then 6: return the 1/2-splitting node arbitrarily pick a previous splitting node as root 9: compute a α c,i -splitting node q 1 10: if q 1 is not on the path between any pair of previous splitting nodes then 11: return q 1 12: else 13: compute a 1/2-splitting node q 2 .14: if q 2 is not on the path between any pair of previous splitting nodes then 15: return the least common ancestor of q 2 and all previous cutting nodes 16: end if 21: end if Each α c,i for any 1 ≤ i < c is a parameter satisfying 0 ≤ α c,i ≤ 1/2.To prevent type c+1 trees, splitting nodes of type c trees must be on the path between some pair of existing splitting nodes, this is assured by setting α c,c = 0.For a fixed c, the running time and space of the algorithm solving SAT of bounded tree-width utilizing the splitting algorithm A are summarized in Theorem 1(see page 11).The following lemmas are the building blocks used to conclude the theorem.
Lemma 7.For every c ≥ 2, tree T with N nodes and splitting nodes S, let Proof.Without loss of generality, suppose N ≥ 2 c .Consider splitting a type i tree with splitting nodes S, 1 ≤ i < c.If the α c,i -splitting-node m is not on the path between any pair of previous splitting nodes, splitting at m will result in multiple type 1 trees of size at most ⌈(1−α c,i )N ⌉ and one type i+1 tree of size at most ⌈α c,i N ⌉.Otherwise, since 1 − α c,i > 1/2, the maximal possible size of a type 1 tree created by any splitting node will not exceed ⌈(1 − α c,i )N ⌉.Splitting at the 1/2-splitting-node c will result in multiple type j (j ≤ i) trees of size at most ⌈N/2⌉, otherwise, splitting at the least common ancestor of c and all previous splitting nodes as p, will result in multiple type 1 tree of size at most ⌈(1 − α c,i )N ⌉ and many type j (j ≤ i) trees with size at most ⌈N/2⌉.In summary, Now, consider splitting a type c tree with splitting nodes S. Since α c,c = 0, we always ignore the (1 − α c,i )-splitting-node m.Splitting at the 1/2-splitting-node c will result in multiple type j (j ≤ i) trees of size at most ⌈N/2⌉.Splitting at the least common ancestor of c and all previous splitting nodes will result in multiple type 1 tree with size at most N and multiple type j (j ≤ i) trees with size at most ⌈N/2⌉.Namely, Proof.Let D ′ c,i (N ) be a function satisfying the following equations, ), and Combining with the previous lemma, it can be easily proved by induction that D ′ c,i (N ) upper bounds D c,i (N ) for all c, i.Specifically, Furthermore, it can be proved that the space resource can be fully exploited to minimize the running time, which is of practical importance.More specifically, the following holds true.
, then γ c is the root of f (X) = 0 with largest absolute value.We know f (2) = 1 > 0, so if we can prove f (2 − 1 2 c 2 ) < 0 then there must be a root between 2 and 2 − 1 The last inequality is true because .
Given the upper bound on λ c , the corollary can be proved as follows.
Optimality Similarly to the second half of the previous section, we also prove the optimality of the generalized tradeoff algorithm.We construct the hard instance using generalized fibonacci trees.
Definition 8.For any integer c ≥ 2, and a positive integer h, a (c, h)-fibonacci tree(denoted as F c,h ) is defined as by one of the rules, (1) if h ≤ c, F c,h is a chain of 2 c nodes; (2) if h > c, F c,h is constructed by starting from a chain of c nodes, then replacing the ith node by a subtree F c,h−i .
An extended (c, h, r)-fibonacci tree (denote as F * c,h,r ) is constructed by connecting one root node r to a subtree F c,h .
See Figure 9 for an illustration of a (c, h)-fibonacci tree.A (c, h)-fibonacci tree is indeed the hardest input of the splitting algorithm.To be more specific, the following lemma holds.
Lemma 10.For each h ≥ 1, MSD(F * c,h,r , {r}) ≥ h.Proof.For any c ≥ 2, h > c and 1 ≤ w ≤ c, the tree G c,h,w is defined as follows, first construct a chain of length w, connect c − w + 1 splitting nodes to the first node of the chain, and connect a subtree F c,h−c+w−i to i-th node of the chain.Denote S ℓ as the set of the ℓ splitting nodes connected to the first node of the chain.We prove that MSD(G c,h,w , S c−w+1 ) ≥ h − c + w, which implies the inequality that we need.Specifically, The inequality is proved by induction on h.The basic case is trivial.Suppose for any h < h 0 , MSD c (G c,h,c , S c−w+1 ) ≥ h − c + w.Now we prove MSD c (G c,h 0 ,c , S 1 ) ≥ h 0 − c + w by induction on w.When w = 1, to prevent type i tree for i > c, we must split at the first node of the chain.Therefore, , where δ c,i is at most constant times of 2 c and γ c,i is the i-th root of the equation f (X) = 0.

An algorithm optimal in our framework
As mentioned in Remark 3, for fixed c ≥ 2, an optimal splitting algorithm, i.e. with smallest splitting depth implies an optimal algorithm in A c .Indeed, the following lemma assures that such an optimal splitting algorithm can be in quasi-polynomial time.
Lemma 11.For a tree T with N nodes, MSD c (T, ∅) can be computed in time O * N MSDc(T,∅) and polynomial space.
Proof.For any h, whether MSD c (T, ∅) ≤ h in O * (N d ) can be tested by a branch-and-bound algorithm.For any tree T and previous splitting nodes S, enumerate all nodes and check whether the minimal splitting depth of each subtree is at most h − 1 recursively.The maximal depth of the recursion is set to h, thus the running time is O * N h .Therefore, the overall time is at most O * N MSD c (T,∅) .The required space is polynomial.
By applying the splitting algorithm in the previous lemma we obtain the following tradeoff algorithm.

Some remarks on the complexity of bounded width SAT
In this section we separate the complexity of the tree-width parameterized from the path-width parameterized SAT for the same width value, and we initiate the study of the incompressibility and non-sparsification of width-parameterized SAT instances.

More preliminaries and notation
For the first part we proceed by giving a machine characterization of SAT tw (w(n)); the problem of deciding SAT where the CNF formula is given together with a tree-decomposition of width w(n), where n is the input length.[Pap09] gives a machine characterization of SAT pw (w(n)); the corresponding problem for a given path decomposition.We define NL[r(n)] to be the class of problems decidable by a log-space machine equipped  that the corresponding gates are connected.At the bottom layer, each node must be labeled by an input gate or a NOT gate which outputs value 1. See Figure 10a for an example.
A proof tree can be viewed as the witness that a circuit evaluates to 1 on the given input.One may observe that, since we assume that all the circuits are of normal form, every proof tree must have the same shape.The tree of the same shape of a proof tree without labeling is called a skeleton(see Figure 10b).Showing that the circuit evaluates to 1 on an input is equivalent to giving a labeling satisfying the proof tree conditions to the skeleton.
One of the 2 O(log l n) gates in the circuit can be indexed by a O(log l n) bit binary string.For each node v in the skeleton, assign a variable x v using space O(log l n), to indicate the index of the gate that this node be labeled.This variable is also seen as a group of O(log l n) boolean variables.For each pair of connected nodes u, v in the skeleton, and for each pair of possible indices a, b, which can be assigned to x u and x v correspondingly satisfying the conditions of a proof tree, create a clause encoding x u = a ∧ x v = b.All these clauses form an SAT instance whose incidence graph has a tree decomposition with tree width O(log l n) (See Figure 10 for an example and illustration).
Corollary 3. SAT tw (log n) is hard for SAC 1 , under log-space many-to-one reductions.
This corollary follows by the characterization in [Ven87].Therefore, under the standard assumption that NL SAC 1 we separate the complexity of SAT pw (log n) and SAT tw (log n).How about higher width values?In this case we do not have well-established higher analogs of NL SAC 1 .However, the characterization of Theorem 6 together with the main theorem in [Pap09] can be understood in the other direction.This means that the conjectures about the corresponding complexity classes may be true exactly because one may conjecture that SAT tw (w(n)) is harder than SAT pw (w(n)).It seems that there is much more to be done towards this direction.

Incompressibility and non-sparsification
By compressibility of SAT instances we mean that the input instance or parameters can be reduced by an efficient algorithm, in a way that the compressed instance preserves the satisfia-bility.Let us start with some preliminary observations stating that no non-trivial compression can be done to reduce the width parameter.
Suppose we have an instance φ together with an optimal tree decomposition of width T W(φ) = ω(log |φ|), and assume that there is a procedure running in polynomial time, which constructs a new instance φ ′ with tree-width T W(φ ′ ) = 1 2 T W(φ) such that φ ⇐⇒ φ ′ .If we repeat this procedure for log T W(φ) times, we will obtain an instance φ, where T W(φ) is constant and has the same satisfiability as φ.Satisfiability of φ can be determined in polynomial time, and the transformation can also be done in polynomial time, therefore we can determine satisfiability of φ in polynomial time.Under ETH, this is not possible, which implies that determining satisfiability of φ requires 2 Ω(T W(φ)) time.Namely, such a procedure cannot exist.
Next we turn to the question of interactively "compressing" the instance length.The literature refers to this process as sparsification.[DvM10] shows that in order for a polynomial-time bounded machine to decide 3-SAT with the help of an unbounded oracle, if the number of bits needed to be sent to the oracle is O(n 3−ǫ ), where n is the number of variables and ǫ > 0, then NP ⊆ coNP/poly.Let L be a language, denote OR(L) be the problem of asking whether one of the input instance belongs to L. The following lemma is crucial for the proof.
Lemma 12 ([DvM10]).Let L be a language, with instance size s and t : Z + → Z + be polynomially bounded s.t. the problem of OR(L) with t(s) instances can be decided by sending O(t(s) log t(s)) bits, then L ∈ coNP/poly.
Lemma 13.If a 3-SAT pw (w(n) log n) instance can be decided by sending O(n 1−ǫ ) bits to the oracle, then NL[w(n)/ log n] ⊆ coNP/poly.
Proof.Obviously, s is at most polynomial in n.Consider an OR(3-SAT pw (w(n))) instance, which contains t(s) 3-SAT pw (w(n)) instances each with n variables can be represented by a 3-SAT pw (w(n)) instance with t(s)s variables.Assume all the instances use different variables.Suppose the instances are φ i , ∀i, and each has a corresponding path-decomposition P i , variables v i,j , clauses C i,j .Simply joining path-decompositions will impose an AND-relation instead of an OR-relation.To impose an OR-relation, first join the path-decompositions sequentially, let a be a selector, for each P i , replace each clause C i,j by a clause representing (a = i) → C i,j = (a = i) ∨ C i,j .a can be implemented by O(log t(s)) = O(log n) variables appearing in every bag.One last step is that each newly created clause is of O(log n) variables, to break each of them into clauses of 3 variables by standard technique, O(w(n) log n) variables need to be introduced.In the end, we constructed a 3-SAT instance with path-width w(n) log n.Now by hypothesis, this instance of t(s)s variables can be decided by sending (t(s)s) 1−ǫ bits, by Lemma 12, this means 3-SAT pw (w(n)) is in coNP/poly, and by the characterization mentioned before, the lemma follows.

Conclusions
We devised a simple algorithm for deciding the satisfiability of arbitrary CNF formulas, that runs in time 2 O(T W(φ) log |φ|) and space polynomial.We conjecture that doing asymptotically better in the exponent blows up the space to exponential in the tree-width.Our main technical development is a family of deterministic algorithms that achieve tradeoffs by trading constants in the exponent between space and running time.
One issue we did not discuss is whether randomness can be helpful towards better algorithms for tree-width bounded SAT.Take for example Schoening's algorithm [Sch99] for 3-SAT, which achieves running time α n , for a constant α < 2 and space polynomial.Intuitively, this algorithm is oblivious to any structure the given CNF may have.An interesting question is finding a way to exploit the small width structure using randomness.
This paper also initiates an in-depth study of the computational complexity of widthparameterized SAT.One possible direction is understanding the implications of our conjecture; i.e. developing machinery that leads to either proving or disproving it.Another interesting research direction is to obtain stronger sparsification results than those obtained in Section 5.The main technical obstacle towards this goal is that the packing lemma of [DvM10] does not apply in the setting of bounded-width SAT.The reason is that even the first step in the construction of [DvM10] blows up the tree-width from any value (e.g.log 2 n) to linear.That is, following their work the given formula is right away transformed into a formula of huge tree-width.We believe that proving non-sparcification O(n) is possible, and it seems to require the development of new non-sparsification tools.
In general, understanding various aspects of the computational complexity of width-parameterized SAT is an issue left open for future research.
Fixing an assignment to the variables in the middle bag results in two independent instances.

Figure 1 :
Figure 1: An example showing bounded tree-width SAT can be solved efficiently

Figure 2 :
Figure 2: Three instances used in the example.Figures on the top are the input tree decompositions, the bottom figures are the two components after fixing assignment to the variables in the middle bag.

Figure 3 :
Figure 3: Two splitting operations at the black shaded nodes

2 :
if every clause in R T which assigned 1 is satisfied by some variables in T then find the splitting node s, and cut at s, which result in many subtrees T i 9: for all assignments R T i consistent with R T do 10: if for each subtree T i , SAT(T i , R T i ) = true then 11: where by the normal form assumption d = 3, i.e.T (|φ|) = O * (3 T W(φ) log |φ| ).

Figure 4 :
Figure 4: Finding the splitting node in three different cases.
splitting nodes are p 1 and p 2 8: consider p 1 as the root and compute the 1/2-splitting node m 9: if m is on the path between p 1 and p 2 then 10: return the least common ancestor c of m and p 2 13: end if 14: end if

Figure 6 :
Figure 6: Illustrations of two cases for the proof of Lemma 1.
Proof.(Proof of Lemma 6) Set α = 3− √ 5 2 , since the number of nodes in F h is Ω lower bound for running time Ω * d 1

Figure 7 :
Figure 7: Finding the splitting node in three different cases.
For any c ≥ 2, the c-splitting depth of a tree with N nodes by A is λ c (log N − c) + c + O(1).
the c-splitting depth of a tree with N nodes by the algorithm A is upper bounded by λ c (log N − c) + c + O(1), where λ c satisfies c l=1 2 − l λc = 1.Proof.(Proof of Theorem 1) For every c ≥ 2, we solve the above recurrences where N < 2 c .The running time isO * d log N (1−ǫ)T W(φ) when N ≥ 2 c , the running time is O * d (λc(log N −c)+c)(1−ǫ)T W(φ) .The space is upper bounded by O * (2 cǫT W(φ) ) since only type i (i ≤ c) trees are allowed.

Figure 8 :
Figure 8: A tree G c,h,w .
1).Therefore, for any c ≥ 2 and N > 2 c , there exists a tree T with N nodes, such that the c-minimal splitting depth of T MSD c (T , ∅) is at least λ c (log N − c) + c − O(1).
(a) A semi-unbounded circuit with a proof tree highlighted.NOT gates are hidden (b) The skeleton of the proof trees

Figure 10 :
Figure 10: In 10b a SAT tw (log l n) instance is constructed from the skeleton: each node corresponds to O(log l n) boolean variables; clauses are constructed for each dashed circle; and only those variables corresponding to a node shared by different dashed circles must be put into a bag in the tree decomposition, which ensures O(log l n) tree width.

Table 1 :
λ c for small c's 1