On the Interplay of Cube Learning and Dependency Schemes in QCDCL Proof Systems
Abstract
Quantified Conflict Driven Clause Leaning (QCDCL) is one of the main approaches to solving Quantified Boolean Formulas (QBF). Cube-learning is employed in this approach to ensure that true formulas can be verified. Dependency Schemes help to detect spurious dependencies that are implied by the variable ordering in the quantifier prefix of QBFs but are not essential for constructing (counter)models. This detection can provably shorten refutations in specific proof systems, and is expected to speed up runs of QBF solvers.
The simplest underlying proof system [BeyersdorffBΓΆhm-LMCS2023], formalises the reasoning in the QCDCL approach on false formulas, when neither cube-learning nor dependency schemes is used. The work of [BΓΆhmPeitlBeyersdorff-AI2024] further incorporates cube-learning. The work of [ChoudhuryMahajan-JAR2024] incorporates a limited use of dependency schemes, but without cube-learning.
In this work, proof systems underlying the reasoning of QCDCL solvers which use cube learning, and which use dependency schemes at all stages, are formalised. Sufficient conditions for soundness and completeness are presented, and it is shown that using the standard and reflexive resolution path dependency schemes ( and ) to relax the decision order provably shortens refutations.
When the decisions are restricted to follow quantification order, but dependency schemes are used in propagation and learning, in conjunction with cube-learning, the resulting proof systems using the dependency schemes and are investigated in detail and their relative strengths are analysed.
Keywords and phrases:
QBF, CDCL, Resolution, Dependency schemesFunding:
Meena Mahajan: Supported in part by the J. C. Bose Fellowship of SERB, ANRF.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Proof complexityEditors:
C. Aiswarya, Ruta Mehta, and Subhajit RoySeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl β Leibniz-Zentrum fΓΌr Informatik
1 Introduction
Despite the NP-hardness of the satisfiability problem, in the last three decades SAT solvers have been phenomenally successful in solving instances of humongous size, and have become the go-to tool in many practical industrial applications (see e.g. [30, 22]). This success has spurred ambitious programs to develop solvers for computationally even more hard problems. In particular, the PSPACE-complete problem of determining the truth of Quantified Boolean Formulas QBFs has many more applications (see e.g. [27]), and over the last twenty years QBF solvers have rapidly approached the state of industrial applicability.
The paradigm that revolutionized SAT solving is Conflict Driven Clause Learning CDCL ([28]), and this is also one of the principal approaches (but not the only one) in QBF solving. The CDCL technique was lifted to QBFs in the form of QCDCL ([31], see also [18]; in [19], the term QDPLL is used), and implemented in state-of-the-art solvers DepQBF [20, 21] and Qute [23] with further augmentations to enhance performance.
For both SAT and QBF, solving techniques are intricately connected with proof systems. The runtime trace of a solver on a formula can be thought of as a proof of the final outcome (sat/unsat, true/false). Proof systems abstract out the reasoning employed in the solvers, and allow representing these traces-as-proofs as formal proofs. The CDCL paradigm in SAT solvers corresponds to resolution, a very well-studied proof system. There are multiple ways in which resolution can be lifted to QBFs, see [5] for an overview. As shown in [4], resolution proofs can be efficiently extracted from traces of CDCL-based SAT solvers. For QBFs, QCDCL traces yield proofs in the proof system long-distance Q-resolution - [31, 3]. However, the converse direction, going from resolution proofs to CDCL runs, famously shown for SAT in [25, 1], seemingly breaks down for QBF and QCDCL as currently implemented; the reasoning employed in basic QCDCL solvers was abstracted in [7, 15] as the proof systems and , and shown to be exponentially weaker than -.
The proof system is a refutational proof system; it was formulated in [7] to explain the reasoning of basic QCDCL-style algorithms on false QBFs. The proof system , defined in [15], incorporates cube-learning as well, and can thus certify both falsity and truth of QBFs. Intriguingly, it was shown in [15] that even for false QBFs, where cube-learning is not necessary for completeness, it can still significantly shorten refutations. Very recently, it was shown in [8] that even when short refutations are actually found, it may take an exponentially long time to find them. Many other variants (different policies for decision order, propagations, reductions) have been studied extensively in [14].
One heuristic that has been used in some QCDCL solvers is the use of dependency schemes. These schemes involve performing some basic analysis of the formula structure and identifying spurious dependencies amongst variables, dependencies that are implied by the quantification order of variables but are not necessary for constructing (counter)models; see for instance [29]. Eliminating such dependencies would transform a QBF to a Dependency QBF, DQBF, for which the computational problem of deciding truth/falsity is even harder; it is NEXP-complete ([2, 12]). However, retaining the formulas as a QBF, and using information about spurious dependencies while propagating and learning, is still a feasible approach, that has been implemented in the solver DepQBF [20, 21] using the standard dependency scheme . In resolution-based QBF proof systems, employing reduction rules based on the reflexive resolution path dependency-scheme , is known to exponentially shorten refutations ([10]), and the expectation is that a similar advantage also manifests in QCDCL solvers.
This work makes progress towards formally understanding the strengths/limitations of using the dependency-scheme heuristic. The first steps in this direction were initiated in a recent work in [16]. It considered the simplest setting, in which the proof system uses the decision policy (deciding variables according to the quantification order), and does not learn cubes. A dependency scheme is used in propagation by, and learning of, clauses. Additionally, a dependency scheme may be used to preprocess the formula, reducing all clauses according to before beginning the QCDCL trails. In this setting, when and are βnormalβ schemes (as defined in [24]), the resulting proof systems were shown to be sound and refutationally complete. In the same setting, the four systems arising from using in preprocessing, in propagation/learning, in both, and in neither, were shown to be incomparable with each other. In the underlying proof system -, using dependency information can never lengthen proofs. The handicap in QCDCL arises because QCDCL algorithms also need to search for the proof.
In this work, we consider more general settings. Our contributions are as follows:
Formalising intensive use of dependency schemes in QCDCL.
We formalise the definitions of and proof systems that use dependency schemes more intensively: in the decision policy, which determines which variables can be βdecidedβ at a particular stage, as well as in propagation and learning, with and without cube learning. Using a dependency scheme in the decision policy means that a variable can be decided if all variables on which it depends, according to , are already assigned; this is the policy . Using a dependency scheme in propagation and learning means that reductions enabled by are performed whenever possible. For two dependency schemes and (which may be the same) we consider proof systems that use in the decision policy and in propagation through and learning of clauses. We consider three scenarios with respect to cube-learning: (1) cube-learning is switched off completely; (2) cube propagation and learning is done without using any dependency schemes; or (3) cube propagation and learning use the scheme but disallow long-distance term-resolution. The reason for this difference between clause and cube learning is that long-distance term resolution is not (yet?) known to be sound if used in conjunction with dependency schemes. We show that for normal , , the resulting systems are sound and refutationally complete; Theorem 3.12.
Provable advantage of .
We show that other parameters remaining the same, using either or as is strictly better than using ; Theorem 3.13.
Using cube-learning, and dependency schemes only in propagation/learning.
When the decision policy is restricted to , we generalise the results from [16] to settings with cube-learning switched on, and also to settings where rather than is used. Specifically, we show that
-
1.
Using in pre-processing is useless; Proposition 4.2.
-
2.
Switching on cube learning provably adds power even in the presence of or ; Theorem 4.12.
-
3.
Adding in various non-trivial ways to results in proof systems that are not only pairwise incomparable, Theorem 4.14, but are also incomparable with both and ; Theorems 4.13 andΒ 4.15.
-
4.
Adding to is orthogonal to switching on cube learning; Theorem 4.16. In certain cases, adding to both and offers a provable advantage.
-
5.
Although strictly refines , in the context of and , adding these schemes gives rise to incomparable systems; Theorem 4.17. Thus, the policy can negate potential benefits of the strict refinement.
We use several known bounds on formulas from earlier works, and also show some new bounds for them. To obtain desired separations, we also introduce three carefully handcrafted new formulas. For easy reference, the known and new results (about previously defined and new formulas) are collated in Table 1 in Section 4. The known simulation order of the proof systems, incorporating prior known results as well as the new results proved here, are summarised in Figure 1, also in Section 4.
Organisation of the paper
In Section 2, we give some basic definitions and describe, in a high-level informal way, the background about known proof systems and dependency schemes. In Section 3, we define the new proof systems, show soundness and completeness, and show that the decision policy is strictly more powerful than . In Section 4, we briefly discuss preprocessing, we define three new QBF families and show various lower and upper bounds for their proof sizes, and we describe the simulation order among various systems. We conclude with some pointers for further directions of interest. Detailed definitions from prior work, as well as detailed proofs of many new results, appear in the full version of this paper [17].
2 Preliminaries
Basic Notation
We assume familiarity with basic concepts from logic and computational complexity: Boolean variables and literals, clauses and cubes/terms, conjunctive normal form (CNF), substitutions, etc. We follow notation from [7, 15]; see also [5]. Selected relevant items are included here.
A literal is a Boolean variable or its negation , and denotes the associated variable . For a set of clauses and a literal , we use shorthand to denote the set of clauses . The empty clause, denoted , is unsatisfiable; the empty cube, denoted , is always true. A clause (cube) is said to be tautological (contradictory) if for some variable it contains both and . The resolution rule can be applied to clauses and to cubes. The resolvent of clauses and is the clause denoted as or . The resolvent of cubes and is the cube , also denoted as or .
A Quantified Boolean Formula (QBF) in prenex conjunction normal form (PCNF) is a prefix with a list of variables, each quantified either existentially or universally, and a matrix, which is a set (conjunction) of clauses over these variables. That is, it has the form where is a propositional formula in CNF, and each is in . We denote by ( respectively) the set of all variables quantified existentially (resp. universally). A QBF is true if for each variable , there exists a (Skolem) function , depending only on variables with , such that substituting these in yields a tautology. Similarly, the formula is false if for each variable , there is a (Herbrand) function , depending only on variables with , such that substituting in yields an unsatisfiable formula.
Some QBF proof systems, and the Dependency Scheme heuristic
The propositional proof system Resolution certifies unsatisfiability of a propositional formula by adding clauses obtaining through resolution until the empty clause is added. This can be lifted to QBFs in many ways. One of the simplest ways is to use the resolution rule along with a universal reduction rule, that allows removing a universal literal or from a clause if it is not βblocked; that is, the clause has no existential literals quantified after in the prefix. This gives rise to the system -; its restriction where resolution is allowed only on existential pivots is the system -. The long-distance resolution rule generalises resolution by permitting seemingly useless universal tautological clauses under certain side-conditions, and gives rise to the system - that generalises -. Informally, in this system, a resolution on is permitted even if the resolvent ends up having and for some universal variable , provided is quantified to the right of . The presence of and together, often referred to as a merged literal , is to be interpreted not as a tautology but as a place-holder for a partial strategy for depending on the value of the pivot .
In direct analogy to - and - are the proof systems - and - for certifying truth. Here the resolution is performed on terms, or cubes, with universal pivots, and existential literals can be reduced from a term if not blocked by universal literals quantified after them. The goal is to derive the empty term. A key point of difference is at the start; since the QBF is in PCNF, there are no terms to begin with. The Axiom rule in these systems permits starting with any term that satisfies the matrix.
For formal definitions of these proof systems, see for instance, Figure 2 in [9] (for -,-, -), Figure 2, in [29] (for -).
The notion of blocking, used in the reduction rules, stems from the understanding that if variables are quantified differently with quantified after , then the value of in a (counter)model may non-trivially depend on . If there is no literal blocking , then the satisfaction of the clause (falsification of cube) should not rely on the unblocked universal (resp. existential) . The dependency scheme heuristic refines this further. If a syntactic examination of the clause-variable structure can reveal that does not really depend on , even though it is quantified later, then can be reduced even in the presence of . This can drive the process towards the empty clause/term faster. Dependency schemes do precisely this. They identify pairs where and are quantified differently and where can be safely assumed to be independent of . (Actually, they list pairs where may depend on ; the other pairs can be assumed to be independent.) The trivial dependency scheme associates with each QBF the dependency set . Other schemes can associate subsets of this set. The schemes relevant to this paper are the standard scheme (see Def 7 in [26] and Def 9 in [29]), and the reflexive resolution scheme (see Defs 3,4,6 in [29]). For every , .
When a dependency scheme is incorporated into any of the preceding proof systems, the reduction rule becomes more generally applicable, and the side-conditions concerning merged literals also become more permissive. This gives rise to the proof systems -, -, -, -. See, for instance, Figure 3 and Section 3.3 in [29] (for - and -reductions), and Figure 1 in [24] (for -). For a clause and a dependency scheme , we denote by the clause obtained by removing all unblocked universal literals from . Similarly, for a cube , denotes the cube obtained by removing all unblocked existential literals from .
An important subclass of dependency schemes are the so-called normal dependency schemes, which have the property of being βmonotoneβ and βsimpleβ. See Def. 7 in [24] for the precise definition. The dependency schemes , , are all normal. This class of schemes is of interest to us because it is known that for normal dependency schemes, - and - are sound and refutationally complete [24]. The system - is known to be sound and complete on true formulas for (in [29], soundness is shown for a stronger dependency scheme, , implying soundness for as well). However the soundness of - is not known for dependency schemes other than .
We say proof system simulates a proof system if some computable function transforms proofs in into proofs in with at most polynomial blow-up in proof size. If this function is also computable in polynomial time (in the given proof size), we say that -simulates . Two systems are said to be incomparable if neither simulates the other.
The proof systems with and without cube learning
The proof system for , as defined in [7], formalizes reasoning in QCDCL algorithms operating on false formulas without cube learning. These algorithms construct trails or partial assignments in a specific way β decide values of variables according to some policy, propagate values of existential variables that appear in clauses which become unit after restriction by the trail so far and by universal reduction (call such a clause the antecedent of the propagated literal) β trying to satisfy the matrix. If a conflict is reached, then the trail is inconsistent with any Skolem function. Conflict analysis is performed, and a new clause is learnt and added to the matrix. If the empty clause is learned, the formula is deemed false. The corresponding refutation in the proof system consists of the sequence of constructed trails, and for each trail the sequence of long-distance resolution steps performed in conflict analysis to learn a clause. The full definition can be found in [7] (Def. 3.5).
The above formulation of the system only considers trails that end in a conflict. Trails ending in a satisfying assignment are ignored. This is enough to ensure refutational completeness β the ability to prove all false QBFs false. However, from satisfying assignments, solvers can and do learn cubes (or terms), and this is necessary to prove true QBFs true. In [15] it was shown that even while refuting false QBFs, allowing cube learning from satisfying assignments can be advantageous. This led to the definition of the proof system , and in [15], it was shown to be strictly stronger than the standard system. The main idea in cube learning systems is to consider satisfying assignments also as conflicts, albeit of a different kind, and to learn cubes from these conflicts. (The algorithm learns that such a trail is inconsistent with any Herbrand function.) Learnt cubes are added disjunctively to the matrix, which thus at intermediate stages is not necessarily in CNF but is the disjunction of a CNF formula and some cubes. With the augmented CNF matrices, cubes that become unit after existential reduction can now propagate universal variables in a way that falsifies the cube. Also, with the augmented CNF matrices, a trail may end up satisfying a cube rather than the CNF; this too is now a conflict, and conflict analysis involving term-resolution can be performed to learn a new cube. For formal details, see Section 3 in [15].
3 Adding dependency schemes to the proof system
The work done in [16] was the first to formalise the addition of dependency schemes to the proof system. It was done only for the setting where trails follow level-ordered decisions, and there is no cube learning. Here we relax both these restrictions; we allow dependency schemes to affect the decision policy of the trail, and we allow cube-learning.
Dependency schemes can be used in QCDCL algorithms in many ways:
(1) in specifying the decision order, (2) in specifying how reduction, propagation, and learning of clauses are performed, and (3) in specifying how these are performed for cubes, if at all. We set up unified notation to describe all such QCDCL-based proof systems.
Definition 3.1 ().
For a dependency scheme , the decision policy permits a decision on a variable at some point in a trail if all variables on which depends according to (i.e. ), have already been assigned.
The specific case of is the policy where decisions must respect quantification level order; is the policy where decisions are unrestricted.
Definition 3.2.
is the proof system where
-
1.
denotes the decision policy; e.g. , , .
In , denotes the dependency scheme, such as , . -
2.
is the dependency scheme used in reduction, propagation, and learning for clauses. Note that this scheme need not be the same as the in .
-
3.
denotes the type of usage of cube learning;
-
(a)
-: No cube learning.
-
(b)
-: Cube Learning used, but no dependency scheme (only ) in cube propagation, and cube learning using -.
-
(c)
-: Cube Learning used, dependency scheme used in propagation, and cube learning is done using -.
-
(a)
Note that in this notation, clause learning always uses -, where might well be . However, for cube learning, the propagation and learning can use either long-distance term resolution -, or dependency schemes without long-distance -, not both. We impose this condition because the soundness of - is not known.
In the notation of Definition 3.2, the standard vanilla system denoted in [7] would be , whereas the system from [15] would be . Further, the dependency-based system introduced in [16] would be .
To define what a derivation in these systems looks like, we first define trails and the learnable clauses and cubes from trails in this system. The following definitions are the natural generalisations of the corresponding ones from [7, 15]. We give a short illustration in Example 3.6 after Definition 3.5.
The trail is a sequence of literals (or , )
where the literals (in boldface) are decision literals, the literals are propagated literals. and no opposing literals appear. We can also view it as a set of literals or an assignment, and the corresponding clause (cube) is the disjunction (conjunction) of all literals in it.
The learnable constraints from a trail are defined as follows:
Definition 3.3 (learning from conflict).
From a trail
ending in a conflict , the set of learnable constraints has a clause associated with each propagated literal propagated in the trail if , and a cube associated with each propagated literal in the trail if . These associated clauses/cubes are constructed by tracing the conflict backwards through the trail as follows. ( denotes the clause/cube that causes literal to be propagated; i.e. the antecedent.) Starting with (respectively ), we resolve in reverse over the antecedent clauses (cubes) that propagated the existential (universal) variables as described below. All such resulting clauses (cubes) are learnable constraints.
In particular, if , then
-
.
-
For and , if and , then is the clause obtained by resolving the clause with the clause obtained from the antecedent of after reduction; such a resolution is possible on pivot . Otherwise, is simply the same as . Thus, equals
if and , and is otherwise. -
The learning process skips decision variables, so is defined using and . For . equals if and , and is otherwise.
If , then non-trivial cube-resolution is performed when is universal, not existential. The set depends on . If , then is replaced by . If , then is replaced by , but the step is performed only if it is a valid - resolution step; otherwise we use the previously learnt cube, just as we do in clause learning when the resolution on is not defined.
Definition 3.4 (learning from satisfaction).
From a trail that assigns all variables, satisfies all clauses, and does not satisfy any cube, the set of learnable constraints is defined as follows: For any set of literals, let denote the cube that is the conjunction of all literals in . Viewing the trail as a set of literals,
Definition 3.5.
For a specific choice of , , , let be the proof system . A -derivation from a PCNF QBF of a clause or cube is a sequence of triples, , where each is a trail, each is a clause/cube, and . The objects are as defined below.
For each , is a propositional formula of the form where is a set of clauses and is a set of cubes. These formulas are defined iteratively; initially we have all the clauses of and no terms, and after each trail either a clause or a term is learnt and added. Formally,
For each , is the QBF with the same quantifier prefix as , and inner formula . For each , is a trail from the formula , is a learnable clause or cube from , and is the derivation of from in the system as per or .
A refutation in these systems is a derivation of the empty clause , and a verification in this system is a derivation of the empty term .
Example 3.6.
The formulas, defined in [16](Section 4.5), have the prefix
and the matrix
Here refers to the propositional Pigeon-hole-principle formulas that assert the existence of a map from pigeons to holes without collision; these formulas are known to be exponentially hard for resolution. Due to , the matrix is unsatisfiable, and thus cube-learning makes no difference. So we consider -.
Consider refutations using , with or . For these formulas, it can be seen that and . The variables are completely independent from the variables; neither nor is in for any . Therefore using the decision policy, we can decide or in the beginning. Consider the trail that decides to assign to false and then to true. The clause becomes unit, so is propagated. Then the clause becomes empty, and the empty clause is propagated, leading to conflict. That is, in , we have , and . In conflict analysis, we first resolve (the reduced version of) with to obtain .
If is used in learning, then this can be reduced further to , which is learnt, i.e. included in and . The next trail then begins with the propagaed literal , and propagates further; , and , , , allowing us to learn . This is a refutation in or , but not in .
If or is used in learning, then from trail the clause is learnt (i.e. included in and ) since it cannot be further reduced. The next trail must again begin with a decision. With , , , , allowing us to learn . This is a refutation in , where could be or but not , and could be or .
By definition, generalises , and generalises . Thus,
Observation 3.7.
For a , and dependency schemes , ,
-
Every derivation in is a derivation in .
-
Every derivation in is a derivation in .
Trails in a system without cube learning are also trails in the corresponding system with cube learning. Hence:
Observation 3.8.
For , and for any decision policy , any derivation in is also a derivation in .
If the matrix of the given PCNF formula is unsatisfiable, then no satisfying trail can ever be constructed, no matter what policy is used, so no βcube learningβ can happen. Hence:
Observation 3.9.
For , and for any decision policy , if a PCNF formula has an unsatisfiable matrix, then any derivation from in the system is also a derivation in .
The following result is shown in [16].
Proposition 3.10 (Theorem 1 in [16]).
For any normal dependency scheme , the system is refutationally complete.
A minor adaptation of the proof of Theorem 3.9 in [7] shows the following soundness:
Theorem 3.11.
For any normal dependency scheme , the proof systems
and are sound.
Proof.
To show that both these systems are sound, it is enough to show the following three statements: (1) The derivation of any learnt clause is a valid - derivation. (2) If , the derivation of any learnt cube is a valid - derivation, and the addition of cubes when learning from satisfaction is sound. (3) If , the derivation of any learnt cube is a valid - derivation. From these three it follows that sticking together the derivations of the final learnt empty clause/term gives a proof in the corresponding system, and all these systems are known to be sound.
Statement (3) is true by definition: term resolution in learning is performed only if it is valid in -. For Statement (2), cube learning is shown to be sound in [15, Theorem 3.8]. For statement (1), we need to show that the resolution steps performed while learning respect the side-conditions of . The analogous statement when is proved in [7, Lemma 3.7, Proposition 3.8, Theorem 3.9], but the same proof works with any . For details, see the full version [17].
From Proposition 3.10, Theorem 3.11, Λ3.7 and Λ3.8, we conclude that all the aforementioned systems are sound and refutationally complete.
Theorem 3.12.
For any dependency schemes , where is normal, and for each , the proof system is sound and refutationally complete.
In based proof systems, incorporating dependency schemes into propagation and learning processes does not always yield benefits: as shown in [16], certain pathological formulas can render the addition of dependency schemes disadvantageous when decisions are constrained to the decision policy.
If the dependency shceme is allowed to influence the decision order (i.e., the system adopts the decision policy), we show below that the resulting systems are strictly more powerful than their counterparts using . (For , an advantage over was noted already in [19]. ) However, they remain strictly weaker than the - systems. (For the proofs, see the full version [17].)
Theorem 3.13.
For dependency schemes and , and for policy , the proof system -simulates and is not simulated by it.
Theorem 3.14.
For in , the proof system - -simulates and is not simulated by it.
4 Dependency-schemes-based QCDCL systems restricted to
We now restrict our attention to proof systems utilizing only the decision policy. Even with , dependency schemes can affect (enhance or impair) the performance of systems. These are the systems also considered in [7, 15, 16].
In [16], another way of incorporating dependency schemes was also considered, through βpreprocessingβ. For a more complete comparison, we very briefly define such systems here as well. Preprocessing a formula using a dependency scheme simply means applying all reductions enabled by it on the input formula, and then proceeding with whatever version of is of interest, on the reduced formula.
Definition 4.1.
For a QBF and a normal dependency scheme , a derivation of a clause from in is a derivation of from the QBF in .
As shown in Theorem 4 of [16], preprocessing using can significantly alter the system strength. In contrast, we observe below that preprocessing using schemes or has no effect, no matter what version of is the subsequent system.
Proposition 4.2.
For every decision policy , dependency scheme and for , the proof systems , , and are equivalent to each other.
We now introduce some new formulas which will be used to pinpoint the relative strengths of the proof systems.
The formulas
The formulas, first defined in [6], show that the proof system with cube learning is stronger than without [15]. We wish to show that cube-learning offers a similar advantage for systems with . The formulas cannot show this because ; so using in any way makes them easy to refute irrespective of cube-learning. To achieve the desired separation, we modify the formula by adding two clauses that make and identical. These new formulas, called , maintain the separation without altering the hardness of .
Formula 1.
The formula has the prefix
and the PCNF matrix
(Note: deleting the clauses and gives the formulas.)
Proposition 4.3.
For , , and .
This makes the usage of the dependency schemes or completely useless. We now show that the formulas are easy to refute with cube-learning, but hard if cube-learning is switched off. Both these results closely mirror the corresponding results for shown in [7] and [15] respectively.
Lemma 4.4.
For and , the formulas have polynomial size refutations in .
Lemma 4.5.
For the formulas require exponential size refutations in .
Proof (Sketch).
By the discussion above, it suffices to show that the formulas require exponential size refutations in .
In [13], the authors consider formulas with a specific structure, called -formulas with the -property. They introduce a semantic measure called gauge for QBFs, and show that for an -formula with the -property, the size of a refutation in is at least exponential in its gauge.
The formulas are easily seen to be -formulas with the -property. We show that they have linear gauge, implying that they are exponentially hard.
The formulas
The next formula is designed to explore how adding in different ways affects the system. It sends trails into a βtrapβ (of refuting the hard existential Pigeonhole Principle ; see Example 3.6) if is not used in propagation, but allows a short refutation (a contradiction on two variables) when is used. This leads to the definition of a formula inspired by the and formulas from [7](Def. 4.5) and [16](Def. 4.4) respectively.
Formula 2.
The formula has the prefix
, and the matrix is as given below.
This formula has an unsatisfiable matrix (due to the presence of ).
The variable ββ is not necessary for the lower or upper bounds proved for this formula. Initialising or removing the variable ββ entirely affects neither the bounds nor their proofs. However we keep it in because the formulas are defined to extend the formula (defined in [7]) which has the ββ variable. Also, it shows that even if the preprocessing step (by ) is non-trivial and changes the formula, addition of in propagation can still make a difference.
Proposition 4.6.
.
Hence = . That is, if we preprocess using , everything stays the same except that the variable βdisappearsβ.
However, just preprocessing by is not enough to make this formula easy to refute. The following lemmas shows that the presence of during propagation is crucial to achieving polynomial sized refutations; its absence forces exponential size.
Lemma 4.7.
For the formulas have polynomial size refutations in
Proof (Sketch).
By Λ3.8, it suffices to show polynomial size refutations in . Any trail must start with a decision on . With in propagation, the contradiction on on and is reached. Thus in 4 such trails the empty clause can be learnt, completing the refutation.
Lemma 4.8.
For the formulas require exponential size refutations in
Proof (Sketch).
Since the formulas have an unsatisfiable matrix, therefore, by Λ3.9 it suffices to show hardness in .
Any trail starts with a decision on , propagating , and then subsequently the trail falls into the trap of refuting and hence the formulas; the hardness follows.
The formulas
The third new formula we introduce shows the advantage of using in propagation and learning. The goal is to create clauses that can be learnt easily with , but are hard to learn without it. These learned clauses enable a quick refutation in with , but without them, one is stuck refuting something hard.
Formula 3.
The formula has the prefix
, and the matrix is as given below.
The variables are essentially βseparatorsβ, putting existential variables into different levels. The variables are blockers, ensuring that the separators do not get reduced too early in the trail.
Proposition 4.9.
.
When is used in propagation, we show that these formulas have short refutations.
Lemma 4.10.
For the formulas have polynomial size refutations in
Proof (Sketch).
By Λ3.8, it suffices to show short refutations in the system . Consider the trail with learnable sequence We choose to learn . We construct next the trail with learnable sequence . Thus the empty clause is learnt.
However, without , the propagations force refuting the clauses, which is hard.
Lemma 4.11.
For the formulas require exponential size refutations in
Proof (Sketch).
We first show that the the formulas require exponential size without cube learning i.e. in and then extend the argument for the case of and
Every trail must start with a decision on , until a literal on is learnt; thenceforth a trail must begin by propagating that literal. Any trail starting with reaches a conflict in the clauses, so subsequently exponential size is required. It can be shown that no satisfying trail is ever constructed, so cube-learning offers no advantage.
Strength Relations between the Proof Systems
The hardness of formulas in systems with or without cube-learning and dependency schemes are collected in Table 1, including known bounds as well as those established above.
β with β includes where , as well as .
β with β includes as well as ,
where and .
| Formula | Matrix | Dependencies | Weakest System where Easy | Strongest System where Hard | |||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ([6]-Def. 3.1) | Sat |
|
|
|
|||||||||
| ([15]-Def 6.1) | Sat |
|
|
|
|||||||||
| ([7]-Def 4.5) | Unsat |
|
|
|
|||||||||
| ([16]-Sec 4.4) | Unsat |
|
|
|
|||||||||
| ([16]-Sec 4.5) | Unsat | [16] |
|
|
|||||||||
| ([16]-Sec 4.7) |
|
[16] |
|
|
|||||||||
| ([16]-Sec 4.8) | Unsat | [16] |
|
|
|||||||||
| * | Sat | (Proposition 4.3) |
|
|
|||||||||
| * | Unsat |
|
|
|
|||||||||
| * | Sat |
|
|
|
Using these bounds, we now establish various relations between the newly introduced -based proof systems and also between them and other -based proof systems. Figure 1 summarises these and earlier known relations in a visually clear way.
From Theorems 4.13 andΒ 4.14.
From Theorems 4.12 andΒ 4.15.
From Theorems 4.12 andΒ 4.16.
means simulates but does not simulate .
means neither nor simulates the other.
As we have discussed, cube-learning in proof systems is the concept of allowing βtermsβ to be learnt from satisfying trails, and intuitively more (optional) learning power would mean a more powerful proof system. The first theorem validates this claim . It states that for any proof system with dependency schemes, adding cube-learning yields a more powerful system than the corresponding system without it.
Theorem 4.12.
For and the proof system is strictly stronger than
For the next three theorems we focus specifically on . The first of these shows that irrespective of the manner in which is used in a proof system, the resulting system is provably incomparable in strength to the system that does not use dependency schemes. This was already known for the setting without cube-learning, Theorem 5 in [16]. We show here that cube learning makes no difference; the systems still remain incomparable. This highlights the fact that adding dependency schemes is not always beneficial.
Theorem 4.13.
Any proof systems are incomparable, where
The next theorem shows that adding in different ways to yields systems incomparable in strength. (Again, this was already known for the setting without cube-learning, Theorem 4 in [16].) This highlights that adding dependency schemes in any one of preprocessing or propagation and learning is not inherently better than the other.
Theorem 4.14.
For a fixed , the three systems
, , and
are pairwise incomparable.
Earlier, we have seen that adding cube-learning to a system with dependency always yields a stronger system, Theorem 4.12. The following theorem shows that even adding cube-learning to a system using is incomparable to a system without cube-learning but using in a different way.
Theorem 4.15.
For any , adding to the proof system in one way and to in any different way yields incomparable proof systems. In particular,
-
1.
is incomparable with and .
-
2.
is incomparable with and .
-
3.
incomparable with and .
Now we come to . First, we show that, as for , a system with is incomparable in strength to a standard system without any dependency schemes.
Theorem 4.16.
For , the proof systems
and are incomparable.
Finally, we compare the dependency schemes and . The mere fact that is a refinement of (more general, eliminates more dependencies) does not make it better; for that matter, is a refinement of , but we have seen that using it can be a disadvantage for some formulas. Similarly, we prove below that neither of and has a proof-theoretic advantage over the other, irrespective of the presence or absence of cube-learning.
Theorem 4.17.
For any ,
and , the proof systems
and are incomparable.
5 Conclusions
In the context of QBF proof systems, dependency schemes are expected to aid the process of refutation, as indeed they do for - and -. It was thus a surprise to see this advantage does not automatically translate to QCDCL algorithms (even in the presence of cube learning) if they make only level-ordered decisions. However, we lack proper lower bound techniques for a non-trivial decision policy . Even for the level-ordered policy, there are many unresolved questions. The comparison between and already shows that using a more refined scheme is not necessarily an advantage. The relative strengths of and (which refines ) is not yet clear. How other dependency schemes would relate in this scenario is completely unexplored.
Since QCDCL-style reasoning is explained through long-distance clause/term resolution, it is worth highlighting three long-standing open questions about those systems. (1) Does using dependency schemes confer any advantage with clausal long-distance; i.e. is the simulation of - by - strict for or ? (2) Is the use of dependency schemes in long-distance term resolution (the system -) sound? (3) Can we even show that - is strictly more powerful than -? This question has remained open since was first implemented in DepQBF over 15 years ago.
References
- [1] Albert Atserias, Johannes Klaus Fichte, and Marc Thurley. Clause-learning algorithms with many restarts and bounded-width resolution. J. Artif. Intell. Res., 40:353β373, 2011. doi:10.1613/jair.3152.
- [2] Salman Azhar, Gary Peterson, and John Reif. Lower bounds for multiplayer non-cooperative games of incomplete information. Journal of Computers and Mathematics with Applications, 41:957β992, 2001.
- [3] Valeriy Balabanov and Jie-Hong R. Jiang. Unified QBF certification and its applications. Formal Methods Syst. Des., 41(1):45β65, 2012. doi:10.1007/s10703-012-0152-6.
- [4] Paul Beame, Henry A. Kautz, and Ashish Sabharwal. Towards understanding and harnessing the potential of clause learning. J. Artif. Intell. Res. (JAIR), 22:319β351, 2004. doi:10.1613/jair.1410.
- [5] Olaf Beyersdorff. Proof complexity of quantified Boolean logic β a survey. In Marco Benini, Olaf Beyersdorff, Michael Rathjen, and Peter Schuster, editors, Mathematics for Computation (M4C), pages 353β391. World Scientific, 2022.
- [6] Olaf Beyersdorff, Joshua Blinkhorn, and Luke Hinde. Size, cost, and capacity: A semantic technique for hard random QBFs. Log. Methods Comput. Sci., 15(1), 2019. doi:10.23638/LMCS-15(1:13)2019.
- [7] Olaf Beyersdorff and Benjamin BΓΆhm. Understanding the relative strength of QBF CDCL solvers and QBF resolution. Logical Methods in Computer Science, 19(2), 2023. preliminary version in ITCS 2021. doi:10.46298/lmcs-19(2:2)2023.
- [8] Olaf Beyersdorff, Benjamin BΓΆhm, and Meena Mahajan. Runtime vs. extracted proof size: an exponential gap for CDCL on QBFs. In Proceedings of 38th AAAI Conference on Artificial Intelligence, 2024, 2024.
- [9] Olaf Beyersdorff, Leroy Chew, and MikolΓ‘s Janota. New resolution-based QBF calculi and their proof complexity. ACM Trans. Comput. Theory, 11(4):26:1β26:42, 2019. doi:10.1145/3352155.
- [10] Joshua Blinkhorn and Olaf Beyersdorff. Shortening QBF proofs with dependency schemes. In Serge Gaspers and Toby Walsh, editors, Theory and Applications of Satisfiability Testing - SAT 2017 - 20th International Conference, Melbourne, VIC, Australia, August 28 - September 1, 2017, Proceedings, volume 10491 of Lecture Notes in Computer Science, pages 263β280. Springer, 2017. doi:10.1007/978-3-319-66263-3_17.
- [11] Joshua Blinkhorn and Olaf Beyersdorff. Dynamic dependency awareness for QBF. In JΓ©rΓ΄me Lang, editor, Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI 2018, July 13-19, 2018, Stockholm, Sweden, pages 5224β5228. ijcai.org, 2018. doi:10.24963/ijcai.2018/726.
- [12] Joshua Blinkhorn, TomΓ‘s Peitl, and Friedrich Slivovsky. Davis and Putnam meet Henkin: Solving DQBF with resolution. In Chu-Min Li and Felip ManyΓ , editors, Theory and Applications of Satisfiability Testing - SAT 2021 - 24th International Conference, Barcelona, Spain, July 5-9, 2021, Proceedings, volume 12831 of Lecture Notes in Computer Science, pages 30β46. Springer, 2021. doi:10.1007/978-3-030-80223-3_4.
- [13] Benjamin BΓΆhm and Olaf Beyersdorff. Lower bounds for QCDCL via formula gauge. J. Autom. Reason., 67(4):35, 2023. preliminary version in SAT 2021. doi:10.1007/s10817-023-09683-1.
- [14] Benjamin BΓΆhm and Olaf Beyersdorff. QCDCL vs QBF resolution: Further insights. J. Artif. Intell. Res., 81:741β769, 2024. preliminary version in SAT 2023. doi:10.1613/jair.1.15522.
- [15] Benjamin BΓΆhm, TomΓ‘s Peitl, and Olaf Beyersdorff. QCDCL with cube learning or pure literal elimination - what is best? Artif. Intell., 336:104194, 2024. preliminary version on IJCAI 2022. doi:10.1016/j.artint.2024.104194.
- [16] Abhimanyu Choudhury and Meena Mahajan. Dependency schemes in CDCL-based QBF solving: A proof-theoretic study. J. Autom. Reason., 68(3):16, 2024. preliminary version in FSTTCS 2023. doi:10.1007/s10817-024-09707-4.
- [17] Abhimanyu Choudhury and Meena Mahajan. On the interplay of cube learning and dependency schemes in QCDCL proof systems, 2025. doi:10.48550/arXiv.2510.05876.
- [18] Enrico Giunchiglia, Paolo Marin, and Massimo Narizzano. Reasoning with quantified boolean formulas. In Armin Biere, Marijn Heule, Hans van Maaren, and Toby Walsh, editors, Handbook of Satisfiability, volume 185 of Frontiers in Artificial Intelligence and Applications, pages 761β780. IOS Press, 2009. doi:10.3233/978-1-58603-929-5-761.
- [19] Florian Lonsing. Dependency schemes and search-based QBF solving: theory and practice. PhD thesis, Johannes Kepler University, Linz, Austria, 2012.
- [20] Florian Lonsing and Armin Biere. DepQBF: A dependency-aware QBF solver. J. Satisf. Boolean Model. Comput., 7(2-3):71β76, 2010. doi:10.3233/sat190077.
- [21] Florian Lonsing and Uwe Egly. DepQBF 6.0: A search-based QBF solver beyond traditional QCDCL. In Proceedings of International Conference on Automated Deduction (CADE), pages 371β384, 2017. doi:10.1007/978-3-319-63046-5_23.
- [22] JoΓ£o P. Marques Silva, InΓͺs Lynce, and Sharad Malik. Conflict-driven clause learning SAT solvers. In Armin Biere, Marijn Heule, Hans van Maaren, and Toby Walsh, editors, Handbook of Satisfiability, Frontiers in Artificial Intelligence and Applications. IOS Press, 2021. doi:10.3233/FAIA200987.
- [23] TomΓ‘s Peitl, Friedrich Slivovsky, and Stefan Szeider. Dependency learning for QBF. J. Artif. Intell. Res., 65:180β208, 2019. doi:10.1613/jair.1.11529.
- [24] TomΓ‘s Peitl, Friedrich Slivovsky, and Stefan Szeider. Long-distance Q-resolution with dependency schemes. J. Autom. Reasoning, 63(1):127β155, 2019. doi:10.1007/s10817-018-9467-3.
- [25] Knot Pipatsrisawat and Adnan Darwiche. On the power of clause-learning SAT solvers as resolution engines. Artif. Intell., 175(2):512β525, 2011. doi:10.1016/j.artint.2010.10.002.
- [26] Marko Samer and Stefan Szeider. Backdoor sets of quantified boolean formulas. J. Autom. Reasoning, 42(1):77β97, 2009. doi:10.1007/s10817-008-9114-5.
- [27] Ankit Shukla, Armin Biere, Luca Pulina, and Martina Seidl. A survey on applications of quantified Boolean formulas. In Proc. IEEE International Conference on Tools with Artificial Intelligence (ICTAI), pages 78β84, 2019. doi:10.1109/ICTAI.2019.00020.
- [28] JoΓ£o P. Marques Silva and Karem A. Sakallah. GRASP - a new search algorithm for satisfiability. In Rob A. Rutenbar and Ralph H. J. M. Otten, editors, Proceedings of the 1996 IEEE/ACM International Conference on Computer-Aided Design, ICCAD 1996, San Jose, CA, USA, November 10-14, 1996, pages 220β227. IEEE Computer Society / ACM, 1996. doi:10.1109/ICCAD.1996.569607.
- [29] Friedrich Slivovsky and Stefan Szeider. Soundness of Q-resolution with dependency schemes. Theor. Comput. Sci., 612:83β101, 2016. doi:10.1016/j.tcs.2015.10.020.
- [30] Moshe Y. Vardi. Boolean satisfiability: theory and engineering. Communications of the ACM, 57(3):5, 2014. doi:10.1145/2578043.
- [31] Lintao Zhang and Sharad Malik. Conflict driven learning in a quantified boolean satisfiability solver. In Lawrence T. Pileggi and Andreas Kuehlmann, editors, Proceedings of the 2002 IEEE/ACM International Conference on Computer-aided Design, ICCAD 2002, San Jose, California, USA, November 10-14, 2002, pages 442β449. ACM / IEEE Computer Society, 2002. doi:10.1145/774572.774637.
