Backdoors to SatisfactionResearch supported by the European Research Council (ERC), project COMPLEX REASON 239962.

# Backdoors to Satisfaction††thanks: Research supported by the European Research Council (ERC), project COMPLEX REASON 239962.

Serge Gaspers Institute of Information Systems, Vienna University of Technology, A-1040 Vienna, Austria 11email: gaspers@kr.tuwien.ac.at, stefan@szeider.net    Stefan Szeider Institute of Information Systems, Vienna University of Technology, A-1040 Vienna, Austria 11email: gaspers@kr.tuwien.ac.at, stefan@szeider.net
###### Abstract

A backdoor set is a set of variables of a propositional formula such that fixing the truth values of the variables in the backdoor set moves the formula into some polynomial-time decidable class. If we know a small backdoor set we can reduce the question of whether the given formula is satisfiable to the same question for one or several easy formulas that belong to the tractable class under consideration. In this survey we review parameterized complexity results for problems that arise in the context of backdoor sets, such as the problem of finding a backdoor set of size at most , parameterized by . We also discuss recent results on backdoor sets for problems that are beyond NP.

## 1 Introduction

Satisfiability (SAT) is the classical problem of determining whether a propositional formula in conjunctive normal form (CNF) has a satisfying truth assignment. The famous Cook-Levin Theorem [22, 57], stating that SAT is NP-complete, placed satisfiability as the cornerstone of complexity theory. Despite its seemingly specialised nature, satisfiability has proved to be extremely useful in a wide range of different disciplines, both from the practical as well as from the theoretical point of view. Satisfiability provides a powerful and general formalism for solving various important problems including hardware and software verification and planning [8, 75, 96, 53]. Satisfiability is the core of many reasoning problems in automated deduction; for instance, the package dependency management for the OpenSuSE Linux distribution and the autonomous controller for NASA’s Deep Space One spacecraft are both based on satisfiability [6, 97]. Over the last two decades, SAT-solvers have become amazingly successful in solving formulas with hundreds of thousands of variables that encode problems arising from various application areas, see, e.g., [48]. Theoretical performance guarantees, however, are far from explaining this empirically observed efficiency. In fact, there is an enormous gap between theory and practice. To illustrate it with numbers, take the exponential factor of the currently fastest known exact 3SAT algorithm [51]. Already for variables this number exceeds by far the expected lifetime of the sun in nanoseconds.

#### Hidden Structure and Parameterized Complexity

The discrepancy between theory and practice can be explained by the presence of a certain “hidden structure” in real-world problem instances. It is a widely accepted view that the structure of real-world problem instances makes the problems easy for heuristic solvers. However, classic worst-case analysis is not particularly well-suited to take this hidden structure into account. The classical model is one-dimensional, where only one aspect of the input (its size in bits, or the number of variables for a SAT formula) is taken into account, and it does not differentiate whether or not the instance is otherwise well-structured.

Parameterized Complexity, introduced by Mike Fellows together with Rod Downey offers a two-dimensional theoretical setting. The first dimension is the input size as usual, the second dimension (the parameter) allows to take structural properties of the problem instance into account. The result is a more fine-grained complexity analysis that has the potential of being more relevant to real-world computation while still admitting a rigorous theoretical treatment and firm algorithmic performance guarantees.

There are various ways of defining the “hidden structure” in a problem instance, yielding various ways to parameterize a problem.

#### Islands of Tractability

One way of coping with the high complexity of important problems within the framework of classical complexity is the identification of tractable sub-problems, i.e., of classes of instances for which the problem can be solved in polynomial time. Each class represents an “island of tractability” within an ocean of intractable problems. For the satisfiability problem, researchers have identified dozens of such islands – one could speak of an archipelago of tractability.

Usually it is quite unlikely that a real-world instance belongs to a known island of tractability, but it may be close to one. A very natural and humble way of parameterizing a problem is hence to take the distance to an island of tractability as a parameter. Guo et al. [50] called this approach “distance to triviality”. For SAT, the distance is most naturally measured in terms of the smallest number variables that need to be instantiated or deleted such that the instance gets moved to an island of tractability. Such sets of variables are called backdoor sets because once we know a small backdoor set we can solve the instance efficiently. Thus backdoor sets provide a “clever reasoning shortcut” through the search space and can be used as an indicator for the presence of a hidden structure in a problem instance. Backdoor sets where independently introduced by Crama et al. [27] and by Williams et al. [98], the latter authors coined the term “backdoor”.

The backdoor set approach to a problem consists of two steps: first a small backdoor set is computed (backdoor detection), second the backdoor set is used to solve the problem at hand (backdoor evaluation). It is hence natural to consider an upper bound on the size of a smallest backdoor set as a parameter for both backdoor detection and backdoor evaluation.

## 2 Satisfiability

The propositional satisfiability problem (SAT) was the first problem shown to be NP-hard [22, 57]. Despite its hardness, SAT solvers are increasingly leaving their mark as a general-purpose tool in areas as diverse as software and hardware verification, automatic test pattern generation, planning, scheduling, and even challenging problems from algebra [48].

A literal is a propositional variable or a negated variable . We also use the notation and . A clause is a finite set literals that does not contain a complementary pair and . A propositional formula in conjunctive normal form, or CNF formula for short, is a set of clauses. An CNF formula is a CNF formula where each clause contains at most literals. For a clause we write or , and for a CNF formula we write . An -CNF formula is a CNF formula where each clause contains at most literals. For a set of literals we write . We call a clause positive if and negative if .

For a set of propositional variables we denote by the set of all mappings , the truth assignments on . For we let and be the sets of literals set by to and , respectively. Given a CNF formula and a truth assignment we define . If and , we simple write instead of .

A CNF formula is satisfiable if there is some with , otherwise is unsatisfiable. Two CNF formulas are equisatisfiable if either both are satisfiable, or both are unsatisfiable. SAT is the NP-complete problem of deciding whether a given CNF formula is satisfiable [22, 57].

#### Islands of Tractability and Backdoors

Backdoors are defined with respect to a fixed class of CNF formulas, the base class (or target class, or more more figuratively, island of tractability). From a base class we require the following properties: (i)  can be recognized in polynomial time, (ii) the satisfiability of formulas in can be decided in polynomial time, and (iii)  is closed under isomorphisms (i.e., if two formulas differ only in the names of their variables, then either both or none belong to ).

Several base classes considered in this survey also satisfy additional properties. Consider a class of CNF formulas.  is clause-induced if it is closed under subsets, i.e., if implies for each .  is clause-defined if for each CNF formula we have if and only if for all clauses .  is closed under variable-disjoint union if for any two CNF formulas with , also .  is self-reducible if for any and any partial truth assignment , also .

A strong -backdoor set of a CNF formula is a set of variables such that for each . A weak -backdoor set of is a set of variables such that is satisfiable and holds for some . A deletion -backdoor set of is a set of variables such that , where .

If we know a strong -backdoor set of of size , we can reduce the satisfiability of to the satisfiability of formulas in . Thus SAT becomes fixed-parameter tractable in . If we know a weak -backdoor set of , then is clearly satisfiable, and we can verify it by trying for each whether is in and satisfiable. If is clause-induced, any deletion -backdoor set of is a strong -backdoor set of . For several base classes, deletion backdoor sets are of interest because they are easier to detect than strong backdoor sets. The challenging problem is to find a strong, weak, or deletion -backdoor set of size at most if it exists. For each class of CNF formulas we consider the following decision problems.

Strong -Backdoor Set Detection
Instance: A CNF formula and an integer .
Parameter: The integer .
Question: Does have a strong -backdoor set of size at most ?

The problems Weak -Backdoor Set Detection and Deletion -Backdoor Set Detection are defined similarly.

In fact, for the backdoor approach we actually need the functional variants of these problems, where if a backdoor set of size at most exists, such a set is computed. However, for all cases considered in this survey, where backdoor detection is fixed-parameter tractable, the respective algorithms also compute a backdoor set.

We also consider these problems for formulas with bounded clause lengths. All such results are stated for 3CNF formulas, but hold, more generally, for CNF formulas, where is a fixed integer.

## 3 Base Classes

In this section we define the base classes for the SAT problem that we will consider in this survey.

### 3.1 Schaefer’s Base Classes

In his seminal paper, Schaefer [90] classified the complexity of generalized satisfiability problems in terms of the relations that are allowed to appear in constraints. For CNF satisfiability, this yields the following five base classes111Affine Boolean formulas considered by Schaefer do not correspond naturally to a class of CNF formulas, hence we do not consider them here.

1. Horn formulas: CNF formulas where each clause contains at most one positive literal.

2. Anti-Horn formulas: CNF formulas where each clause contains at most one negative literal.

3. 2CNF formulas: CNF formulas where each clause contains at most two literals.

4. 0-valid formulas: CNF formulas where each clause contains at least one negative literal.

5. 1-valid formulas: CNF formulas where each clause contains at least one positive literal.

We denote the respective classes of CNF formulas by Horn, , 2CNF, -Val, and -Val, and we write . We note that all these classes are clause-defined, and by Schaefer’s Theorem, these are the only maximal clause-defined base classes. We also note that -Val and -Val are the only two base classes considered in this survey that are not self-reducible.

### 3.2 Base Classes Based on Subsolvers

State-of-the-art SAT-solvers are based on variants of the so-called Davis-Logemann-Loveland (DPLL) procedure [29, 30] (see also [23]). The DPLL procedure searches systematically for a satisfying assignment, applying first unit propagation and pure literal elimination as often as possible. Then, DPLL branches on the truth value of a variable, and recurses. The algorithms stops if either there are no clauses left (the original formula is satisfiable) or all branches of the search lead to an empty clause (the original formula is unsatisfiable). Unit propagation takes as input a CNF formula that contains a “unit clause” and outputs . Pure literal elimination takes as input a CNF formula that has a “pure literal” , where and , and outputs . In both cases and are equisatisfiable. If we omit the branching, we get an incomplete algorithm which decides satisfiability for a subclass of CNF formulas. Whenever the algorithm reaches the branching step, it halts and outputs “give up”. This incomplete algorithm is an example of a “subsolver” as considered by Williams et al. [98]. The DPLL procedure gives rise to three non-trivial subsolvers: (unit propagation and pure literal elimination are available), UP (only unit propagation is available), PL (only pure literal elimination is available). We associate each subsolver with the class of CNF formulas for which it determines the satisfiability (this is well-defined, since unit propagation and pure literal elimination are confluent operations). Since the subsolvers clearly run in polynomial time, , UP, and PL form base classes. We write .

### 3.3 Miscellaneous Base Classes

#### Renamable Horn

Let be a set of variables and a CNF formula. We let denote the CNF formula obtained from by replacing for every variable , all occurrences of in with , for . We call a renaming of . Clearly and are equisatisfiable. A CNF formula is called renamable Horn if it has a renaming which is Horn, and we denote the class of renamable Horn formulas as RHorn. It is easy to see that Horn is a strict subset of RHorn. One can find in polynomial time a Horn renaming of a given CNF formula, if it exists [58]. Hence RHorn is a further base class. In contrast to Horn, RHorn is not clause-defined.

#### Forests

Many NP-hard problems can be solved in polynomial time for problem instances that are in a certain sense acyclic. The satisfiability problem is no exception. There are various ways of defining a CNF formula to be acyclic. Here we consider acyclicity based on (undirected) incidence graphs: the incidence graph of a CNF formula is the bipartite graph whose vertices are the variables and the clauses of ; a variable and a clause are joined by an edge if and only if . Let Forest denote the class of CNF formulas whose undirected incidence graphs are forests. It is well known that Forest forms islands of tractability: the satisfiability of CNF formulas whose incidence graphs have bounded treewidth can be decided in linear time [43, 88]. Forest is the special case of formulas with treewidth at most .

#### Clusters

A CNF formula is called a hitting if any two distinct clauses clash. Two clauses clash if they contain a complimentary pair of literals, i.e., . A CNF formula is called a clustering formula if it is a variable disjoint union of hitting formulas. We denote by Clu the class of clustering formulas. Clustering formulas not only allow polynomial-time SAT decision, one can even count the number of satisfying truth assignments in polynomial time. This is due to the fact that each truth assignment invalidates at most one clause of a hitting formula [52, 66].

## 4 Detecting Weak Backdoor Sets

It turns out that for all base classes considered in this survey, Weak -Backdoor Set Detection is W[2]-hard. In several cases, restricting the input formula to 3CNF helps, and makes Weak -Backdoor Set Detection fixed-parameter tractable.

In the proof of the following proposition we use a general approach that entails previously published proofs (such as in [46, 65, 66]) as special cases.

###### Proof

We show W[2]-hardness for , Horn, -Val, RHorn, Forest, . The hardness proofs for the remaining two classes -Val and are symmetric to the proofs for -Val and Horn, respectively.

Let be a CNF formula with a set of its variables marked as external, all other variables of are called internal. We call an or-gadget for a base class  if has the following properties:

1. .

2. .

3. holds for all .

4. For each clause either or .

5. .

6. can be constructed in time polynomial in .

First, we show the following meta-result, and then we define or-gadgets for the different base-classes.

Claim 1: If is clause-induced, closed under variable-disjoint union, and has an or-gadget for any number of external variables, then Weak -Backdoor Set Detection is W[2]-hard.

We prove the claim by giving a parameterized reduction from the W[2]-complete problem Hitting Set (HS) [33]. Let , , be an instance of HS. Let . For each we construct or-gadgets whose external variables are exactly the elements of , and whose internal variables do not appear in any of the other gadgets for . Let . From Property 6 it follows that can be constructed from in polynomial time. We show that has a hitting set of size if and only if has a weak -backdoor set of size .

Assume is a hitting set of of size . Let the truth assignment that sets all variables from to 1. By Properties 2 and 3, is satisfiable and belongs to for each . By Property 4, for any two distinct pairs . Consequently is satisfiable, and since is closed under variable-disjoint union, belongs to . Thus is a weak -backdoor set of of size .

Conversely, assume that is a weak -backdoor set of of size . Hence, there exists a truth assignment such that is satisfiable and belongs to . Clearly for each , is satisfiable (since ), and (since is clause-induced). However, since by Property 1, for each . Let . By construction, contains copies of the same gadget. From Property 5 it follows that all the copies are different. Since , there must be some such that there are with . It follows that is an external variable of , hence . Consequently, is a hitting set of .

Hence we have indeed a parameterized reduction from HS to Weak -Backdoor Set Detection, and Claim 1 is shown true. We define for each class , Horn, -Val, RHorn, Forest, an or-gadget where is the set of external variables; internal variables are denoted .

• .

• .

• .

• .

• .

Since the considered classes are clearly clause-induced and closed under variable-disjoint union, the proposition now follows from Claim 1.

For base classes based on subsolvers, weak backdoor set detection is even W[P]-hard. This is not surprising, since the subsolvers allow a propagation through the formula which is similar to the propagation in problems like Minimum Axiom Set or Degree 3 Subgraph Annihilator [33]. The proof of the following theorem is based on a reduction from the W[P]-complete problem Cyclic Monotone Circuit Activation.

###### Theorem 4.1 ([93])

Weak -Backdoor Set Detection is W[P]-complete for all base classes . This even holds if the input formula is in 3CNF.

In summary, we conclude that Weak -Backdoor Set Detection is at least W[2]-hard for all considered base classes. If we restrict our scope to 3CNF formulas, we obtain mixed results.

###### Proposition 2

For every clause-defined class , Weak -Backdoor Set Detection is fixed-parameter tractable for input formulas in 3CNF.

###### Proof

The result follows by a standard bounded search tree argument, sketched as follows. Assume we are given a CNF formula and an integer . We want to decide whether has a weak -backdoor set of size . Since is clause-defined, contains a clause such that . Hence some variable of must belong to any weak -backdoor set of . There are at most such variables, each of which can be set to true or to false. Hence we branch in at most 6 cases. By iterating this case distinction we build a search tree , where each node of corresponds to a partial truth assignment . We can stop building the tree at nodes of depth and at nodes where . It is now easy to see that has a weak -backdoor set of size at most if and only if has a leaf such that and is satisfiable. For each leaf we can check in polynomial time whether these properties hold.

In particular, Weak -Backdoor Set Detection is fixed-parameter tractable for if the input formula is in 3CNF.

The proof of Proposition 2 can be extended to the class Clu of clustering formulas. Nishimura et al. [66] have shown that a CNF formula is a clustering formula if and only if it does not contain (i) two clauses that overlap () but do not clash (), or (ii) three clauses where and clash, and clash, but and do not clash. is called an overlap obstruction, is called a clash obstruction. Each weak Clu-backdoor set of a CNF formula must contain at least one variable from each overlap and each clash obstruction. However, if is a 3CNF formula, the number of variables of an overlap obstruction is at most 5, and the number of variables of a clash obstruction is at most 7. Hence we can find a weak Clu-backdoor set of size at most with a bounded search tree, which gives the following result.

###### Proposition 3

Weak Clu-Backdoor Set Detection is fixed-parameter tractable for 3CNF formulas.

###### Proposition 4

Weak RHorn-Backdoor Set Detection is W[2]-hard, even for 3CNF formulas.

###### Proof

Similarly to the proof of Proposition 1 we reduce from HS. As gadgets we use formulas of the form , , , , , where are external variables and are internal variables. can be considered as being obtained form the complete formula by “subdividing” the clause . but . In fact, for , hence no external variable needs to be renamed. Moreover, we can satisfy by setting all external variables and to 0, and by setting to 1.

Let , , be an instance of HS. For each we construct gadgets , each having as the set of its external variables, and the internal variables are new variables only used inside a gadget. We let to be the union of all such gadgets for and .

Similar to the proof of Proposition 1 we can easily show that has a hitting set of size if and only if has a weak RHorn-backdoor set of size . The proposition follows.

According to Propositions 2 and 3, Weak -Backdoor Set Detection is fixed-parameter tractable for certain base classes and input formulas in 3CNF. For the classes covered by Propositions 2 and 3 it holds that for every 3CNF formula we can find a set of variables of bounded size, an “obstruction”, from which at least one variable must be in any weak -backdoor set of . Hence a weak backdoor set of size at most can be found by means of a bounded search tree algorithm. The next result shows that fixed-parameter tractability also prevails for the base class Forest. However, the algorithm is considerably more complicated, as in this case we do not have obstructions of bounded size.

###### Theorem 4.2 ([46])

Weak Forest-Backdoor Set Detection is fixed-parameter tractable for 3CNF formulas.

###### Proof (Sketch)

We sketch the fpt algorithm from [46] deciding whether a 3CNF formula has a weak Forest-backdoor set of size . We refer to [46] for the full details and the correctness proof. Let denote the incidence graph of . The first step of the algorithm runs an fpt algorithm (with parameter ) by Bodlaender [9] that either finds vertex-disjoint cycles in or a feedback vertex set of of size at most .

In case a feedback vertex set is returned, a tree decomposition of of width 1 is computed and is added to each bag of this tree decomposition. As the Weak Forest-Backdoor Set Detection problem can be defined in Monadic Second Order Logic, a meta-theorem by Courcelle [26] can use this tree decomposition to conclude.

In case Bodlaender’s algorithm returns vertex-disjoint cycles, the algorithm finds a set of variables such that any weak Forest-backdoor set of size contains at least one variable from . In this case, the algorithm recurses by considering all possibilities of assigning a value to a variable from .

Let denote the variable-disjoint cycles returned by Bodlaender’s algorithm. Consider a variable and a cycle . We say that kills internally if . We say that kills externally if and contains a clause such that .

As our cycles are all vertex-disjoint, at most cycles may be killed internally. The algorithm goes through all choices of cycles among that may be killed internally. All other cycles, say , are not killed internally and need to be killed externally. The algorithm now computes a set of size such that any weak Forest-backdoor set of size , which is a subset of , contains at least one variable from . The union of all such , taken over all choices of cycles to be killed internally, forms then the set that was to be computed.

For each cycle from , compute its set of external killers in . Only these external killers are considered from now on. If one such cycle has no such external killer, then there is no solution with the current specifications and the algorithm backtracks. For each , let denote an external killer of with a maximum number of neighbors in . The algorithm executes the first applicable from the following rules.

Multi-Killer Unsupported

If there is an index such that has neighbors in and at most external killers of have at least neighbors in , then include all these external killers in .

Multi-Killer Supported

If there is an index such that has neighbors in and more than external killers of have at least neighbors in , then set .

Large Overlap

If there are two cycles with at least common external killers, then set .

Small Overlap

Otherwise, include in all vertices that are common external killers of at least two cycles from .

The algorithm recursively checks for each whether the formulas and have a weak Forest-backdoor set of size and returns Yes if any such recursive call was successful and No otherwise.

## 5 Detecting Strong Backdoor Sets

###### Proposition 5 ([65])

Strong -Backdoor Set Detection is fixed-parameter tractable for every base class . For , the problem is even solvable in polynomial time.

###### Proposition 6

Strong RHorn-Backdoor Set Detection is W[2]-hard.

###### Proof

The proof uses a reduction from HS similar to the proof of Proposition 1. An instance , , of HS is reduced to a formula which is the union of certain gadgets for and . Let . A gadget contains the four clauses , , , and , where are internal variables that do not occur outside the gadget. Let be a hitting set of and let . If sets at least one variable to , then removes from each gadget the only negative clause, hence . On the other hand, if sets all variables from to , then it removes from each gadget the only positive clause ( is a hitting set). Hence, in this case. Consequently is a strong RHorn-backdoor set of . Conversely, assume is a strong RHorn-backdoor set of . Let be the all-1-assignment. For the sake of contradiction, assume there is a set such that . Since , for some . Now contains the subset which is not renamable Horn, hence is not a strong RHorn-backdoor set of , a contradiction. Hence is a hitting set of .

It is not known whether Strong Forest-Backdoor Set Detection is fixed-parameter tractable nor whether Strong RHorn-Backdoor Set Detection is fixed-parameter tractable for 3CNF formulas. For the former problem, however, we know at least an fpt approximation [46]; see Theorem 7.1 below.

The following result is shown by a reduction from Cyclic Monotone Circuit Activation, similarly to Theorem 4.1.

###### Theorem 5.1 ([93])

Strong -Backdoor Set Detection is W[P]-complete for every base class , even for formulas in 3CNF.

The bounded search tree method outlined above for Weak Clu-Backdoor Set Detection for 3CNF formulas can clearly be adapted for strong backdoors. Hence we get the following result.

###### Proposition 7

Strong Clu-Backdoor Set Detection is fixed-parameter tractable for 3CNF formulas.

### 5.1 Empty Clause Detection

Dilkina et al. [31] suggested to strengthen the concept of strong backdoor sets by means of empty clause detection. Let denote the class of all CNF formulas that contain the empty clause. For a base class we put ; we call the base class obtained from by adding empty clause detection. Formulas often have much smaller strong -backdoor sets than strong -backdoor sets [31]. Dilkina et al. show that, given a CNF formula and an integer , determining whether has a strong -backdoor set of size , is both NP-hard and co-NP-hard (here is considered just as part of the input and not as a parameter). Thus, the non-parameterized search problem for strong Horn-backdoor sets gets harder when empty clause detection is added. It turns out that also the parameterized problem gets harder when empty clause detection is added.

###### Theorem 5.2 ([94])

For every clause-induced base class such that at least one satisfiable CNF formula does not belong to the problem strong -backdoor set is W[1]-hard.

The theorem clearly applies to all base classes in . The proof from [94] relies on a reduction from [39], where a reduction to 3CNF formulas is also given. Thus, Theorem 5.2 also holds for 3CNF formulas.

## 6 Detecting Deletion Backdoor Sets

In this section we consider the parameterized complexity of Deletion -Backdoor Set Detection for the various base classes from above. For most of the classes the complexity is easily established as follows. For Schaefer classes, strong and deletion backdoor sets coincide, hence the FPT results carry over. The subsolver classes are not clause-induced, hence it does not make sense to consider deletion backdoor sets. Deletion Forest-Backdoor Set Detection can be solved by algorithms for a slight variation of the feedback vertex set problem, and is therefore FPT. One has only to make sure that the feedback vertex set contains only variables and no clauses. This, however, can be achieved by using algorithms for Weighted Feedback Vertex Set [77, 17].

It is tempting to use Chen et al.’s FPT algorithm for directed feedback vertex set [20] for the detection of deletion backdoor sets. The corresponding base class would contain all CNF formulas with acyclic directed incidence graphs (the orientation of edges indicate whether a variable occurs positively or negatively). Unfortunately this class is not suited as a base class since it contains formulas where each clause contains either only positive literals or only negative literals, and SAT is well known to be NP-hard for such formulas [45].

Hence we are left with the classes Clu and RHorn.

For the detection of deletion Clu-backdoor sets we can use overlap obstructions and clash obstructions, as defined before Proposition 3. With each obstruction, we associate a deletion pair which is a pair of sets of variables. With an overlap obstruction , we associate the deletion pair

 {var(C1∩C2),var((C1∖C2)∪(C2∖C1))},

and with a clash obstruction , we associate the deletion pair

 {var((D1∖D3)∩¯¯¯¯¯¯¯D2),% var((D3∖D1)∩¯¯¯¯¯¯¯D2)}.

For a formula , let denote the graph with vertex set that has an edge if and only if there is a deletion pair of with and . Nishimura et al. [66] have shown that a set is a deletion Clu-backdoor set of if and only if is a vertex cover of . Thus, the detection of a deletion Clu-backdoor set of size can be reduced to the problem of checking whether has a vertex cover of size , for which there exist very fast algorithms (see for example [19]).

###### Proposition 8 ([66])

Deletion Clu-Backdoor Set Detection is fixed-parameter tractable.

The remaining case is the class RHorn. As noted by Gottlob and Szeider [49] without proof (see also [79]), one can show fixed-parameter tractability of Deletion RHorn-Backdoor Set Detection by reducing it to the problem 2SAT Deletion. The latter problem takes as input a 2CNF formula and an integer (the parameter), and asks whether one can make the formula satisfiable by deleting at most  clauses. 2SAT Deletion was shown fixed-parameter tractable by Razgon and O’Sullivan [79]. Here we give the above mentioned reduction.

###### Lemma 1

There is a parameterized reduction from Deletion RHorn-Backdoor Set Detection to 2SAT Deletion.

###### Proof

Let be a given instance of Deletion RHorn-Backdoor Set Detection. We construct a graph by taking as vertices all literals , for and , and by adding two groups of edges. The first group consists of all edges for , the second group consists of all edges for , , such that for some . Observe that the edges of the first group form a perfect matching of the graph .

Claim 1. has a deletion RHorn-backdoor set of size at most if and only if has a vertex cover with at most vertices.

() Let be a deletion RHorn-backdoor set of of size at most and such that . Let . Let . By definition, . We show that is a vertex cover of . Consider an edge of the first group. If , then and if , then . Hence is covered by . It remains to consider an edge of the second group. If or , then this edge is covered by . Hence assume . By construction of , there is a clause with . Since , there is also a clause with . Since corresponds to a Horn clause , at least one of the literals belongs to , and hence covers the edge . Hence the first direction of Claim 1 follows.

() Let be a vertex cover of with at most vertices. Let be the set of all variables such that both . Clearly . Let such that . We show that . Let be two literals that belong to a clause of . We show that or . Let the clause that corresponds to , and let . It follows that , and since is a vertex cover of , or . If then , if then . Since were chosen arbitrarily, we conclude that . Hence Claim 1 is shown.

Mishra et al. [63] already observed that a reduction from [16] can be adapted to show that this above-guarantee vertex cover problem can be reduced to 2SAT Deletion. For completeness, we give a reduction here as well.

We construct a 2CNF formula from . For each vertex of we take a variable . For each edge we add a negative clause , and for each edge we add a positive clause .

Claim 2. has a vertex cover with at most vertices if and only if we can delete at most negative clauses from to obtain a satisfiable formula.

() Let be a vertex cover of . We delete from all negative clauses where both (there are at most such clauses) and obtain a 2CNF formula . We define a truth assignment by setting a variable to 1 if and only if it belongs to . It remains to show that satisfies . The negative clauses are satisfied since sets exactly one literal of a negative clause to 1 and exactly one to 0. The positive clauses are satisfied since each positive clause corresponds to an edge , and since is a vertex cover, sets at least one of the variables  to 1.

() Let be a satisfiable formula obtained from by deleting at most negative clauses. Let . Let be a satisfying truth assignment of . We define a set of vertices of by setting , and we observe that . It remains to show that is a vertex cover of . Consider an edge of the first group. If then ; if then , hence is covered by . Now consider an edge of the second group. If or then is clearly covered by . Hence assume . By definition, there is a positive clause . Since satisfies , it follows that or . Consequently or , thus covers . Hence Claim 2 is shown.

Next we modify by replacing each positive clause with “mixed” clauses , for , where the are new variables. Let denote the 2CNF formula obtained this way from .

Claim 3. We can delete at most negative clauses from to obtain a satisfiable formula if and only if we can delete at most clauses from to obtain a satisfiable formula.

The claim follows easily from the following considerations. We observe that each pair of mixed clauses is semantically equivalent with . Hence, if can be made satisfiable by deleting some of the negative clauses, we can also make satisfiable by deleting the same clauses. However, deleting some of the mixed clauses does only help if we delete at least one from each of the pairs that correspond to the same clause . Hence also Claim 3 is shown true. Claims 1–3 together establish the lemma.

Razgon and O’Sullivan’s result [79] together with Lemma 1 immediately give the following.

###### Proposition 9

Deletion RHorn-Backdoor Set Detection is fixed-parameter tractable.

## 7 Permissive Problems

We consider any function that assigns nonnegative integers to CNF formulas as a satisfiability parameter. In particular we are interested in such satisfiability parameters  for which the following parameterized problem is fixed-parameter tractable:

Instance: A CNF formula and an integer .

Parameter: The integer .
Task: Determine whether is satisfiable or determine that .

Note that an algorithm that solves the problem has the freedom of deciding the satisfiability of some formulas with , hence the exact recognition of formulas with can be avoided. Thus is not a usual decision problem, as there are three different outputs, not just two. If is fixed-parameter tractable then we call an fpt satisfiability parameter, and we say that “the satisfiability of CNF formulas of bounded is fixed-parameter tractable” (cf. [92]). We write if the input is restricted to 3CNF formulas.

Backdoor sets provide a generic way to define satisfiability parameters. Let be a base class and a CNF formula. We define , and as the size of a smallest weak, strong, and deletion -backdoor set of , respectively.

Of course, if the detection of the respective -backdoor set is fixed-parameter tractable, then , , and are fpt satisfiability parameters. However, it is possible that , , or are fpt satisfiability parameters but the corresponding -backdoor set detection problem is W[1]-hard. The problems , , and can therefore be considered as more “permissive” versions of the “strict” problems Weak, Strong, and Deletion -Backdoor Set Detection, the latter require to find a backdoor set even if the given formula is trivially seen to be satisfiable or unsatisfiable. The distinction between permissive and strict versions of problems have been considered in a related context by Marx and Schlotter [61, 62] for parameterized -neighborhood local search. Showing hardness for permissive problems seems to be a much more difficult task than for the strict problems. So far we could establish only few such hardness results.

###### Proposition 10

is W[1]-hard for all .

###### Proof

We will show a more general result, that W[1]-hardness holds for all base classes that contain all anti-monotone 2CNF formulas. A CNF formula is anti-monotone if all its clauses are negative. Let be a base class that contains all anti-monotone 2CNF formulas.

We show that is W[1]-hard by reducing from Partitioned Clique, also known as Multicolored Clique. This problem takes as input a -partite graph and asks whether the graph has a clique on vertices. The integer is the parameter. The problem is well-known to be W[1]-complete [73].

Let with be an instance of this problem. We construct a CNF formula as follows. We consider the vertices of as variables and add clauses for any two distinct vertices such that . For each , we add the clause . This completes the construction of .

We show that the following statements are equivalent:

1. is satisfiable

2. contains a -clique.

3. has a weak -backdoor set of size at most .

(1)(2). Let be a satisfying assignment of . Because of the clause , sets at least one variable of to , for each . As each is an independent set, contains a clause for every two distinct vertices in . Thus, sets exactly one variable of to , for each . The clauses of also imply that for each , since otherwise would falsify the clause . Hence induce a clique in .

(2)(3). Assume induce a clique in , with . We show that is a weak -backdoor set of . Let be the truth assignment that sets all variables of to . This satisfies all the clauses . Thus, is an anti-monotone 2CNF formula. Therefore it is in and it is satisfiable as it is 0-valid. Hence is a weak -backdoor set of .

(3)(1). Any formula that has a weak backdoor set is satisfiable.

Since all three statements are equivalent, we conclude that is W[1]-hard. This shows the proposition for the base classes Horn, 2CNF, -Val, and RHorn, as they contain all anti-monotone 2CNF formulas. The hardness for and -Val follows by symmetric arguments from the hardness of Horn and -Val, respectively.

In general, if we have an fpt approximation algorithm [14, 21, 34] for a strict backdoor set detection problem, then the corresponding permissive problem is fixed-parameter tractable. For instance, if we have an fpt algorithm that, for a given pair either outputs a weak, strong, or deletion -backdoor set of of size at most or decides that has no such backdoor set of size at most , then clearly , , and , respectively, is an fpt satisfiability parameter.

This line of reasoning is used in the next theorem to show that is an fpt satisfiability parameter. This result labels Forest as the first nontrivial base class for which is an fpt satisfiability parameter and . Hence the additional power of strong Forest-backdoor sets over deletion Forest-backdoor sets is accessible.

###### Theorem 7.1 ([46])

Strong Forest-Backdoor Set Detection admits a fpt-approximation. Hence is fixed-parameter tractable.

###### Proof (Sketch)

We sketch the fpt-approximation algorithm from [46] which either concludes that a CNF formula has no strong Forest-backdoor set of size or returns one of size at most . We refer to [46] for the full details and the correctness proof. Let  denote the incidence graph of . The first step of the algorithm runs, similarly to the proof of Theorem 4.2, the fpt algorithm (with parameter ) by Bodlaender [9] that either finds vertex-disjoint cycles in or a feedback vertex set of of size at most .

In case a feedback vertex set is returned, a tree decomposition of of width 1 is computed and is added to each bag of this tree decomposition. As the Strong Forest-Backdoor Set Detection problem can be defined in Monadic Second Order Logic, a meta-theorem by Courcelle [26] can be used to decide the problem in linear time using this tree decomposition.

In case Bodlaender’s algorithm returns vertex-disjoint cycles, the algorithm finds a set of variables such that every strong Forest-backdoor set of size contains at least one variable from . In this case, the algorithm recurses by considering all possibilities of including a variable from in the backdoor set.

Let denote the variable-disjoint cycles returned by Bodlaender’s algorithm. Consider a variable and a cycle . We say that kills internally if . We say that kills externally if and contains two clause such that and . We say in this case that kills externally in and .

The algorithm goes through all ways to choose cycles among that may be killed internally. All other cycles, say with , are not killed internally. We refer to these cycles as -cycles. The algorithm now computes a set of size at most such that any strong Forest-backdoor set of size , which is a subset of , contains at least one variable from . The union of all such , taken over all choices of cycles to be killed internally, forms then the set that was to be computed.

From now on, consider only killers in . For each -cycle , consider vertices such that kills externally in and and there is a path from to along the cycle such that if any variable kills externally in two clauses and such that , then . Note that any variable that does not kill internally, but kills the cycle also kills the cycle externally in and . We refer to such external killers as interesting.

The algorithm executes the first applicable from the following rules.

No External Killer

If there is an index , such that has no external killer, then set .

Killing Same Cycles

If there are variables and and at least -cycles such that both and are interesting external killers of each of these -cycles, then set .

Killing Many Cycles

If there is a variable that is an interesting external killer of at least -cycles, then set .

Too Many Cycles

Otherwise, set .

For each the algorithm calls itself recursively to compute a strong Forest-backdoor set for and for with parameter . If both recursive calls return backdoor sets, the union of these two backdoor sets and is a strong Forest-backdoor set for . It returns the smallest such backdoor set obtained for all choices of , or No if for each at least one recursive call returned No.

## 8 Comparison of Parameters

Satisfiability parameters can be compared with respect to their generality. Let be satisfiability parameters. We say that is at least as general as , in symbols , if there exists a function such that for every CNF formula we have . Clearly, if and is fpt, then so is . If but not , then is more general than . If neither nor then and are incomparable.

As discussed above, each base class gives rise to three satisfiability parameters , and . If