{'fraction_non_alphanumeric': 0.04056749543475207, 'fraction_numerical': 0.012923163365641241, 'mean_word_length': 4.364883195177091, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
On Tackling the Limits of Resolution in SAT Solving

The practical success of Boolean Satisfiability (SAT) solvers stems from the CDCL (Conflict-Driven Clause Learning) approach to SAT solving. However, from a propositional proof complexity perspective, CDCL is no more powerful than the resolution proof system, for which many hard examples exist. This paper proposes a new problem transformation, which enables reducing the decision problem for formulas in conjunctive normal form (CNF) to the problem of solving maximum satisfiability over Horn formulas. Given the new transformation, the paper proves a polynomial bound on the number of MaxSAT resolution steps for pigeonhole formulas. This result is in clear contrast with earlier results on the length of proofs of MaxSAT resolution for pigeonhole formulas. The paper also establishes the same polynomial bound in the case of modern core-guided MaxSAT solvers. Experimental results, obtained on CNF formulas known to be hard for CDCL SAT solvers, show that these can be efficiently solved with modern MaxSAT solvers.

maximum satisfiability problem, but in such a way that CDCL SAT solvers can still be exploited.
Given any CNF formula F, the paper shows how to encode the problem as Horn Maximum Satisfiability (HornMaxSAT), more concretely by requiring a given cost on the HornMaxSAT formulation. This enables solving the modified problem with either a MaxSAT solver or with a dedicated HornMaxSAT solver. The basic encoding is also shown to be subject to a number of optimizations, that can effectively reduce the number of variables. The paper then shows that for propositional encodings of the pigeonhole principle [27], transformed to HornMaxSAT, there exists a polynomially time bounded sequence of MaxSAT resolution steps which enables deriving a number of falsified clauses that suffices for proving unsatisfiable the original PHP formula. Similarly, the paper also proves that for modern core-guided MaxSAT solvers there exist sequences of unsatisfiable cores that enable reaching the same conclusion in polynomial time. This in turn suggests that MaxSAT algorithms [54] can be effective in practice when applied to such instances.
Experimental results, obtained on different encodings of the pigeonhole principle, but also on other instances that are well-known to be hard for resolution [68], confirm the theoretical result. Furthermore, a recently-proposed family of MaxSAT solvers [29,63], based on iterative computation of minimum hitting sets, is also shown to be effective in practice and on a wider range of classes of instances.
The paper is organized as follows. Section 2 introduces the definitions and notation used throughout the paper. Section 3 develops a simple encoding from SAT into Horn-MaxSAT. Section 4 derives a polynomial bound on the number and size of MaxSATresolution steps to establish the unsatisfiability of propositional formulas encoding the pigeonhole principle transformed into HornMaxSAT. The section also shows that there are executions of core-guided MaxSAT solvers that take polynomial time to establish a lower bound of the cost of the MaxSAT solution which establishes the unsatisfiability of the original CNF formula. Experimental results on formulas encoding the pigeonhole principle, but also on other formulas known to be hard for CDCL SAT solvers [68] are analyzed in Section 5.2. The paper concludes in Section 6.

Preliminaries
The paper assumes definitions and notation standard in propositional satisfiability (SAT) and maximum satisfiability (MaxSAT) [17]. Propositional variables are taken from a set X = {x 1 , x 2 , . . .}. A Conjunctive Normal Form (CNF) formula is defined as a conjunction of disjunctions of literals, where a literal is a variable or its complement. CNF formulas can also be viewed as sets of sets of literals, and are represented with calligraphic letters, A, F, H, etc. A truth assignment is a map from variables to {0, 1}. Given a truth assignment, a clause is satisfied if at least one of its literals is assigned value 1; otherwise it is falsified. A formula is satisfied if all of its clauses are satisfied; otherwise it is falsified. If there exists no assignment that satisfies a CNF formula F, then F is referred to as unsatisfiable. (Boolean) Satisfiability (SAT) is the decision problem for propositional formulas, i.e. to decide whether a given propositional formula is satisfiable. Since the paper only considers propositional formulas in CNF, throughout the paper SAT refers to the decision problem for propositional formulas in CNF.
To simplify modeling with propositional logic, one often represents more expressive constraints. Concrete examples are cardinality constraints and pseudo-Boolean constraints [17]. A cardinality constraint of the form x i ≤ k is referred to as an AtMostk constraint, whereas a cardinality constraint of the form x i ≥ k is referred to as an AtLeastk constraint. The study of propositional encodings of cardinality and pseudo-Boolean constraints is an area of active research [1,4,5,9,10,17,25,34,58,65,69].
A clause is Horn if it contains at most one positive literal. A Horn clause is a goal clause if it has no positive literals; otherwise it is a definite clause. The decision problem for Horn formulas is well-known to be in P, with linear time algorithms since the 80s [32,52]. A number of function problems defined on Horn formulas can be solved in polynomial time [48]. These include computing the lean kernel, finding a minimal unsatisfiable subformula and finding a maximal satisfiable subformula.

Propositional Encodings of the Pigeonhole Principle
The propositional encoding of the pigeonhole hole principle is well-known [27].
Propositional formulations of PHP encode the negation of the principle, and ask for an assignment such that the m + 1 pigeons are placed into m holes. The propositional encoding of the PHP m+1 m problem can be derived as follows. Let the variables be x ij , with 1 ≤ i ≤ m + 1, 1 ≤ j ≤ m, with x ij = 1 iff the i th pigeon is placed in the j th hole. The constraints are that each pigeon must be placed in at least one hole, and each hole must not have more than one pigeon.

MaxSAT, MaxSAT Resolution & MaxSAT Algorithms
MaxSAT. For unsatisfiable formulas, the maximum satisfiability (MaxSAT) problem is to find an assignment that maximizes the number of satisfied clauses (given that not all clauses can be satisfied). There are different variants of the MaxSAT problem [17,Chapter 19]. Partial MaxSAT allows for hard clauses (which must be satisfied) and soft clauses (which represent a preference to satisfy those clauses). There are also weighted variants, in which soft clauses are given a weight, and for which hard clauses (if any) have a weight of (meaning clauses that must be satisfied). The notation (c, w) will be used to represent a clause c with w denoting the cost of falsifying c. The paper considers partial MaxSAT instances, with hard clauses, for which w = , and soft clauses, for which w = 1. The notation H, S is used to denote partial MaxSAT problems with sets of hard (H) and soft (S) clauses. Throughout the paper, a MaxSAT solution represents either a maximum cardinality set of satisfied soft clauses or an assignment that satisfies all hard clauses and also maximizes (or minimizes, resp.) the number of satisfied (or falsified, resp.) soft clauses.
MaxSAT Resolution [18,46]. In contrast with SAT, the MaxSAT resolution operation requires the introduction of additional clauses other than the resolvent, and resolved clauses cannot be resolved again. Let (x ∨ A, u) and (¬x ∨ B, w) be two clauses, and let m min(u, w), u w (u == ) ? : u − w, with u ≥ w. The (nonclausal) MaxSAT resolution step [46] is shown in Table 1. (We could have used the clausal formulation [18], but it is more verbose and unnecessary for the purposes of the paper. It suffices to mention that clausal MaxSAT resolution adds at most 2n clauses at each resolution step, where the number of variables is n and the number of literals in each clause does not exceed n.) It is well-known that MaxSAT-resolution is unlikely to improve propositional resolution [18]. For the original PHP m+1 m formulas, there are known exponential lower bounds on the size of deriving one empty clause by MaxSATresolution (given that the remaining clauses are satisfiable) [18,Corollary 18].
MaxSAT Algorithms. Many algorithms for MaxSAT have been proposed over the years [17,Chapter 19]. The most widely investigated can be broadly organized into branch and bound [17,Chapter 19], iterative-search [12,36,45], core-guided [2,36,49,50,53,54,56], and minimum hitting sets [29,63]. In most proposed algorithms, coreguided and minimum hitting sets MaxSAT algorithms iteratively determine formulas to be unsatisfiable, until satisfiability is reached for a formula that relaxes clauses of minimum cost. This paper analyzes the operation of core-guided MaxSAT algorithms, concretely the MSU3 algorithm [49] 1 . Moreover, and to our best knowledge, the relationship between core-guided MaxSAT algorithms and MaxSAT resolution was first investigated in [56].

Related Work
The complexity of resolution on pigeonhole formulas has been studied by different authors, e.g. see [11,27,39,57,61] and references therein, among others. It is wellknown that for other proof systems, including cutting planes and extended resolution, PHP has polynomial proofs [6,20,21,26,28,64]. Different authors have looked into extending CDCL (and so resolution) with the goal of solving formulas for which resolution has known exponential lower bounds [7,12,13,16,37,38,40,43,44,67]. Some SAT solvers apply pattern matching techniques [14], but these are only effective for specific propositional encodings. Furthermore, there has been limited success in applying cutting planes and extended resolution in practical SAT solvers.

Reducing SAT to HornMaxSAT
The propositional satisfiability problem for CNF formulas can be reduced to Horn-MaxSAT, more concretely to the problem of deciding whether for some target Horn formula there exists an assignment that satisfies a given number of soft clauses.
Let F be a CNF formula, with N variables {x 1 . . . , x N } and M clauses {c 1 , . . . , c M }. Given F, the reduction creates a Horn MaxSAT problem with hard clauses H and soft clauses S, H, S = HEnc(F). For each variable x i ∈ X, create new variables p i and n i , where p i = 1 iff x i = 1, and n i = 1 iff x i = 0. Thus, we need a hard clause (¬p i ∨ ¬n i ), to ensure that we do not simultaneously assign x i = 1 and x i = 0. (Observe that the added clause is Horn.) This set of hard Horn clauses is referred to as P. For each clause c j , we require c j to be satisfied, by requiring that one of its literals not to be falsified. For each literal x i use ¬n i , and for each literal ¬x i use ¬p i . Thus, c j is encoded with a new (hard) clause c j with the same number of literals as c j , but with only negative literals on the p i and n i variables, and so the resulting clause is also Horn. The set of soft clauses S is given by (p i ) and (n i ) for each of the original variables x i . If the resulting Horn formula has a HornMaxSAT solution with at least N variables assigned value 1, then the original formula is satisfiable; otherwise the original formula is unsatisfiable. (Observe that, by construction, the HornMaxSAT solution cannot assign value 1 to more than N variables. Thus, unsatisfiability implies being unable to satisfy more than N − 1 soft clauses.) Clearly, the encoding outlined in this section can be the subject of different improvements, e.g. not all clauses need to be goal clauses. (An approach to tighten the encoding is detailed later in this section.) Example 1. Let the CNF formula be: The new variables are {n 1 , p 1 , n 2 , p 2 , n 3 , p 3 }. Preventing simultaneous assignment to 0 and 1 is guaranteed with the hard clauses: The original clauses are reencoded as hard clauses as follows: Finally, the soft clauses are The transformation proposed above can be related with the well-known dual-rail encoding, used in different settings [19,42,47,60,62]. To our best knowledge, the use of a dual-rail encoding for deriving a pure Horn formula has not been proposed in earlier work. Lemma 1. Given H, S = HEnc(F), there can be no more than N satisfied soft clauses.
Proof. By construction of H, S , for any x i , there is no assignment that satisfies H with n i = 1 and p i = 1.
Lemma 2. Let F have a satisfying assignment ν. Then, there exists an assignment that satisfies H and N soft clauses in H, S = HEnc(F). Proof. Given ν, we create an assignment ν to the n i and p i variables that satisfies the clauses in H, and N clauses in S. For each x i , if ν(x i ) = 1, then set p i = 1; otherwise set n i = 1. Thus, there will be N satisfied clauses in S. For each clause c j ∈ F, pick a literal l k assigned value 1. If l k = x k , then c k contains literal ¬n k , and so it is satisfied. If l k = ¬x k , then c k contains literal ¬p k , and so it is satisfied. Thus every clause in H is satisfied, and N soft clauses are satisfied.
Lemma 3. Let ν be an assignment that satisfies the clauses in H and N clauses in S. Then there exists an assignment ν that satisfies F. Proof. By construction of H, S , for each x i , either n i is assigned value 1, or p i is assigned value 1, but not both. Let ν( All variables x i are either assigned value 0 or 1. For clause c j , let l k be a literal assigned value 1. If l k = ¬n k , then x k is a literal in c j and since ν(x i ) = 1, then the clause c j is satisfied. Otherwise, if l k = ¬p k , then ¬x k is a literal in c j and since ν(x i ) = 0, then the clause c j is satisfied.
Lemma 1, Lemma 2 and Lemma 3 yield the following.
Theorem 1. F is satisfiable if and only if there exists an assignment that satisfies H and N clauses in S. The reduction of SAT into HornMaxSAT can also be applied to the PHP m+1 m problem. Example 2 (Pigeonhole Principle). With each variable x ij , 1 ≤ i ≤ m + 1, 1 ≤ j ≤ m, we associate two new variables: n ij and p ij . The set of clauses P prevents a variable x i from being assigned value 0 and 1 simultaneously: with |S| = 2m(m + 1). Thus, the complete reduction of PHP into MaxSAT becomes: Clearly, given P, one cannot satisfy more the m(m + 1) soft clauses. By Theorem 1, PHP m+1 m is satisfiable if and only if there exists an assignment that satisfies the hard clauses H and m(m + 1) soft clauses from S.
Reducing the number of variables. As hinted earlier in this section, one can devise encodings that use fewer variables, while producing a Horn MaxSAT formula. Given F, let N ⊆ F denote the set of non-Horn clauses. For each clause c j ∈ N , let C j represent the set of positive literals of c j , and let x i ∈ C j . Moreover, let W = ∪ j C j , i.e. the set of variables causing the clauses in N not to be Horn. Finally, let r i = 1 if and only if for clause c j variable x i is not dual-rail encoded. Clearly, for c j we must have xi∈Cj r i ≤ 1, i.e. the number of positive literals that remain cannot exceed 1; otherwise the resulting clause would not be Horn. Moreover, we would like to discard as many variables as possible, and so we add a soft clause (r i ) for each x i ∈ W . This corresponds to finding a maximum independent set, which we can approximate heuristically.

Short MaxSAT Proofs for PHP
This section shows that the reduction of PHP m+1 m to HornMaxSAT based on a dualrail encoding enables both existing core-guided MaxSAT algorithms and also MaxSAT resolution, to prove in polynomial time that the original problem formulation 2 is unsatisfiable. Recall from Theorem 1, that PHP m+1 m is satisfiable if and only if, given (5), there exists an assignment that satisfies H and m(m + 1) soft clauses in S. This section shows that for both core-guided algorithms and for MaxSAT resolution, we can conclude in polynomial time that satisfying H requires falsifying at least m(m + 1) + 1 soft clauses, thus proving PHP m+1 m to be unsatisfiable.
The results in this section should be contrasted with earlier work [18], which proves that MaxSAT resolution requires an exponentially large proof to produce an empty clause, this assuming the original propositional encoding for PHP m+1 m .

A Polynomial Bound on Core-Guided MaxSAT Algorithms
This section shows that a core-guided MaxSAT algorithm will conclude in polynomial time that more than m(m + 1) clauses must be falsified, when the hard clauses are satisfied, thus proving the original PHP m+1 m to be unsatisfiable. The analysis assumes the operation of basic core-guided algorithm, MSU3 [49], but similar analyses could be carried out for other families of core-guided algorithms 3 .
The following observations about (5) are essential to prove the bound on the run time. First, the clauses in the L i constraints do not share variables in common with the clauses in the M j constraints. Second, each constraint L i is of the form (¬n i1 ∨ . . . ∨ ¬n im ) and so its variables are disjoint from any other L k , k = i. Third, assuming a pairwise encoding, each constraint M j is of the form ∧ m+1 r=2 ∧ r−1 s=1 (¬p rj ∨ ¬p sj ), and so its variables are disjoint from any other M l , l = j. Since the sets of variables for each constraint are disjoint from the other sets of variables, we can exploit this partition of the clauses, and run a MaxSAT solver separately on each one. (Alternatively, we could assume the MSU3 MaxSAT algorithm to work with disjoint unsatisfiable cores.) Table 2 summarizes the sequence of unit propagation steps that yields a lower bound on the number of falsified clauses larger than m(m + 1). For each L i , the operation is summarized in the second row of Table 2. Unit propagation yields a conflict between m soft clauses and the corresponding hard clause. This means that at least one of these soft clauses must be falsified. Since there are m + 1 constraints L i , defined on disjoint 2 This section studies the original pairwise encoding of PHP m+1 m . However, a similar argument can be applied to PHP m+1 m provided any encoding of AtMost1 constraints Mj, as confirmed by the experimental results in Section 5.2. 3 Basic knowledge of core-guided MaxSAT algorithms is assumed. The reader is referred to recent surveys for more information [2,54].

Clauses
Unit Propagation sets of variables, then each will contribute at least one falsified soft clause, which puts the lower bound on the number of falsified clauses at m + 1.
For each M j the operation is summarized in rows 3 to last of Table 2. Each row indicates a sequence of unit propagation steps that produces a conflict, each on a distinct set of soft clauses. Observe that each soft clause (p kj ), k ≥ 2, induces a sequence of unit propagation steps, that causes the AtMost{k−1} constraint to become inconsistent. Concretely, for iteration k (where row 3 corresponds to iteration 1), the sequence of unit propagation steps is summarized in Table 3 4 . Since there are m such rows, then each M j contributes at least m falsified soft clauses. Moreover, the number of M j constraints is m, and so the M j constraints increase the bound by m · m.
Given the above, in total we are guaranteed to falsify at least m + 1 + m · m = m(m + 1) + 1 clauses, thus proving that one cannot satisfy m(m + 1) soft clauses if the hard clauses are satisfied. In turn, this proves that the PHP m+1 m problem is unsatisfiable.
We can also measure the run time of the sequence of unit propagation steps. For each L i , the run time is O(m), and there will be m such unit propagation steps, for a total O(m 2 ).  Moreover, it is important to observe that the unit propagation steps considered in the analysis above avoid the clauses in P, i.e. only the clauses in L i , M j , S, and relaxed clauses, are used for deriving the lower bound of m(m+1)+1 on the minimum number of falsified soft clauses. As shown in Section 5.2, and for the concrete case of PHP, the clauses in P are unnecessary and actually impact negatively the performance of coreguided MaxSAT solvers. Finally, and although the proof above assumes an MSU3-like core-guided algorithm, similar ideas could be considered in the case of other variants of core-guided MaxSAT algorithms [2,36,54,56].

A Polynomial Bound on MaxSAT Resolution
We can now exploit the intuition from the previous section to identify the sequence of MaxSAT resolution steps that enable deriving m(m + 1) + 1 empty clauses, thereby proving that any assignment that satisfies the hard clauses must falsify at least m(m + 1) + 1 soft clauses, and therefore proving that the propositional encoding of PHP is unsatisfiable. As before, we assume that the pairwise encoding is used to encode each constraint M j . As indicated earlier in Section 2.2, we consider a simplified version of MaxSAT resolution [46], which is non-clausal. As explained below, this is not problematic, as just a few clauses are of interest. For the clausal version of MaxSAT resolution, the other clauses, which our analysis ignores, are guaranteed to be linear in the number of variables at each step, and will not be considered again. Table 4 summarizes the essential aspects of the MaxSAT resolution steps used to derive m(m + 1) + 1 empty clauses. (Also, Section 4.1 clarifies that the formula can be partitioned if P is ignored.) Similarly to the previous section, the L i constraints serve to derive m + 1 empty clauses, whereas each M j constraint serves to derive m empty clauses. In total, we derive m(m + 1) + 1 empty clauses, getting the intended result. As shown in Table 4, for each constraint L i , start by applying MaxSAT resolution between the hard clause L i (¬n i1 ∨ . . . ∨ ¬n im ) and soft clause (n i1 ) to get soft clause (¬n i2 ∨ . . . ∨ ¬n im ), and a few other clauses (which are irrelevant for our purposes). Next, apply m − 1 additional MaxSAT resolution steps, resolving soft clause (¬n ik ∨ . . . ∨ ¬n im ) with soft clause (n ik ) to get soft clause (¬n ik+1 ∨ . . . ∨ ¬n im ). Clearly, the final MaxSAT resolution step will yield an empty clause. Therefore, over all m + 1 L i constraints, we derive m + 1 empty clauses. Table 4 also illustrates the application of the MaxSAT resolution steps to the pairwise encoding of M j . At iteration i, with 2 ≤ i ≤ m+1, we apply i MaxSAT resolution steps to derive another empty clause. In total, we derive m empty clauses for each M j . An essential aspect is selecting the initial clause from which each sequence of MaxSAT

Constraint
Clauses Resulting clause(s) resolution steps is executed. These reused clauses are highlighted in Table 4, and are crucial for getting the right sequence of MaxSAT resolution steps. For each M j , the MaxSAT resolution steps can be organized in m phases, each yielding an empty soft clause. For phase l, the previous phase l−1 produces the clause (p 1j ∨p 2j ∨. . .∨p lj , 1), which is then iteratively simplified, using unit soft clauses, until the empty soft clause for phase l is derived. It should be noted that the first phase uses two unit soft clauses to produce (p 1j ∨ p 2j , 1), which is then used in the second phase. As in Section 4.1, is is immediate that each soft clause is never reused.
Regarding the run time complexity, observe that each MaxSAT resolution step runs in time linear on the number of literals in the clauses. The clauses in the problem for-mulation have no more than O(m) literals. This also holds true as MaxSAT resolution steps are applied. By analogy with the analysis of the core-guided algorithm, a total of O(m 2 ) empty soft clauses will be derived. From the analysis above, summarized in Ta Proof. (Sketch) The discussion above.

Integration in SAT Solvers
This section shows that off-the-shelf MaxSAT solvers, which build on CDCL SAT solvers, can solve PHP m+1 m in polynomial time, provided the right order of conflicts is chosen. In turn, this motivates integrating core-guided MaxSAT reasoning into SAT solvers. Similarly, one could consider integrating MaxSAT resolution (or a mix of both [56]) but, like resolution, MaxSAT resolution is harder to implement in practice. The proposed problem transformation can be applied on demand, and the operation of CDCL can be modified to integrate some form of core-guided reasoning. In contrast to other attempts at extending CDCL, the use of MaxSAT reasoning, will build also on CDCL itself.

MaxHS-like Horn
MaxSAT. The reduction to Horn MaxSAT also motivates the development of dedicated MaxSAT solvers. One approach is to build upon MaxHSsolvers [29,63], since in this case the SAT checks can be made to run in linear time, e.g. using an implementation of LTUR [52]. As indicated above, similar technique can possibly be integrated into SAT solvers.
Handling P clauses. The P clauses prevent assigning a variable simultaneously value 0 and value 1. As the analysis for the PHP instances suggests, and the experimental results confirm, these clauses can be responsible for non-polynomial run times. One can envision attempting to solve problems without considering the P clauses, and then adding these clauses on demand, as deemed necessary to block non-solutions. The operation is similar to the well-known counterexample-guided abstraction refinement paradigm (CEGAR) [24].

Experimental Evaluation
This section evaluates the ideas proposed in the paper in practice, for the case of formulas that are known to be hard for resolution-based reasoning. Concretely, the experimental evaluation shows that the performance gains are provided by the proposed problem transformation and the follow-up core-guided MaxSAT solving. Table 5: Families of solvers considered in the evaluation (their best performing representatives are written in italics). SAT+ stands for SAT strengthened with other techniques, IHS MaxSAT is for implicit hitting set based MaxSAT, CG MaxSAT is for core-guided MaxSAT, MRes is for MaxSAT resolution, MIP is for mixed integer programming, OPB is for pseudo-Boolean optimization, BDD is for binary decision diagrams.

Experimental Setup
To illustrate the main points of the paper, a number of solvers were tested. However and in order to save space, the results are detailed below only for some of the tested competitors. 5 The families of the evaluated solvers as well as the chosen representatives for the families are listed in Table 5. The family of CDCL SAT solvers comprises MiniSat 2.2 (minisat) and Glucose 3 (glucose) while the family of SAT solvers strengthened with the use of other powerful techniques (e.g. Gaussian elimination, GA and/or cardinality-based reasoning, CBR) includes lingeling (lgl) and CryptoMiniSat (crypto). The MaxSAT solvers include the known tools based on implicit minimum-size hitting set enumeration, i.e. MaxHS (maxhs) and LMHS (lmhs), and also a number of coreguided solvers shown to be best for industrial instances in a series of recent MaxSAT Evaluations 6 , e.g. MSCG (mscg), OpenWBO16 (wbo) and WPM3 (wpm3), as well as the recent MaxSAT solver Eva500a (eva) based on MaxSAT resolution. Other competitors considered include CPLEX (lp), OPB solvers cdcl-cuttingplanes (cc) and Sat4j (sat4j) as well as a solver based on ZBDDs called ZRes (zres).
Note that three configurations of CPLEX were tested: (1) the default configuration and the configurations used in (2) MaxHS and (3) LMHS. Given the overall performance, we decided to present the results for one best performing configuration, which turned out to be the default one. Also, the performance of CPLEX was measured for the following two types of LP instances: (1) the instances encoded to LP directly from the original CNF formulas (see lp-cnf ) and (2) the instances obtained from the Horn-MaxSAT formulas (lp-wcnf ). A similar remark can be made with regard to the cc solver: it can deal with the original CNF formulas as well as their OPB encodings (the corresponding configurations of the solver are cc-cnf and cc-opb 7 , respectively).
Regarding the IHS-based MaxSAT solvers, both MaxHS and LMHS implement the Eq-Seeding constraints [30]. Given that all soft clauses constructed by the proposed HornMaxSAT transformation are unit and that the set of all variables of HornMaxSAT formulas is covered by the soft clauses, these eq-seeding constraints replicate the complete MaxSAT formula on the MIP side. As a result, after all disjoint unsatisfiable cores are enumerated by MaxHS or LMHS, only one call to an MIP solver is needed to compute the optimum solution. In order to show the performance of an IHS-based MaxSAT solver with this feature disabled, we additionally considered another configuration of LMHS called lmhs-nes. 8 All the conducted experiments were performed in Ubuntu Linux on an Intel Xeon E5-2630 2.60GHz processor with 64GByte of memory. The time limit was set to 1800s and the memory limit to 10GByte for each individual process to run.
Pigeonhole Principle benchmarks. The set of PHP formulas contains 2 families of benchmarks differing in the way AtMost1 constraints are encoded: (1) standard pairwiseencoded (PHP-pw) and (2) encoded with sequential counters [65] (PHP-sc). Each of the families contains 46 CNF formulas encoding the pigeonhole principle for 5 to 100 pigeons. Figure 1 9 shows the performance of the solver on sets PHP-pw and PHP-sc. As can be seen, the MaxSAT solvers (except eva and wbo) and also lp- * are able to solve all instances. As expected, CDCL SAT solvers perform poorly for PHP with the exception of lingeling, which in some cases detects cardinality constraints in PHP-pw. However, disabling cardinality constraints reasoning or considering the PHP-sc benchmarks impairs its performance tremendously. Also note that we were unable to reproduce the performance of zres applied to PHP reported in [22].
On discarding P clauses. To confirm the conjecture that the P clauses can hamper a MaxSAT solver's ability to get good unsatisfiable cores, we also considered both PHPpw and PHP-sc instances without the P clauses. Figure 2   the MaxSAT solvers working on PHP formulas w/ and w/o the P clauses. The lines with (no P) denote solvers working on the formulas w/o P (except maxhs and lmhs whose performance is not affected by removal of P). As detailed in Figure 2c, the efficiency of wbo is improved by a few orders of magnitude if the P clauses are discarded. Also, as shown in Figure 2b, mscg gets about an order of magnitude performance improvement outperforming all the other solvers.
Urquhart benchmarks and combined instances. The URQ instances are known to be hard for resolution [68], but not for BDD-based reasoning [22]. Here, we follow the  encoding of [22] to obtain the formulas of varying size given the parameter n of the encoder. In the experiments, we generated 3 CNF formulas for each n from 3 to 30 (i.e. URQ n,i for n ∈ {3, . . . , 30} and i ∈ {1, 2, 3}), which resulted in 84 instances. As expected, the best performance on the URQ instances is demonstrated by zres. Both maxhs and lmhs are not far behind. Note that both maxhs and lmhs do exactly 1 call to CPLEX (due to eq-seeding) after enumerating disjoint unsatisfiable cores. This contrasts sharply with the poor performance of lp-wcnf, which is fed with the same problem instances. Lingeling if augmented with Gaussian elimination (GA, see lgl in Figure 3a) performs reasonably well being able to solve 29 instances. However, as the result for lgl-nogauss suggests, GA is crucial for lgl to efficiently decide URQ. Note that lp-cnf and cc-opb are not shown in Figure 3a due to their inability to solve any instance.
The COMB benchmark set is supposed to inherit the complexity of both PHP and URQ instances and contains formulas PHP m+1 m ∨ URQ n,i with the PHP part being pairwise-encoded, where m ∈ {7, 9, 11, 13}, n ∈ {3, . . . , 10}, and i ∈ {1, 2, 3}, i.e. |COMB| = 96. As one can observe in Figure 3b, even these small m and n result in instances that are hard for most of the competitors. All IHS-based MaxSAT solvers (maxhs, lmhs, and lmhs-nes) perform well and solve most of the instances. Note that lgl is confused by the structure of the formulas (neither CBR nor GA helps it solve these instances). The same holds for zres. As for CPLEX, while lp-cnf is still unable to solve any instance from the COMB set, lp-wcnf can also solve only 18 instances. The opposite observation can be made for cc-cnf and cc-opb.
Summary. As shown in Table 6, given all the considered benchmarks sets, the proposed problem transformation and the follow-up IHS-based MaxSAT solving can cope with by far the largest number of instances overall (see the data for maxhs, lmhs, and lmhs-nes). The core-guided and also resolution based MaxSAT solvers generally perform well on the pigeonhole formulas (except wbo, and this has to be investigated further), which supports the theoretical claims of papers. However, using them does not help solving the URQ and also COMB benchmarks. Also, as shown in Figure 2, the P clauses can be harmful for MaxSAT solvers. As expected, SAT solvers cannot deal with most of the considered formulas as long as they do not utilize more powerful reasoning (e.g. GA or CBR). However, and as the COMB instances demonstrate, it is easy to construct instances that are hard for the state-of-the-art SAT solvers strengthened with GA and CBR. Finally, one should note the performance gap between maxhs (also lmhs) and lp-wcnf given that they solve the same instances by one call to the same MIP solver with the only difference being the disjoint cores precomputed by maxhs and lmhs.

Conclusions & Research Directions
Resolution is at the core of CDCL SAT solving, but it also represents its Achilles' heel. Many crafted formulas are known to be hard for resolution, with pigeonhole formulas representing a well-known example [27]. More importantly, some of these examples can occur naturally in some practical settings. In the context of MaxSAT, researchers have proposed a dedicated form of resolution, i.e. MaxSAT resolution [18,46], which was also shown not to be more powerful than propositional resolution [18] for the concrete case of pigeonhole formulas [27].
This paper proposes a general transformation for CNF formulas, by encoding the SAT decision problem as a MaxSAT problem over Horn formulas. The transformation is based on the well-known dual-rail encoding, but it is modified such that all clauses are Horn. More importantly, the paper shows that, on this modified formula, MaxSAT resolution can identify in polynomial time a large enough number of empty soft clauses such that this number implies the unsatisfiability of the original pigeonhole formula. Furthermore, the paper shows that the same argument can be used to prove a polynomial run time for the well-known class of core-guided MaxSAT solvers [54].
Experimental results, obtained on formulas known to be hard for SAT solvers, show that different families of MaxSAT solvers perform far better than the best performing SAT solvers, and also ILP solvers, on these instances.
As the paper also hints at, future work will investigate effective mechanisms for integrating Horn MaxSAT problem transformation and MaxSAT reasoning techniques into SAT solvers. In contrast to cutting planes or extended resolution, MaxSAT algorithms already build on CDCL SAT solvers; this is expected to facilitate integration. Another research direction is to investigate similar transformations for the many other examples for which resolution has exponential lower bounds, but also when to opt to apply such transformations.