Backdoors into Heterogeneous Classes of SAT and CSP

09/18/2015 ∙ by Serge Gaspers, et al. ∙ University of Oxford UNSW 0

In this paper we extend the classical notion of strong and weak backdoor sets for SAT and CSP by allowing that different instantiations of the backdoor variables result in instances that belong to different base classes; the union of the base classes forms a heterogeneous base class. Backdoor sets to heterogeneous base classes can be much smaller than backdoor sets to homogeneous ones, hence they are much more desirable but possibly harder to find. We draw a detailed complexity landscape for the problem of detecting strong and weak backdoor sets into heterogeneous base classes for SAT and CSP.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

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

1 Introduction

We consider the propositional satisfiability problem (SAT) and the constraint satisfaction problem (CSP). Backdoors are small sets of variables of a SAT or CSP instance that represent “clever reasoning shortcuts” through the search space. Backdoor sets were originally introduced by Williams, Gomes, and Selman ([40, 41]

) as a tool for the analysis of decision heuristics in propositional satisfiability. Since then, backdoor sets have been widely used in the areas of propositional satisfiability 

[40, 34, 9, 35, 27, 10, 19], and also for material discovery [31], abductive reasoning [33], argumentation [12], quantified Boolean formulas [36], and planning [29, 30]. A backdoor set is defined with respect to some fixed base class for which the computational problem under consideration is polynomial-time tractable (alternatively, it can be defined with respect to a polynomial-time subsolver). The size of the backdoor set can be seen as a distance measure that indicates how far the instance is from the target class. One distinguishes between strong and weak backdoor sets; the latter applies only to satisfiable instances. Once a strong backdoor set of size is identified, one can decide the satisfiability of the instance by deciding the satisfiability of at most “easy” instances that belong to the tractable base class, where denotes the size of the domain for the variables; for SAT we have . Each of the easy instances is obtained by one of the possible instantiations of the variables in the backdoor set. Hence, the satisfiability check is fixed-parameter tractable [11] for the combined parameter backdoor size and domain size (). A similar approach works for weak backdoor sets, where the computation of a certificate for satisfiability (i.e., a satisfying assignment) is fixed-parameter tractable for the combined parameter ().

The fixed-parameter tractability of using the backdoor set for deciding satisfiability or the computation of a certificate for satisfiability triggers the question of whether finding a backdoor set of size at most is also fixed-parameter tractable. In particular, for every base class one can ask whether the detection of a strong or weak backdoor set into of size at most is fixed-parameter tractable for parameter  (possibly in combination with restrictions on the input or other parameters). A systematic study of the parameterized complexity of backdoor set detection was initiated by Nishimura et al. [32] for SAT, who showed that the detection of strong backdoor sets into the classes HORN and 2CNF is fixed-parameter tractable, but the detection of weak backdoor sets into any of these two classes is W[2]-hard (and hence unlikely to be fixed-parameter tractable). Since then, the parameterized complexity of backdoor set detection has become an active research topic as outlined in a survey [18].

In this work, we provide two significant extensions to the exciting research on fixed-parameter tractable backdoor set detection. First, we introduce heterogeneous base classes, which can be composed of several homogeneous base classes. We show that heterogeneous base classes are particularly well-suited for strong backdoor sets, since they allow that different instantiations of the backdoor variables result in instances that belong to different base classes, which leads to arbitrary reductions in the size of a strong backdoor set even compared to the smallest strong backdoor set for each individual homogeneous base class. This is in contrast to weak backdoor sets, where the size of a weak backdoor set into a heterogeneous base class is equal to the size of the smallest backdoor set into any of the individual base classes. Here we show that also the complexity of weak backdoor set detection into heterogeneous base classes is tight to its complexity on the individual base classes. Second, we extend the scope of backdoor set detection from SAT to CSP, considering target classes that are defined by tractable constraint languages in terms of certain closure properties under polymorphisms.

Heterogeneous Base Classes

Consider the following SAT instance where and . It is easy to see that any strong backdoor set into HORN needs to contain at least one of the variables or from each clause , hence such a backdoor set must be of size ; on the other hand, any strong backdoor set into 2CNF must contain at least variables from the clause ; hence such a backdoor must be of size at as well. However, is Horn, and is a 2CNF, hence the singleton constitutes a strong backdoor set into the “heterogeneous” base class . This example shows that by considering heterogeneous base classes we can access structural properties of instances that are not accessible by backdoor sets into homogeneous base classes. Identifying a base class with a class of instances that are solvable by a particular polynomial-time subsolver, one can consider a heterogeneous base class as a “portfolio subsolver,” where for each instance the best suitable subsolver from the portfolio is chosen.

SAT Backdoor Sets

A natural question at this point is whether the fixed-parameter tractability results for the detection of strong backdoor sets into individual base classes can be extended to more powerful heterogeneous base classes. In this work, we completely characterize the complexity landscape for heterogeneous base classes obtained arbitrary combinations of the well-known Schaefer classes [38], in the following denoted by HORN (for Horn formulas), (for Anti-Horn formulas), 2CNF (for 2-CNF formulas), 0-VAL (for zero valid formulas), and 1-VAL (for one valid formulas). To state the classification, we briefly introduce some terminology. We say that a pair of Schaefer classes is a bad pair if and .

Let be a class of CNF-formulas such that for some subset of the Schaefer classes. Our main result for SAT backdoor sets (Theorem 6) is that Strong -Backdoor Detection is fixed parameter tractable if and only if does not contain a bad pair of Schaefer classes, otherwise it is W[2]-hard. On the other hand, detecting weak backdoors is always W[2]-hard for any choice of , and we show this by building on the known hardness results for when is a singleton set (Theorem 8).

We also show that Strong -Backdoor Detection as well as Weak -Backdoor Detection are fixed-parameter tractable for the combined parameter and the maximum length of a clause of the input formula (Theorem 7 and 9). These algorithms formalize the intuition that all the hardness results in the previous classification result exploit clauses of unbounded length.

CSP Backdoor Sets

The identification of tractable classes of CSP instances has been subject of extensive studies. A prominent line of research, initiated by Schaefer [38] in his seminal paper on Boolean CSP, is to identify tractable classes by restricting the relations that may appear in constraints to a prescribed set, a constraint language. Today, many constraint languages have been identified that give rise to tractable classes of CSPs [5, 22, 2]; typically such languages are defined in terms of certain closure properties, which ensure that the relations are closed under pointwise application of certain operations on the domain. For instance, consider a CSP instance whose relations are closed under a constant operation for some (such a operation is a polymorphism of the relations in the instance). Then note that every relation is either empty or forced to contain the tuple . Thus, given a particular instance, we may either declare it unsatisfiable (if it contains a constraint over the empty relation), or satisfy it trivially by setting every variable to . Further examples of polymorphisms for which closure properties yield tractable CSP are min, max, majority, affine, and Mal’cev operations [24, 1].

We study the problem of finding strong and weak backdoor sets into tractable classes of CSP instances defined by certain polymorphisms. Our main result for CSP backdoors (Theorem 10) establishes fixed-parameter tractability for a wide range of such base classes. In particular, we show that the detection of strong and weak backdoor sets is fixed-parameter tractable for the combined parameter backdoor size, domain size, and the maximum arity of constraints. In fact, this result entails heterogeneous base classes, as different instantiations of the backdoor variables can lead to reduced instances that are closed under different polymorphisms (even polymorphisms of different type). We complement our main result with hardness results that show that we lose fixed-parameter tractability when we omit either domain size or the maximum arity of constraints from the parameter (Theorems 12 and 13). Hence, Theorem 10 is tight in a certain sense.

Related Work

Recently, two papers dealing with strong backdoor set detection for the constraint satisfaction problem have appeared [7, 17], which nicely supplement (however are mostly orthogonal to) the results in this paper. Carbonnel et al. [7] show W[2]-hardness for strong backdoor set detection parameterized by the size of the backdoor set even for CSP-instances with only one constraint (however with unbounded domain and unbounded arity). They also give a fixed-parameter algorithm for strong backdoor set detection parameterized by the size of the backdoor set and the maximum arity of any constraint, if the base class is “h-Helly” for any fixed integer . However, as is also mentioned in Carbonnel and Cooper [6], the “h-Helly” property is rather restrictive and orthogonal to our approach of considering the domain as an additional parameter.

Ganian et al. [17] show fixed-parameter tractability of strong backdoor detection parameterized by the size of the backdoor to a very general family of heterogeneous base classes, i.e., base classes defined as all CSP-instances obtained from the disjoint union of tractable, finite, and semi-conservative constraint languages. These base classes are orthogonal to the base classes considered in this paper. They are more general in the sense that they allow for the CSP-instance to consist of pairwise disjoint subinstances each belonging to a different tractable class, and they are more specific in the sense that they only consider finite and semi-conservative constraint languages, which also restricts the CSP-instances to bounded domain and bounded arity.

2 Preliminaries

Sat

A literal is a propositional variable or a negated variable . We also use the notation and . A clause is a finite set of 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. For a clause we write or , and for a CNF formula we write .

For a set of propositional variables we denote by the set of all mappings from to , the truth assignments on . We denote by the set of literals corresponding to the negated variables of . 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 simply write instead of .

A CNF formula is satisfiable if there is some with , otherwise is unsatisfiable.

Csp

Let be a set and and be natural numbers. An -ary relation on is a subset of . For a tuple , we denote by , the -th entry of , where . For two tuples and , we denote by , the concatenation of and .

An instance of a constraint satisfaction problem (CSP) is a triple , where is a finite set of variables over a finite set (domain) , and is a set of constraints. A constraint consists of a scope, denoted by , which is an ordered list of a subset of , and a relation, denoted by , which is a -ary relation on . To simplify notation, we sometimes treat ordered lists without repetitions, such as the scope of a constraint, like sets. For a variable and a tuple , we denote by , the -th entry of , where is the position of in . For a CSP instance we sometimes denote by , , , and , its set of variables , its domain , its set of constraints , and the maximum arity of any constraint of , respectively.

Let and . For a constraint , we denote by , the constraint whose scope is and whose relation contains all -ary tuples such that there is a -ary tuple with for every and for every . We denote by the CSP instance with variables , domain , and constraints , where contains a constraint for every .

A solution to a CSP instance is a mapping such that for every with .

Backdoors

Backdoors are defined relative to some fixed class of instances of the problem under consideration (i.e., SAT or CSP). One usually assumes that the problem is tractable for instances from , as well as that the recognition of is tractable.

In the context of SAT, we define a strong -backdoor set of a CNF formula to be 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 . If we know a strong -backdoor set of , we can decide the satisfiability of by checking the satisfiability of “easy” formulas that belong to . Thus SAT decision is fixed-parameter tractable in the size of the backdoor. Similarly, in the context of CSP, we define a strong -backdoor set of a CSP instance as a set of variables such that for every . We also call a strong -backdoor a strong backdoor set into . A weak -backdoor set of is a set of variables such that is satisfiable and holds for some . If we know a strong -backdoor set of of size , we can reduce the satisfiability of to the satisfiability of CSP instances in where . Thus deciding the satisfiability of a CSP instance is fixed-parameter tractable in the combined parameter .

The challenging problem is—for SAT and for CSP—to find a strong, or weak -backdoor set of size at most if one exists.

For each class of SAT or CSP instances, we define the following problem.

Strong -Backdoor Detection Input: A SAT or CSP instance and a nonnegative integer . Question: Does have a strong -backdoor set of size at most ?

The problem Weak -Backdoor Detection is defined similarly.

Parameterized Complexity

We provide basic definitions of parameterized complexity; for an in-depth treatment we refer to the recent monograph [11]. A problem is parameterized if each problem instance is associated with a nonnegative integer , the parameter. A parameterized problem is fixed-parameter tractable (or FPT, for short) if there is an algorithm, , a constant , and a computable function , such that solves instances of input size and parameter in time . Fixed-parameter tractability extends the conventional notion of polynomial-time tractability, the latter being the special case where is a polynomial. The so-called Weft-hierarchy contains classes of parameterized decision problems that are presumed to be larger than FPT. It is believed that problems that are hard for any of the classes in the Weft-hierarchy are not fixed-parameter tractable. The classes are closed under fpt-reductions that are fixed-parameter tractable many-one reductions, which map an instance with parameter of one problem to a decision-equivalent instance with parameter of another problem, where for some computable function .

For instance, the following problem is well-known to be W[2]-complete [11].

Hitting Set Parameter: Input: A set system over a set (universe) , and a positive integer Question: Is there a subset , with such that every set contains at least one element from ?

3 Backdoor Detection for SAT

Schaefer’s base classes [38] give rise to classes of CNF formulas defined in terms of syntactical properties of clauses.111Affine Boolean formulas considered by Schaefer do not correspond naturally to a class of CNF formulas, hence we do not consider them here. However, we do consider the affine case in the context of Boolean CSPs; cf. Theorem 12. A clause is

  • Horn if it contains at most one positive literal,

  • Anti-Horn if it contains at most one negative literal,

  • 2CNF if it contains at most two literals,222A clause containing exactly two literals is also known as a Krom clause [26].

  • 0-valid if it is empty or contains at least one negative literal, and

  • 1-valid if it is empty or contains at least one positive literal3330-valid and 1-valid is often defined more restrictively, not allowing empty clauses..

A CNF formula is Horn, Anti-Horn, etc. if it contains only Horn, Anti-Horn, etc. clauses. We denote the respective classes of CNF formulas by HORN, HORN, 2CNF, 0-VAL, and 1-VAL.

3.1 Strong Backdoor Sets

In this section we study the parameterized complexity of Strong -Backdoor Detection, where is the union of any subset of the Schaefer classes. In the case that consists only of a single Schaefer class this has been intensively studied before [32, 18] and it is known that Strong -Backdoor Detection is polynomial for 0-VAL and 1-VAL, and FPT for the remaining Schaefer classes.

The results in this subsection are as follows. First we show that Strong -Backdoor Detection is fixed-parameter tractable parameterized by the size of the backdoor set for various combinations of the Schaefer classes, i.e., the case that for any is shown in Theorem 2, the cases that and are shown in Theorem 3, and finally Theorem 4 shows tractability for the cases that and . In contrast, Theorem 5 captures a condition for hardness of the strong backdoor detection problem, which is complementary to all the cases in the first three results. Together, and combined with known results in the literature, these theorems give us a complete complexity classification, which is summarized in Theorem 6.

Our hardness results rely on the fact that the clauses have unbounded length. Theorem 7 shows that if we consider the maximum length of any clause as an additional parameter, then the problem of finding a strong heterogeneous backdoor becomes fixed-parameter tractable for any combination of the Schaefer classes.

As mentioned above we employ branching algorithms for the detection of strong backdoor sets. In particular, all algorithms are based on a depth-bounded search tree approach and mainly differ in the set of employed branching rules. Informally, the algorithms construct a search tree, where each node is labeled with a potential backdoor set and the crucial difference between the algorithms lies in chosing the set of possible extensions of the potential backdoor set on which to branch on. In this way backdoor set detection can be reduced to the following problem, which given a potential backdoor set computes the set of potential extensions of , which can be branched on in the next step.

-Strong Branch Input: A CNF formula with variables , a non-negative integer , and a subset with . Question: Output: Yes iff is a strong -backdoor set of , or a family of subsets of such that: for every it holds that , and for every strong -backdoor set of with and there is a such that .

The next theorem shows that Strong -Backdoor Detection can be reduced to -Strong Branch via a branching algorithm that uses an algorithm for -Strong Branch as a subroutine to determine the set of braching choices. Importantly the running time of the resulting branching algorithm for Strong -Backdoor Detection crucially depends on the “type” of braching rules returned by , or in other words the branching factor. To be able to quantify the branching factor we introduce the function defined recursively as

where is the set of all possible output sets of on any input , with , and .

Theorem 1.

Let be a class of CNF formulas, be a CNF formula, a non-negative integer, and let be an algorithm solving -Strong Branch. Then Strong -Backdoor Detection can be solved in time , where is the time required by on any input , with , and .

Proof.

We will employ a branching algorithm that employs the algorithm solving -Strong Branch as a subroutine. The algorithm uses a depth-bounded search tree approach to find a strong -backdoor set of size at most . Let be any CNF-formula with variables .

We construct a search tree , for which every node is labeled by a set of at most variables of . Additionally, every leaf node has a second label, which is either Yes or No. is defined inductively as follows. The root of is labeled by the empty set. Furthermore, if is a node of , whose first label is , then the children of in are obtained as follows. First we run the algorithm on , , and . If returns Yes then becomes a leaf node, whose second label is Yes. Otherwise let be the set of subsets of returned by . If , then there is no strong -backdoor set of with and and consequently becomes a leaf node whose second label is No. Otherwise, i.e., if then has a a child for every , whose first label is . This completes the definition of . If has a leaf node, whose second label is Yes, then the algorithm returns the first label of that leaf node as a strong -backdoor set of . Otherwise the algorithm returns No. This completes the description of the algorithm.

We now show the correctness of the algorithm. First, suppose the search tree built by the algorithm has a leaf node whose second label is Yes. Here, the algorithm returns the first label, say of . By definition of , we obtain that and is a strong -backdoor set of .

Now consider the case where the algorithm returns No. We need to show that has no strong -backdoor set of size at most . Assume, for the sake of contradiction that such a set exists.

Observe first that for every leaf node of whose second label is No, it holds that . This is because the algorithm on input , , and returned the empty set for . Hence if is a leaf node whose first label satisfies , then the second label of must be Yes.

It hence remains to show that has a leaf node whose first label is a set with . This will complete the proof about the correctness of the algorithm. We will show a slightly stronger statement, namely, that for every natural number , either has a leaf whose first label is contained in or has an inner node of distance exactly from the root whose first label is contained in . We show the latter by induction on .

The claim obviously holds for . So assume that contains a node at distance from the root of whose first label, say , is a subset of . If is a leaf node of , then the claim is shown. Otherwise, the algorithm determined that is not a strong -backdoor set of and returned a set of subsets of satisfying B2. Hence there is a with and because contains a child whose first label is , we obtain that is a node at distance satisfying the induction invariant. This concludes the proof concerning the correctness of the algorithm.

The running time of the algorithm is obtained as follows. Let be a search tree obtained by the algorithm. Then the running time of the depth-bounded search tree algorithm is times the maximum time that is spend on any node of . Since and the time spend on any node is at most , the stated running time follows. ∎

Our first tractability result is for Strong -Backdoor Detection, where . Before formally stating the algorithm, we provide a brief intuition for the branching rules. Typically, we branch on an obstructing clause (or a pair of obstructing clauses), a situation that occurs in one of two flavors:

  1. Either there is a clause that is not in , or,

  2. there is a pair of clauses and , where and .

Consider the case when . In scenario (1), the formula has a clause of length at least three with only positive literals. Because has only positive literals, it follows that no subclause of is -valid. Hence every backdoor set has to hit all but at most two literals from . It follows that if has more than literals, then there is no strong backdoor of size to . Otherwise, the clause has at most literals on which we can branch exhaustively. In scenario (2), we know that has at most two literals and because we obtain that any strong backdoor set that does not contain a variable from must reduce to a clause with at most two literals. Hence, any strong backdoor set has to contain either a variable from (but there are at most two of those) or must contain a variable from any subset of three variables in .

Consider the case when . In scenario (1) above, the formula has a clause of length at least three with at least two positive literals, say and . Let be any other literal in . It is clear that any strong backdoor set must contain one of , or , and we branch accordingly. In scenario (2), we know that has at most two literals and contains at least two positive literals. Because every strong backdoor set that does not contain a variable from must reduce to a clause with at most two literals, we can branch on the variables in and any subset of three variables in .

The intuitive explanations for 1-VAL and are analogous. Note that the criteria described above need to be refined further at internal nodes of the branching process. We now turn to a formal exposition of the algorithm.

Theorem 2.

Let . Then, Strong -Backdoor Detection is fixed-parameter tractable parameterized by the size of the backdoor set.

Proof.

Let . We will provide an algorithm solving -Strong Branch in time and satisfying . The result then follows from Theorem 1.

Let be the given CNF formula with variables , the given integer, and with . The algorithm first checks whether for every assignment . If that is the case then returns Yes. Otherwise let be an assignment such that , we consider two cases:

  1. if , then there is no strong -backdoor set of with and and the algorithm correctly returns the set ,

  2. otherwise, i.e., if , then we again distinguish two cases:

    1. there is a clause with , then we again distinguish two cases:

      1. if , then let be a subset of with and . Then returns the set .

        To show the correctness of this step assume that there is a strong -backdoor set of with and . It suffices to show that . Suppose for a contradiction that this is not the case and let be an assignment compatible with that does not satisfy any literal of . Then, contains a superset of as a clause and hence , contradicting our assumption that is a strong -backdoor set of .

      2. if , then we again distinguish two cases:

        1. , then the algorithm returns the set .

          The correctness of this step follows from the fact that every strong -backdoor set of with has to contain all but at most two variables of and hence would have size larger than .

        2. otherwise, i.e., if , then the algorithm returns the set containing all sets for every two element subset of .

          To show the correctness of this step assume that there is a strong -backdoor set of with and . It remains to show that . Assume not, and let be an assignment compatible with that does not satisfy any literal of . Then, and because and , also , contradicting our assumption that is a strong -backdoor set of .

    2. otherwise, there is a clause in with and a clause in with . Let be the set of variables containing the (at most) two variables from plus any three element subset of variables from . Then, the algorithm returns the set .

      To show the correctness of this step assume that there is a strong -backdoor set of with and . It remains to show that . Assume not, and let be an assignment compatible with that does not satisfy any literal of . Then, contains the clause together with a subclause of containing at least three literals. Because and , we obtain that .

This completes the description and the proof of correctness of the algorithm . The running time of is the number of assignments of the at most variables in times the time required to test whether the reduced formula is in , i.e., runs in time . It remains to obtaine the stated bound of for the function . According to the three branching rules given in (2.a.i), (2.a.ii.B), and (2.b) we obtain that can be bounded by the maximum of the following recurrence relations: (1) (2.a.i), (2) for any (2.a.ii.B), and (3) (2.b). In case of (1) is at most , in case of (2) the maximum of is obtained for by setting , and in case of (3) is at most . It follows that . ∎

We now turn to the case when the base classes are either or .

As before, in scenario (1), the length of an obstructing clause must be bounded in a Yes-instance. Indeed, consider a clause that is not in . Such a clause has only positive literals, and any strong backdoor set must contain all these literals but one. Therefore, if the clause has more than literals, we reject the instance, otherwise the clause length is bounded, allowing for a bounded branching strategy.

In scenario (2), on the other hand, we have a pair of obstructing clauses, say , and . Now, note that can have only one literal by definition. Let be any subset of two positive literals from . Note that any strong backdoor must intersect either or the unique literal in , which again leads us to a feasible branching step. We now turn to a formal description of the algorithm.

Theorem 3.

Strong -Backdoor Detection and Strong -Backdoor Detection are fixed-parameter tractable parameterized by the size of the backdoor set.

Proof.

We only give the proof for the class , as the proof for the class is analogous. Let . We will provide an algorithm solving -Strong Branch in time and satisfying . The result then follows from Theorem 1.

Let be the given CNF formula with variables , the given integer, and with . The algorithm first checks whether for every assignment . If that is the case then returns Yes. Otherwise let be an assignment such that , we consider two cases:

  1. if , then there is no strong -backdoor set of with and and the algorithm correctly returns the set ,

  2. otherwise, i.e., if , then we again distinguish two cases:

    1. there is a clause with , then we again distinguish two cases:

      1. , then the algorithm returns the set .

        To show the correctness of this step it is sufficient to show that does not have a strong -backdoor set with and . Assume for a contradiction that this is not the case and let be strong -backdoor set of with and . Because we obtain that misses at least two literals of . Let be any assignment that is compatible with and does not satisfy any literal from . Then contains a subclause of that contains at least two literals. It follows that , contradicting our assumption that is a strong -backdoor set for .

      2. otherwise, i.e., if , then returns the set .

        To show the correctness of this step assume that there is a strong -backdoor set of with and . It suffices to show that . Assume not, and let be an assignment compatible with that does not satisfy any literal of . Then, and because and , also , contradicting our assumption that is a strong -backdoor set of .

    2. otherwise, there is a clause in with and a clause in with . Let be the set of variables containing the one variable from plus any two variables corresponding to two positive literals from . Then returns the set .

      To show the correctness of this step assume that there is a strong -backdoor set of with and . It sufficies to show that . Assume not, and let be an assignment compatible with that does not satisfy any literal of . Then, contains the clause together with a subclause of containing at least two positive literals. Because and , we obtain that .

This completes the description and the proof of correctness of the algorithm . The running time of is the number of assignments of the at most variables in times the time required to test whether the reduced formula is in , i.e., runs in time . It remains to obtaine the stated bound of for the function . According to the two branching rules given in (2.a.ii) and (2.b) we obtain that can be bounded by the maximum of the following recurrence relations: (1) for any (2.a.ii) and (2) (2.b). In case of (1) the maximum of is obtained for by setting , and in case of (2) is at most . It follows that . ∎

In our next result, we consider heterogeneous base classes comprised of three Schaefer’s classes, namely and . We refer the reader to Figure 1 for an overview of the branching strategies employed here.

Theorem 4.

Strong -Backdoor Detection and Strong -Backdoor Detection are fixed-parameter tractable parameterized by the size of the backdoor set.

Proof.

We only give the proof for the class , since the proof for the class is analogous. Let . We will provide an algorithm solving -Strong Branch in time and satisfying . The result then follows from Theorem 1.

Let be the given CNF formula with variables , the given integer, and with . The algorithm first checks whether for every assignment . If that is the case then returns Yes. Otherwise let be an assignment such that , we consider two cases:

  1. if , then there is no strong -backdoor set of with and and the algorithm correctly returns the set ,

  2. otherwise, i.e., if , then we again distinguish two cases:

    1. there is a clause with , then we again distinguish two cases:

      1. , then the algorithm returns the set .

        To show the correctness of this step it is sufficient to show that does not have a strong -backdoor set with and . Assume for a contradiction that this is not the case and let be strong -backdoor set of with and . Because , we obtain that misses at least three literals from . Hence, there is an assignment that is compatible with such that contains a clause with . Clearly, and because contained only positive literals (because ) also . Hence, contradicting our assumption that is a strong -backdoor set for .

      2. otherwise, i.e., if , then the algorithm returns the set .

        To show the correctness of this step assume that there is a strong -backdoor set of with and . It suffices to show that . Assume not, and let be an assignment compatible with that does not satisfy any literal of . Then, and because and contains only positive literals, also , contradicting our assumption that is a strong -backdoor set for .

    2. there is a clause with and , we again distinguish two cases:

      1. there is a clause with (note that ). Let be a set of variables containing all variables of (at most two) plus three variables of of which two correspond to positive literals in . Then the algorithm returns the set .

        To show the correctness of this step assume that there is a strong -backdoor set of with and . It sufficies to show that . Assume not and let be an assignment compatible with , which does not satisfy any literal of . Then, contains as well as a subclause of of length at least three, which contains at least two positive literals. Then, and because , we obtain that , contradicting our assumption that is a strong -backdoor set for .

      2. otherwise, there are clauses with and . Let be a set of variables containing all variables of (at most two) and three variables of . Then the algorithm returns the set .

        To show the correctness of this step assume that there is a strong -backdoor set of with and . It sufficies to show that . Assume not and let be an assignment compatible with , which does not satisfy any literal of . Then, contains as well as a subclause of of length at least three. Because it follows that . Because also , we obtain that , contradicting our assumption that is a strong -backdoor set for .

    3. there is a clause with and . In this case also and hence the case is covered by case (2.b).

    4. The cases (2.a), (2.b), and (2.c) completely cover all possible cases, because if none of these cases apply then , which contradicts the choice of . To see this assume there is a clause with . Because of the cases (2.b) and (2.c), we obtain that . Furthermore, because of case (2.a), we obtain that . Hence, but such a clause cannot exist.

This completes the description and the proof of correctness of the algorithm . The running time of is the number of assignments of the at most variables in times the time required to test whether the reduced formula is in , i.e., runs in time . It remains to obtain the stated bound of for the function .

According to the three branching rules given in (2.a.ii), (2.b.i), and (2.b.ii) we obtain that can be bounded by the maximum of the following recurrence relations: (1) for any (2.a.ii), (2) (2.b.i), and (3) (2.b.ii). In case of (2) and (3) is at most and in case of (1) the maximum of is obtained for by setting . It follows that .

There is a clause

There is a clause

and

There is a clause

and

Say No.

Branch.

,

Branch.

and .

Branch.

with

and .

Implies , subsumed above.
Figure 1: The branching cases for Theorem 4.

We say that a pair of Schaefer classes is a bad pair if and . Our next result establishes hardness for the case when the base class contains a bad pair.

Theorem 5.

For every that contains at least one bad pair of Schaefer classes, it holds that Strong -Backdoor Detection is W[2]-hard parameterized by the size of the backdoor set, where .

Proof.

We give a parameterized reduction from the W[2]-complete Hitting Set problem. Given an instance for Hitting Set, construct a formula as follows. The variables of are . For each set , there is one clause . There is also one clause . This completes the description of the reduction.

We claim that has a hitting set of size at most if and only if the formula has a strong -backdoor set of size at most . Suppose , , is a hitting set. To show that is also a strong -backdoor set, consider any assignment . If for some , then satisfies the clause . Thus, since each clause in contains no negative literal and at least one positive literal and is hence in . If for all , then all clauses , are satisfied by since is a hitting set. The only remaining clause is HORN and 0-VAL since it has no positive literal and at least one negative literal.

For the other direction, suppose that is a strong -backdoor set of size at most . Obtain from by replacing each for any with by some variable from .

The set is also a strong -backdoor set of size at most . Therefore, the assignment with for all must satisfy all clauses . Otherwise, contains both a long clause containing only positive and a long clause containing only negative literals and hence . Thus, is a hitting set for of size at most . ∎

We now summarize our results in the following theorem.

Theorem 6.

Let