1 Introduction
Recall that the twoelement field has elements , where addition is XOR, which we write as , while multiplication is AND, written . A linear system of equations over , in matrix form , where is an matrix over , with the number of equations, the number of variables, while , yields a boolean function , which assigns to a total assignments of the variables of iff that assignment is a solution of . The task of “good” representations of by conjunctive normal forms (clausesets, to be precise), for the purpose of SAT solving, shows up in many applications, for example cryptanalysing the Data Encryption Standard and the MD5 hashing algorithm in [16], translating PseudoBoolean constraints to SAT in [22], and in roughly in benchmarks from SAT 2005 to 2011 according to [57] (see Subsection 1.4 for an overview on the literature).
The basic criterion for a good is “arcconsistency”, which we write as “ACrepresentation” (similar to “representation”, explained later); in Subsection 1.4.1 we review and discuss this terminology. For an arbitrary boolean function , a CNFrepresentation of is AC if for every partial assignment to the variables of , when applying the partial assignment to , i.e., performing , and then performing unitclause propagation, which we write as , the result has no forced assignments anymore, that is, for every remaining variable and the result of assigning to in is satisfiable.
1.1 The lower bound
We show that there is no polynomialsize ACrepresentation of arbitrary linear systems (Theorem 6.5). To show this, we apply the lower bound on monotone circuit sizes for monotone span programs (msp’s) from [2], by translating msp’s into linear systems. An msp computes a boolean function (with ), by using auxiliary boolean variables , and for each a linear system , where is an matrix over . For the computation of , a value means the system is active, while otherwise it’s inactive; the value of is if all the active systems together are unsatisfiable, and otherwise. Obviously is monotonically increasing. The task is now to put that machinery into a single system of (XOR) equations. The main idea is to “dope” each equation of every with a dedicated new boolean variable added to the equation, making that equation trivially satisfiable, independently of everything else; all these auxiliary variables together are called , where is the number of equations in .
Example 1.1
Consider (), which can be represented by an msp with (with , thus ), where activates , while activates and activates . If , then the combined system is unsatisfiability, otherwise it is satisfiable. The doping process applied to yields linear equations , and .
If all the doping variable used for a system are set to , then they disappear and the system is active, while if they are not set, then this system is trivially satisfiable, and thus is deactivated. Now consider an ACrepresentation of . Note that the are not part of , but the variables of are together with , where the latter represent in a sense the . From we can compute by setting the accordingly (if , then all belonging to are set to , if , then these variables stay unassigned), running on the system, and output iff the empty clause was produced by . So we can compute msp’s from ACrepresentations of the corresponding linear system, since we can apply partial instantiation. The second pillar of the lowerbound proof is a general polynomialtime translation of ACrepresentations of (arbitrary) boolean functions into monotone circuits computing a monotonisation of the boolean function (Theorem 6.1; motivated by [9]), where this monotonisation precisely enables partial instantiation. So from we obtain a monotone circuit computing , whose size is polynomial in , where by [2] the size of is for certain msp’s.
Based on [34], this superpolynomial lower bound also holds, if we consider any fixed , and instead of requiring unitclause propagation to detect all forced assignments, we only ask that “asymmetric widthbounded resolution”, i.e., resolution, is sufficient to derive all contradictions obtained by (partial) instantiation (to the variables in ); see Corollary 6.6. Here resolution is the appropriate generalisation of widthbounded resolution for handling long clauses (see [49, 51, 52, 54]), where for each resolution step at least one parent clause has length at most (while the standard “symmetric width” requires both parent clauses to have length at most ).
1.2 Upper bounds
Besides this fundamental negative result, we provide various forms of good representations of systems with bounded number of equations. Theorem 9.2 shows that there is an ACrepresentation with many clauses. The remaining results use a stronger criterion for a “good” representation, namely they demand that , where is the class of “unitpropagation complete clausesets” as introduced in [12] — while for AC only partial assignments to the variables of are considered, now partial assignments for all variables in (which contains the variables of , and possibly further auxiliary variables) are to be considered. For the obvious translation , by subdividing the big constraints into small constraints, is in (Lemma 8.4). For we have an intelligent representation in (Theorem 10.1), while the use of (piecewise) is still feasible for full (dag)resolution, but not for treeresolution (Theorem 10.6).
We conjecture (Conjecture 10.2) that Theorem 9.2 and Theorem 10.1 can be combined, which would yield an fptalgorithm for computing a representation for arbitrary with the parameter . We now turn to a discussion of the advantages of having a representation in compared to mere AC, also placing this in a wider framework.
1.3 Measuring “good” representations
We have seen yet two criteria for good representations of boolean functions, namely AC and the stronger condition of unitpropagation completeness. In Subsection 1.3.1 we discuss some fundamental aspects of these two criteria, while in Subsection 1.3.2 we consider another criterion, namely unitrefutation completeness, concluding this excursion in Subsection 1.3.3 by a general framework.
1.3.1 AC versus
It has been shown that the practical performance of SAT solvers can depend heavily on the SAT representation used. See for example [5, 72, 22] for work on cardinality constraints, [75, 76] for work on general constraint translations, and [46, 31] for investigations into different translations in cryptography. In order to obtain “good” representations, the basic concept is that of an ACrepresentation. The task is to ensure that for all (partial) assignments to the variables of the constraint, if there is a forced assignment (i.e., some variable which must be set to a particular value to avoid inconsistency), then unitclause propagation () is sufficient to find and set this assignment. In a similar vein, there is the class of propagationcomplete clausesets, containing all clausesets for which unitclause propagation is sufficient to detect all forced assignments; the class was introduced in [12], while in [3] it is shown that membership decision is coNPcomplete.
AC and may at a glance seem the same concept. However there is an essential difference. When translating a constraint into SAT, typically one does not just use the variables of the constraint, but one adds auxiliary variables to allow for a compact representation. Now when speaking of AC, one only cares about assignments to the constraint variables. But propagationcompleteness deals only with the representing clauseset, thus can not know about the distinction between original and auxiliary variables, and thus it is a property on the (partial) assignments over all variables! So a SAT representation, which is AC, will in general not fulfil the stronger property of propagationcompleteness, due to assignments over both constraint and auxiliary variables yielding a forced assignment or even an inconsistency which doesn’t detect.
In [44] it is shown that conflictdriven solvers with branching restricted to input variables have only superpolynomial runtime on , an (extreme) Extended Resolution extension to the pigeonhole formulas, while unrestricted branching determines unsatisfiability quickly (see [54] for a prooftheoretical analysis of the general context). Also experimentally it is demonstrated in [45] that inputrestricted branching can have a detrimental effect on solver times and proof sizes for modern CDCL solvers. This adds motivation to considering all variables (rather than just input variables), when deciding what properties we want for SAT translations. We call this the “absolute (representation) condition”, taking also the auxiliary variables into account, while the “relative condition” only considers the original variables.
Besides avoiding the creation of hard unsatisfiable subproblems, the absolute condition also enables one to study the “target classes”, like , on their own, without relation to what is represented. Target classes different from have been proposed, and are reviewed in the following. The underlying idea of AC and propagationcomplete translations is to compress all of the constraint knowledge into the SAT translation, and then to use to extract this knowledge when appropriate. In Subsection 1.3.2 we present a weaker notion of what “constraint knowledge” could mean, while in Subsection 1.3.3 we present different extraction mechanisms.
1.3.2 Unitrefutation completeness
In [32, 33, 37] we considered the somewhat more fundamental class of “unitrefutation complete” clausesets, introduced in [21] as a method for propositional knowledge compilation. Rather than requiring that detects all forced assignments (as for ), a clauseset is in iff for all partial assignments resulting in an unsatisfiable clauseset, detects this. As shown in [32, 33, 37], the equation holds, where , introduced in [71], is a fundamental class of clausesets for which SAT is decidable in polynomial time; in [14] it was shown that membership decision for is coNPcomplete.
These considerations can be extended to a general “measurement” approach, where we do not just have in/out for some target classes, but where a “hardness” measure tells us how far is from resp. (in some sense), and this general approach is discussed next.
1.3.3 How to gauge representations?
We now outline a a more general approach to gauge how good is a representation of a boolean function . Obviously the size of must be considered, number of variables , number of clauses , number of literal occurrences . Currently we do not see a possibility to be more precise than to say that a compromise is to be sought between stronger inference properties of and the size of . One criterion to judge the inference power of is AC, as already explained. This doesn’t yield a possibility in case no ACrepresentation is feasible, nor is there a possibility for stronger representations. Our approach addresses these concerns as follows.
[32, 37] introduced the measures (“hardness”, “phardness”, and “whardness”), where is the set of all clausesets (interpreted as CNF’s), and is some set of variables. These measures determine the maximal “effort” (in some sense) needed to show unsatisfiability of instantiations of for partial assignments with in case of and , resp. the maximal “effort” to determine all forced assignments for in case of . The “effort” in case of or is the maximal level of generalised unitclause propagation needed, that is the maximal for reductions introduced in [51, 52], where is unitclause propagation and is (complete) elimination of failed literals. While for the effort is the maximal needed for asymmetric widthbounded resolution, i.e., for each resolution step one of the parent clauses must have length at most .^{1)}^{1)}1)Symmetric widthbounded resolution requires both parent clauses to have length at most , which for arbitrary clauselength is not appropriate as complexity measure, since already unsatisfiable Horn clausesets need unbounded symmetric width; see [54] for the use of asymmetric width in the context of resolution and/or space lower bounds.
Now we have that is an ACrepresentation of iff , while would allow higher levels of generalised unitclause propagation (allowing potentially shorter ). Weaker is the requirement , which has various names in the literature: we call it “relative hardness”, while [11] calls it “existential unitrefutation completeness”, and [4] calls it “unit contradiction”. Now not every forced assignment is necessarily detected by unitclause propagation, but only unsatisfiability. Similarly, would allow higher levels of generalised unitclause propagation.
If we only consider “relative (w/p)hardness”, that is, , then, as shown in [34], regarding polysize representations for all conditions , , and are equivalent to AC (), that is, the representations can be transformed in polynomial time into ACrepresentations. These transformations produce large representations (and very likely they are not fixedparameter tractable in ), and so higher can yield smaller representations, however these savings can not be captured by the notion of polynomial size.
This situation changes, as we show in [36], when we do not allow auxiliary variables, that is, we require : Now higher for each of these measures allows short representations which otherwise require exponential size. We conjecture, that this strictness of hierarchies also holds in the presence of auxiliary variables, but using the absolute condition, i.e., (all variables are included in the worstcase determinations for (w/p)hardness). The measurements in case of are just written as . In this way we capture the classes and , namely and . More generally we have , and . The basic relations between these classes are for , for , and for .
1.4 Literature review
Section 1.5 of [33, 37] discusses the translation of the socalled “Schaefer classes” into the hierarchy; see Section 12.2 in [19] for an introduction, and see [18] for an indepth overview on recent developments. All Schaefer classes except affine equations have natural translations into either or . The open question was whether systems of XORclauses (i.e., affine equations) can be translated into for some fixed ; the current paper answers this question negatively.
Our investigations into the classes started with [32, 37]. From there on, three new developments started. First we have this paper. Then we have [36], showing that without auxiliary variables, the hierarchies , and are strict regarding polysize representations of boolean functions. Finally, [34] discusses general tools for obtaining “good” representations, and how SAT solvers perform with them; it contains the proof that regarding the relative condition and allowing auxiliary variables, all three hierarchies , and collapse to their first level (regarding polysize representations). The predecessor of [36, 34] and the current report is [35], while the (shortened) conference version of the current report is [38].
1.4.1 Discussion of terminology “arcconsistent representation”
We think that the current terminology in the literature can potentially cause confusion between the fields CSP (constraintsatisfaction problems) and SAT, and thus some clarifying discussion is needed. The notion “ACrepresentation” of fully expanded says: “a representation maintaining hyperarcconsistency (or generalised arcconsistency) via unitclause propagation for the (single, global) boolean constraint after (arbitrary) partial assignments”. Recall that a constraint is “hyperarcconsistent” if for each variable each value in its (current) domain is still available (does not yield an inconsistency); see Chapter 3 of [68]. However for a (boolean) clauseset it is not clear what the “constraint” is. In our context it is most natural to consider the whole as a “constraint”, and then, since every variable has (precisely) two values, “arcconsistency” of means that has no forced assignments (or no “forced literals”). It must be emphasised here that considering as a single constraint is not a natural point of view for the CSP area. The standard notion of “arcconsistency” just applies to , and for ordinary constraints is considered as constant — only “global constraints” are allowed to contain a nonconstant number of variables. Especially for XORclausesets it is tempting to take each XORclause as a constraint, but this is not interesting here.
The notion of “an encoding maintaining arcconsistency via unit propagation” has been introduced in [28], showing that the support encoding of a single constraint yields in our terminology an ACrepresentation — it is essential here that this assumes as usual that the number of variables is constant. “Maintaining”, as in “MAC” for “maintaining arcconsistency”, applies to constraints after a domain restriction (which for SAT is achieved by partial assignments), where (hyper)arcconsistency has to be reestablished (this can be done in polynomial time, since the number of variables in a constraint is constant). Apparently the first explicit definition of “arcconsistency under unit propagation” for SAT representations is [22], the Definition on Page 5 (it is left open whether may also involve the introduced variables, but this is a kind of automatic assumption, since only the variables of the (original) constraint are considered in this context^{2)}^{2)}2)An assumption which we challenge by considering .). For further examples for pseudoboolean constraints see Section 22.6.7 in [69] and [5, 72, 6], while related considerations one finds in [48].
We prefer to speak of “ACrepresentations”, hiding the “arcconsistency”. It also seems superfluous to mention in this context “unit(clause) propagation”. One could also say “ACtranslation” or“ACencoding”, but we reserve “translation” for (polytime) functions computing a representation, and “encoding” for the translation of nonboolean variables into boolean variables. Our own “proper terminology” for an “ACrepresentation” of is that is a CNFrepresentation of with relative phardness at most , i.e., .
1.4.2 Applications of XORconstraints
If we do not specify the representation in the following, then essentially what we call is used, that is, breaking up long XORconstraints into short ones and using the unique equivalent CNF’s for the short constraints.
XORconstraints are a typical part of cryptographic schemes, and accordingly it is important to have “good” representations for them. The earliest application of SAT to cryptanalysis is [65], translating DES to SAT and then considering finding a key. In [16], DES is encoded to ANF (“algebraic normal form”, that is, XOR’s of conjunctions), and then translated. [46] attacks DES, AES and the Courtois Toy Cipher via translation to SAT. Each cipher is first translated to equations over GF(2) and then to CNF. A key contribution is a specialised translation of certain forms of polynomials, designed to reduce the number of variables and clauses. The size for breaking up long XORconstraints is called the “cutting length”, and has apparently some effect on solver times. [66] translates MD5 to SAT and finds collisions. MD5 is translated by modelling it as a circuit (including XORs) and applying the Tseitin translation.
[64] provides an overview of SATbased methods in Electronic Design Automation, and suggests keeping track of circuit information (fan in/fan out of gates etc.) in the SAT solver when solving such instances. XOR is relevant here due to the use of XOR gates in the underlying circuit being checked (and translated).
A potential application area is the translation of pseudoboolean constraints, as investigated by [22]. Translations via “fulladders” introduces XORs via translation of the fulladder circuit. It is shown that this translation does not produce an ACrepresentation (does not “maintain arcconsistency via unit propagation”), and the presence of XOR and the log encoding is blamed for this (in Section 5.5). Experiments conclude that sorting network and BDD methods perform better, as long as their translations are not too large.
1.4.3 Hard examples via XORs
It is wellknown that translating each XOR to its prime implicates results in hard instances for resolution. This goes back to the “Tseitin formulas” introduced in [77], which were proven hard for full resolution in [78], and generalised to (empirically) hard satisfiable instances in [39]. A wellknown benchmark was introduced in [17], called the “Minimal Disagreement Parity” problem (which became the parity32 benchmarks in the SAT2002 competition). Given vectors , further bits , and , find a vector such that , where is the scalar product. The SAT encoding is for (so iff ), together with a cardinality constraint based on fulladders. So the XORs occur both in the summations and the cardinality constraint. These benchmarks were first solved by the solver EqSatz ([63]).
1.4.4 Special reasoning
It is natural to consider extensions of resolution and/or SAT techniques to handle XORconstraints more directly. The earliest theoretical approach seems [7], integrating a proof calculus for Gaussian elimination with an abstract proof calculus modelling DPLL. It is argued that such a system should offer improvements over just DPLL/resolution in handling XORs. [42] points out the simple algorithm for extracting “equivalence constraints”. The earliest SAT solver with special reasoning is EqSatz ([63]), extracting XORclauses from its input and applying DPresolution plus incomplete XOR reasoning rules. More recently, CryptoMiniSAT ([74, 73]) integrates Gaussian elimination during search, allowing both explicitly specified XORclauses and also XORclauses extracted from CNF input. However in the newest version 3.3 the XOR handling during search is removed, since it is deemed too expensive.^{3)}^{3)}3)See http://www.msoos.org/2013/08/whycryptominisat33doesnthavexors/. Further approaches for hybrid solvers one finds in [15, 40].
A systematic study of the integration of XORreasoning and SATtechniques has been started with [55], by introducing the “DPLL(XOR)” framework, similar to SMT. These techniques have also been integrated into MiniSat. [56] expands on this by reasoning about equivalence classes of literals created by binary XORs, while [58] learns conflicts in terms of “parity (XOR) explanations”. The latest paper [59] (with underlying report [60]) extends the reasoning from “Gauß elimination” to “GaußJordan elimination”, which corresponds to moving from relative hardness to relative phardness, i.e., also detecting forced literals, not just inconsistency.^{4)}^{4)}4)We say “relative” here, since the reasoning mechanism is placed outside of SAT solving, different from the “absolute” condition, where also the reasoning itself is made accessible to SAT solving (that is, one can (feasibly!) split in some sense on the higherlevel reasoning). Theorem 4 in [59] is similar in spirit to Corollary 4.8, Part 2, considering conditions when strong reasoning only needs to be applied to “components”.
Altogether we see a mixed picture regarding special reasoning in SAT solvers. The first phase of expanding SAT solvers could be seen as having ended in some disappointment regarding XOR reasoning, but with [55] a systematic approach towards integrating special reasoning has been reopened. A second approach for handling XORconstraints, the approach of this paper, is by using intelligent translations (possibly combined with special reasoning).
1.4.5 Translations to CNF
Switching now to translations of XORs to CNF, [57] identifies the subsets of “treelike” systems of XOR constraints, where the standard translation delivers an ACrepresentation (our Theorem 8.5 strengthens this, showing that indeed a representation in is obtained):

[57] also considered equivalence reasoning, where for “cyclepartitionable” systems of XOR constraints this reasoning suffices to derive all conclusions.

Furthermore [57] showed how to eliminate the need for such special equivalence reasoning by another ACrepresentation.

In general, the idea is to only use Gaussian elimination for such parts of XOR systems which the SAT solver is otherwise incapable of propagating on. Existing propagation mechanisms, especially unitclause propagation, and to a lesser degree equivalence reasoning, are very fast, while Gaussian elimination is much slower (although still polytime).
Experimental evaluation on SAT 2005 benchmarks instances showed that, when “not too large”, such CNF translations outperform dedicated XOR reasoning modules. The successor [61] provides several comparisons of specialreasoning machinery with resolutionbased methods, and in Theorem 4 there we find a general ACtranslation; our Theorem 9.2
yields a better upper bound, but the heuristic reasoning of
[59, 61] seems valuable, and should be explored further.1.5 Better understanding of “SAT”
One motivation of our investigations is the question on the relation between CSP and SAT, and on the success of SAT. Viewing a linear system as a constraint on , one can encode evaluation via Tseitin’s translation, obtaining a CNFrepresentation with the property that for every total assignment , i.e., , we have that either contains the empty clause or is empty.^{5)}^{5)}5)In Subsection 9.4.1 of [36] this class of representations is called ; up to lineartime transformation it is the same as representations by boolean circuits. However this says nothing about partial assignments , and as our result shows (Theorem 6.5), there is indeed no polysize representation which handles all partial assignments. One can write an algorithm (a kind of “constraint”, now using Gaussian elimination) which handles (in a sense) all partial assignments in polynomial time (detects unsatisfiability of for all partial assignments ), but this can not be integrated into the CNF formalism (by using auxiliary variables and clauses), since algorithms always need total assignments, and so partial assignments would need to be encoded — the information “variable not assigned” (i.e., ) needs to be represented by setting some auxiliary variable, and this must happen by a mechanism outside of the CNF formalism.
It is an essential strength of the CNF formalism to allow partial instantiation; if we want these partial instantiations also to be easily understandable by a SAT solver, then the results of [9] and our results show that there are restrictions. Yet there is little understanding of these restrictions. There are many examples where AC and stronger representations are possible, while the current nonrepresentability results, one in [9], one in this article and a variation on [9] in [54], rely on nontrivial lower bounds on monotone circuit complexity; in fact Corollary 6.4 shows that there is a polysize ACrepresentation of a boolean function if and only if the monotonisation , which encodes partial assignments to , has polysize monotone circuits.
1.6 Overview on results
In Section 2 we give the basic definitions related to clausesets, and in Section 3 we review the basic concepts and notions related to hardness, whardness, and the classes and . Section 4 contains a review of phardness and the classes , and also introduces basic criteria for for clausesets : the main result Theorem 4.6 shows that the “incidence graph” being acyclic is sufficient. In Section 5 we introduce the central concepts of this article, “XORclausesets” and their CNFrepresentations, and show in Lemma 5.2, that the sum of XORclauses is the (easier) counterpart to the resolution operation for (ordinary) clauses.
In Section 6 we present our general lower bound. Motivated by [9], in Theorem 6.1 we show that from a CNFrepresentation of relative hardness of a boolean function we obtain in polynomial time a monotone circuit computing the monotonisation , which extends by allowing partial assignments to the inputs.^{6)}^{6)}6)The precise relation to the results of [9] is not clear. The notion of “CNF decomposition of a consistency checker” in [9] is similar to an ACrepresentation, but it contains an additional special condition. Actually, as we show in Corollary 6.4, in this way ACrepresentations are equivalently characterised. Theorem 6.5 shows that there are no short ACrepresentations of arbitrary XORclausesets (at all), with Corollary 6.6 generalising this to arbitrary relative whardness.
The fundamental translation of XORclausesets (using the trivial translation for every XORclause) is studied in Section 7, with Lemma 7.1 stating the basic criterion for . Furthermore the Tseitin formulas are discussed. The standard translation, called , uses , but breaks up long clauses first (to avoid the exponential sizeexplosion), and is studied in Section 8. The main result here is Theorem 8.5, showing that if fulfils the basic graphtheoretic properties considered before, then . In Section 9 we show that , where is obtained from by adding all implied XORclauses, achieves AC in linear time for a constant number of XORclauses (Theorem 9.2). In Section 10 we turn to the question of two XORclauses and . In Theorem 10.1 we show how to obtain a translation . Then we discuss and and show, that all three cases can be distinguished here regarding their complexity measures; the worst representation is , which still yields an acceptable translation regarding whardness, but not regarding hardness (Theorem 10.6). Finally in Section 11 we present the conclusions and open problems.
2 Preliminaries
We follow the general notations and definitions as outlined in [50]. We use and . Let be the infinite set of variables, and let be the set of literals, the disjoint union of variables as positive literals and complemented variables as negative literals. We use to complement a set of literals. A clause is a finite subset which is complementfree, i.e., ; the set of all clauses is denoted by . A clauseset is a finite set of clauses, the set of all clausesets is . By we denote the underlying variable of a literal , and we extend this via for clauses , and via for clausesets . The possible literals in a clauseset are denoted by . Measuring clausesets happens by for the number of variables, for the number of clauses, and for the number of literal occurrences. A special clauseset is , the empty clauseset, and a special clause is , the empty clause.
A partial assignment is a map for some finite , where we set , and where the set of all partial assignments is . For let (with and ). We construct partial assignments by terms for literals with different underlying variables and . For and we denote the result of applying to by , removing clauses containing with , and removing literals with from the remaining clauses. By the set of satisfiable clausesets is denoted, and by the set of unsatisfiable clausesets.
By we denote unitclause propagation, that is,

if ,

if contains only clauses of length at least ,

while otherwise a unitclause is chosen, and recursively we define .
It is easy to see that the final result does not depend on the choices of the unitclauses. In [51, 52] the theory of generalised unitclause propagation for was developed; the basic idea should become clear from the definition of , which is complete “failed literal elimination”: if , then , if otherwise there is a literal such that , then , and otherwise .
Reduction by applies certain forced assignments to the (current) , which are assignments such that the opposite assignment yields an unsatisfiable clauseset, that is, where ; the literal here is also called a forced literal. The reduction applying all forced assignments is denoted by (so ). Forced assignments are also known under other names, for example “necessary assignments” or “backbones”; see [43] for an overview on algorithms computing all forced assignments.
Two clauses are resolvable iff they clash in exactly one literal , that is, , in which case their resolvent is (with resolution literal ). A resolution tree is a full binary tree formed by the resolution operation. We write if is a resolution tree with axioms (the clauses at the leaves) all in and with derived clause (at the root) .
A prime implicate of is a clause such that a resolution tree with exists, but no exists for some with ; the set of all prime implicates of is denoted by . The term “implicate” refers to the implicit interpretation of as a conjunctive normal form (CNF). Considering clauses as combinatorial objects one can speak of “prime clauses”, and the “” in our notation reminds of “unsatisfiability”, which is characteristic for CNF. Two clausesets are equivalent iff . A clauseset is unsatisfiable iff . If is unsatisfiable, then every literal is a forced literal for , while otherwise is forced for iff . It can be considered as known, that for a clauseset the computation of all prime implicates is fixedparameter tractable (fpt) in the number of clauses, but perhaps that is not stated explicitly in the literature, and so we provide a simple proof:
Lemma 2.1
Consider and let . Then , and can be computed in time .
Proof: By Subsection 4.1 (especially Lemma 4.12) in [36] we run through all subsets , determine the set of pure literals of , and include if is an implicate of (note that SATdecision for a CNFclauseset can be done in time ). To the final result subsumptionelimination is applied, which can be done in cubic time, and we obtain .
3 Measuring “SAT representation complexity”
In this section we define and discuss the measures and the corresponding classes . It is mostly of an expository nature, explaining the background from [51, 52, 32, 33, 37]. For the measure and the corresponding classes see Section 4.
3.1 Hardness and
Hardness for unsatisfiable clausesets was introduced in [51, 52], while the specific generalisation to arbitrary clausesets used here was first mentioned in [1], and systematically studied in [32, 33, 37]. Using the HortonStrahler number of binary trees, applied to resolution trees (deriving clause from ), the hardness for can be defined as the minimal such that for all prime implicates of there exists with . An equivalent characterisation uses necessary levels of generalised unitclause propagation (see [32, 33, 37] for the details):
Definition 3.1
Consider the reductions for as introduced in [51]; it is unitclause propagation, while is (full, iterated) failedliteral elimination. Then for and is the minimal such that for all with and holds , i.e., the minimal such that detects unsatisfiability of any partial instantiation of variables in . Furthermore .
For every there is a partial assignment with , where consists of certain forced assignments , i.e., . A weaker localisation of forced assignments has been considered in [20], namely “backbones”, which are forced assignments for such that there is with and such that is forced also for . It is not hard to see that for will set all backbones of (using that for we have by Lemma 3.18 in [51]). The fundamental level of “hardness” for forced assignments or unsatisfiability is given by the level needed for . As a hierarchy of CNFclasses and only considering detection of unsatisfiability (for all instantiations), this is captured by the hierarchy (with “UC” for “unitrefutation complete”):
Definition 3.2
For let .
is the class of unitrefutation complete clausesets, as introduced in [21]. In [32, 33, 37] we show that , where is the class of clausesets solvable via Single Lookahead Unit Resolution (see [25]). Using [14] we then obtain ([32, 33, 37]) that membership decision for () is coNPcomplete for . The class is the class of all clausesets where unsatisfiability for any partial assignment is detected by failedliteral reduction (see Section 5.2.1 in [41] for the usage of failed literals in SAT solvers).
3.2 WHardness and
A basic weakness of the standard notion of widthrestricted resolution, which demands that both parent clauses must have length at most for some fixed (“width”, denoted by below; see [8]), is that even Horn clausesets require unbounded width in this sense. A better solution, as investigated and discussed in [51, 52, 54], seems to use the notion of “resolution” as introduced in [49], where only one parent clause needs to have length at most (thus properly generalising unitresolution).^{7)}^{7)}7)Symmetric width is only applied to clausesets with bounded clauselength, and here everything can be done as well via asymmetric width, as discussed in [54]. It might be that symmetric width could have a relevant combinatorial meaning, so that symmetric and asymmetric width both have their roles. Nested inputresolution ([51, 52]) is the prooftheoretic basis of hardness, and approximates treeresolution. In the same vein, resolution is the prooftheoretic basis of “whardness”, and approximates dagresolution (see Theorem 6.12 in [52]):
Definition 3.3
The whardness (“widthhardness”, or “asymmetric width”) is defined for as follows:

If , then .

If , then .
For let .
The symmetric width is defined in the same way, only that for we define as the minimal such that there is , where all clauses of (axioms and resolvents) have length at most .
More generally, for , we define and for unsatisfiable , while for satisfiable only with are considered.
We have , , and for all holds (this follows by Lemma 6.8 in [52] for unsatisfiable clausesets, which extends to satisfiable clausesets by definition). What is the relation between asymmetric width and the wellknown (for unsatisfiable ) symmetric width ? By definition we have for all . Now consider , where is the set of all Horn clausesets, defined by the condition that each clause contains at most one positive literal. The symmetric width here is unbounded, and is equal to the maximal clauselength of in case is minimally unsatisfiable. But we have here. So for unbounded clauselength there is an essential difference between symmetric and asymmetric width. On the other hand we have
for , , by Lemma 8.5 in [51], or, more generally, Lemma 6.22 in [52] (also shown in [54]). So for bounded clauselength and considered asymptotically, symmetric and asymmetric width can be considered equivalent.
4 PHardness and
Complementary to “unitrefutation completeness”, there is the notion of “propagationcompleteness” as investigated in [67, 12], yielding the class . This was captured and generalised by a measure of “propagationhardness” along with the associated hierarchy, defined in [33, 37] as follows:
Definition 4.1
For and we define the (relative) propagationhardness (for short “phardness”) as the minimal such that for all partial assignments with we have , where applies all forced assignments, and can be defined by . Furthermore . For let (the class of propagationcomplete clausesets of level ).
Remarks:

We have .

For we have .

By definition (and composition of partial assignments) we have that all classes are stable under application of partial assignments.

We have iff for all the clauseset in case of has no forced literals.
Recall that a clauseset has no forced assignments (at all) if and only if all prime implicates of have length at least .^{8)}^{8)}8)The “at all” is for the case , where every literal is forced for , but has no literals. Before proving the main lemma (Lemma 4.5), we need a simple characterisation of such clausesets without forced assignments. Recall that a partial assignment is an autarky for iff for all with holds ; for an autarky for the (sub)clauseset is satisfiable iff is satisfiable. See [50] for the general theory of autarkies.
Lemma 4.2
A clauseset has no forced assignments if and only if is satisfiable, and for every there is an autarky for with .
Proof: If has no forced assignment, then can not be unsatisfiable (since then every literal would be forced), and for a literal the clauseset is satisfiable (since is not forced), thus has a satisfying assignment , and the composition (first assigning , then applying ) is an autarky for . Now let be satisfiable, and for each let there be an autarky for with . If had a forced literal , then consider an autarky for with : since is forced, is unsatisfiable, while by the autarky condition would be satisfiable.
In the rest of this section we show that having an “acyclic incidence graph” yields a sufficient criterion for for clausesets .
Definition 4.3
For a finite family of clausesets the incidence graph is the bipartite graph, where the two parts are given by and , while there is an edge between and if . We say that is acyclic if is acyclic (i.e., has no cycle as an (undirected) graph, or, equivalently, is a forest). A single clauseset is acyclic if is acyclic.
From the family of clausesets we can derive the hypergraph , whose hyperedges are the variablesets of the . Now is acyclic iff is “Bergeacyclic” (which just means that the bipartite incidence graph of is acyclic). The standard notion of a constraint satisfaction instance being acyclic, as defined in Subsection 2.4 in [30], is “acyclicity” of the corresponding “formula hypergraph” (as with , given by the variablesets of the constraints), which is a more general notion, however since there is no automatic conversion from (sets of) clausesets to CSP’s, there is no danger of confusion here.
Since the property of the incidence graph being acyclic only depends on the occurrences of variables, if is acyclic, then this is maintained by applying partial assignments and by adding new variables to each :
Lemma 4.4
Consider an acyclic family of clausesets.

For every family of partial assignments the family is acyclic.

Every family with and for all , , is acyclic.
We are ready to prove that an acyclic union of clausesets without forced assignments has itself no forced assignments. This is kind of folklore in the CSP literature (see e.g. [26, 27]), using that a clauseset has no forced assignments iff considered as a single constraint is generalised arcconsistent, but to be selfcontained we provide the proof. The idea is simple: any assignment to a (single) variable in some can be extended to a satisfying assignment of , which sets single variables in other , which can again be extended to satisfying assignments, and so on, and due to acyclicity never two variables are set in some . Perhaps best to see this basic idea at work for a chain of clausesets, where each has no forced assignments, and neighbouring clausesets share at most one variable (), while otherwise these clausesets are variabledisjoint: then no literal is forced for , since the assignment can only affect at most two neighbouring clausesets, for which that assignment can be extended to a satisfying assignment of them, due to them not having forced assignment (and must be the only common variable); now can be continued “left and right”, using that assigning at most one variable in some can not destroy satisfiability of .
Lemma 4.5
Consider an acyclic family of clausesets. If no has forced assignments, then also has no forced assignments.
Proof: We use the following simple property of acyclic graphs : if is a connected set of vertices and , then there is at most one vertex in adjacent to (since otherwise there would be a cycle in ).
Let and . Consider a literal , and we show that can be extended to an autarky for (the assertion then follows by Lemma 4.2); let with . Consider a maximal with the properties:

;

for it is connected in ;

there is a partial assignment with



.

fulfils these three properties (since has no forced assignments), and so there is such a maximal . If there is no adjacent to some variable in , then is an autarky for and we are done; so assume there is such an . According to the above remark, there is exactly one adjacent to , that is, . Since has no forced assignments, there is a partial assignment with , and . Now satisfies , and thus satisfies the three conditions, contradicting the maximality of .
Lemma 4.5 only depends on the boolean functions underlying the clausesets , and thus could be formulated more generally for boolean functions . We obtain a sufficient criterion for the union of unitpropagation complete clausesets to be itself unitpropagation complete:
Theorem 4.6
Consider and an acyclic family of clausesets. If for all we have , then also .
Proof: Let , and consider a partial assignment with for . We have to show that has no forced assignments. For all we have , and thus has no forced assignments (since ). So has no forced assignments by Lemma 4.5. Thus , whence has no forced assignments.
The conditions for being acyclic, which are relevant to us, are collected in the following lemma; they are in fact pure graphtheoretical statements on the acyclicity of bipartite graphs, but for concreteness we formulate them in terms of families of clausesets:
Lemma 4.7
Consider a family of clausesets, and let .

If there are , , with , then is not acyclic.

Assume that for all , , holds . If the “variableinteraction graph”, which has vertexset , while there is an edge between with if , is acyclic, then is acyclic.

If there is a variable , such that for , , holds , then is acyclic.
Proof: For Part 1 note that together with , , yield a cycle (of length ) in . For Part 2 assume has a cycle (which must be of even length ). The case is not possible, since different clausesets have at most one common variable, and thus . Leaving out the interconnecting variables in , we obtain a cycle of length in the variableinteraction graph. Finally for Part 3 it is obvious that can not have a cycle , since the length of needed to be at least , which is not possible, since the only possible vertex in it would be .
Corollary 4.8
Consider and a family of clausesets with for all . Then each of the following conditions implies :

Any two different clausesets have at most one variable in common, and the variableinteraction graph is acyclic.

There is a variable with for all , .
The following examples show that the conditions of Corollary 4.8 can not be improved in general:
Example 4.9
An example for three boolean functions without forced assignments, where each pair has exactly one variable in common, while the variableinteraction graph has a cycle, and the union is unsatisfiable, is . And if there are two variables in common, then also without a cycle we can obtain unsatisfiability, as shows. The latter family of two boolean functions yields also an example for a family of two clausesets where none of them has forced assignments, while the union has (is in fact unsatisfiable). Since a hypergraph with two hyperedges is “acyclic”, in the fundamental Lemma 4.5 we thus can not use any of the more general notions “//acyclicity” (see [23] for these four basic notions of “acyclic hypergraphs”).
5 Systems of XORconstraints
We now review the concepts of “XORconstraints” and their representations via CNFclausesets. In Subsection 5.1 we model XORconstraints via “XORclauses” (and “XORclausesets”), and we define their semantics. And in Subsection 5.2 we define “CNFrepresentations” of XORclausesets, and show in Lemma 5.2 that all XORclauses following from an XORclauses are obtained by summing up the XORclauses.
5.1 XORclausesets
As usual, an XORconstraint (also known as “parity constraint”) is a (boolean) constraint of the form for literals and , where is the addition in the 2element field . Note that is equivalent to , while and , and and . Two XORconstraints are equivalent, if they have exactly the same set of solutions. In this report we prefer a lightweight approach, and so we do not present a full framework for working with XORconstraints, but we use a representation by XORclauses. These are just ordinary clauses , but under a different interpretation, namely implicitly interpreting as the XORconstraints . And instead of systems of XORconstraints we just handle XORclausesets , which are sets of XORclauses, that is, ordinary clausesets with a different interpretation. So two XORclauses are equivalent iff
Comments
There are no comments yet.