QRATPre+: Effective QBF Preprocessing via Strong Redundancy Properties

TL;DR

QRATPre+ is a new QBF preprocessor that uses advanced redundancy properties to simplify formulas, improving the effectiveness of QBF solving tools.

Contribution

It introduces the first implementation of QRAT and QRAT+ redundancy properties in a preprocessor, enhancing QBF preprocessing capabilities.

Findings

QRATPre+ outperforms existing preprocessors in experiments.

It effectively reduces QBF formula complexity.

The tool integrates easily with other QBF solvers.

Abstract

We present version 2.0 of QRATPre+, a preprocessor for quantified Boolean formulas (QBFs) based on the QRAT proof system and its generalization QRAT+. These systems rely on strong redundancy properties of clauses and universal literals. QRATPre+ is the first implementation of these redundancy properties in QRAT and QRAT+ used to simplify QBFs in preprocessing. It is written in C and features an API for easy integration in other QBF tools. We present implementation details and report on experimental results demonstrating that QRATPre+ improves upon the power of state-of-the-art preprocessors and solvers.

Figures

Tables

Table 1. Table 1: Effect of preprocessing.

	Q	B	H	QB	BQ	QH	HQ
#cl	79	78	23	70	69	18	17
#qb	92	22	17	21	22	59	17
#$\exists$l	82	85	27	80	77	20	21
#$\forall$l	73	95	74	82	86	44	53

Table 2. Table 2: QBFEVAL’18: solved instances ( S ), unsatisfiable ( ⊥ bottom \bot ), satisfiable ( ⊤ top \top ), and uniquely solved ones ( U ), and total CPU time in kiloseconds (K) including time outs.

Solver	S	$\perp$	$\top$	U	Time
CAQE	151	107	44	11	586K
DepQBF	149	87	62	50	592K
RAReQS	147	115	32	4	588K
Ijtihad	132	111	21	2	609K
Qute	98	79	19	6	665K

Table 3. (a) Original instances.

Solver	S	$\perp$	$\top$	U	Time
CAQE	151	107	44	11	586K
DepQBF	149	87	62	50	592K
RAReQS	147	115	32	4	588K
Ijtihad	132	111	21	2	609K
Qute	98	79	19	6	665K

Table 4. (b) QRATPre + only (Q).

Solver	S	$\perp$	$\top$	U	Time
CAQE	211	135	76	29	487K
RAReQS	178	120	58	9	533K
DepQBF	165	83	82	33	562K
Ijtihad	156	111	45	1	562K
Qute	137	92	45	9	598K

Table 5. (c) Bloqqer only (B).

Solver	S	$\perp$	$\top$	U	Time
CAQE	269	150	119	24	383K
RAReQS	258	159	99	7	399K
Ijtihad	200	128	72	4	482K
DepQBF	198	99	99	21	501K
Qute	189	114	75	2	512K

Table 6. (d) QRATPre + and Bloqqer (QB).

Solver	S	$\perp$	$\top$	U	Time
CAQE	290	169	121	37	347K
RAReQS	260	163	97	5	390K
Ijtihad	216	140	76	2	456K
DepQBF	210	107	103	21	481K
Qute	197	119	78	2	493K

Table 7. (e) HQSpre only (H).

Solver	S	$\perp$	$\top$	U	Time
CAQE	322	183	139	21	290K
RAReQS	292	180	112	2	317K
DepQBF	270	160	110	20	364K
Qute	253	161	92	3	390K
Ijtihad	249	167	82	0	394K

Table 8. (f) HQSpre and QRATPre + (HQ).

Solver	S	$\perp$	$\top$	U	Time
CAQE	325	188	137	14	279K
RAReQS	303	189	114	3	304K
DepQBF	271	158	113	20	362K
Qute	263	170	93	2	377K
Ijtihad	245	166	79	0	407K

Table 9. Table 3: QBFEVAL’18: solved instances ( S ), unsatisfiable ( ⊥ bottom \bot ), satisfiable ( ⊤ top \top ), and uniquely solved ones ( U ), and total CPU time in kiloseconds (K) including time outs.

Solver	S	$\perp$	$\top$	U	Time
CAQE	284	165	119	35	358K
RAReQS	257	161	96	5	399K
DepQBF	204	102	102	17	490K
Ijtihad	197	127	70	3	490K
Qute	184	111	73	1	515K

Table 10. (a) Bloqqer and QRATPre + (BQ).

Solver	S	$\perp$	$\top$	U	Time
CAQE	284	165	119	35	358K
RAReQS	257	161	96	5	399K
DepQBF	204	102	102	17	490K
Ijtihad	197	127	70	3	490K
Qute	184	111	73	1	515K

Table 11. (b) QRATPre + and HQSpre (QH).

Solver	S	$\perp$	$\top$	U	Time
CAQE	308	183	125	16	303K
RAReQS	283	178	105	7	340K
DepQBF	251	149	102	23	398K
Qute	244	159	85	3	410K
Ijtihad	231	159	72	2	428K

Full text

1 Introduction

The application of preprocessing prior to the actual solving process is crucial for the performance of most of the quantified Boolean formula (QBF) solvers [17, 19, 20]. Preprocessors aim at decreasing the complexity of a given formula with respect to the number of variables, the number of clauses, or the number of quantifier blocks. Contrary to complete QBF solvers, preprocessors are incomplete but can detect redundant parts of the given formula by applying resource-restricted reasoning. Bloqqer [6] and HQSpre [25] are leading preprocessors which show their power in the yearly QBFEVAL competitions111http://www.qbflib.org/index_eval.php in potentially almost doubling the number of instances solved by certain state-of-the-art solvers. These tools apply a diverse set of redundancy elimination techniques.

We present QRATPre+ 2.0,222QRATPre+ is licensed under GPLv3: https://lonsing.github.io/qratpreplus/ a QBF preprocessor based on the $\mathsf{QRAT}^{+}$ proof system [18]. QRATPre+ processes QBFs in prenex conjunctive normal form (PCNF) and eliminates redundant clauses and universal literals. Redundancy checking relies on redundancy properties defined by the $\mathsf{QRAT}^{+}$ proof system, which is a generalization of the $\mathsf{QRAT}$ (quantified resolution asymmetric tautology) proof system [7, 9]. $\mathsf{QRAT}$ is a lifting of (D)RAT [11, 24] from the propositional to the QBF level, and it simulates virtually all simplification rules applied in state-of-the-art QBF preprocessors. This is made possible by strong redundancy properties.

However, the strong redundancy properties of $\mathsf{QRAT}$ have not been applied to preprocess QBFs so far. With QRATPre+ we close this gap and leverage the power of $\mathsf{QRAT}$ and $\mathsf{QRAT}^{+}$ for QBF preprocessing. Compared to the initially released version 1.0, version 2.0 comes with a more modularized code base and a C API that allows to easily integrate QRATPre+ in other tools. QRATPre+ currently applies only rewrite rules of the $\mathsf{QRAT}$ and $\mathsf{QRAT}^{+}$ proof systems that remove either clauses or universal literals from a PCNF. That is, it does not attempt to add redundant parts with the aim to potentially enable further simplifications later on. Despite this fact, experimental results with benchmarks from QBFEVAL’18 clearly indicate the effectiveness of QRATPre+. It improves on state-of-the-art preprocessors, such as Bloqqer and HQSpre, and solvers in terms of formula size reduction and solved instances, respectively.

2 $\mathsf{QRAT}^{+}$ Redundancy Checking for Preprocessing

QRATPre+ eliminates redundant clauses and universal literals within clauses from a QBF in PCNF. Redundancy checking in QRATPre+ relies on redundancy properties defined by the $\mathsf{QRAT}^{+}$ proof system. We present $\mathsf{QRAT}^{+}$ only informally and refer to related work instead [18].

Let $\phi:=\Pi.(\psi\wedge(C^{\prime}\cup\{l\}))$ be a PCNF with prefix $\Pi:=Q_{1}B_{1}\ldots Q_{i}B_{i}\ldots\linebreak\ldots Q_{n}B_{n}$, where $Q_{i}B_{i}$ are quantifier blocks (qblocks) consisting of a quantifier $Q_{i}\in\{\forall,\exists\}$ and a block (i.e., set) $B_{i}$ of variables. We write $Q(B_{1}\ldots B_{n})$ for $Q(B_{1}\cup\ldots\cup B_{n})$. Index $i$ is the nesting level of qblock $Q_{i}B_{i}$ and of the variables in $B_{i}$. Formula $\psi\wedge(C^{\prime}\cup\{l\})$ is in CNF, where $(C^{\prime}\cup\{l\})$ is a clause in $\phi$ containing literal $l$. We consider only PCNFs without tautological clauses of the form $(C\cup\{p\}\cup\{\bar{p}\})$ for some propositional variable $p$.

Given a clause $C:=(C^{\prime}\cup\{l\})$ in $\phi$, checking whether $C$ or the literal $l\in C$ is redundant requires to consider all clauses $D_{i}$ in the resolution neighborhood $\mathsf{RN}(C,l):=\{D_{i}\mid D_{i}\in\phi,\bar{l}\in D_{i}\}$ of $C$ with respect to $l$, cf. [11, 12, 13]. This is illustrated in Fig. 1. Given $C$ and some $D_{j}\in\mathsf{RN}(C,l)$, we first compute the outer resolvent $\mathsf{OR}_{j}\subset(C\cup D_{j})$ of $C$ and $D_{j}$ on literal $l$ [9]. Then we determine the maximum nesting level $i:=\mathit{max}(\mathit{levels}(\Pi,\mathsf{OR}_{j}))$ of variables appearing in $\mathsf{OR}_{j}$. Based on $i$ we construct the PCNF $\mathit{Abs}(\Pi.\psi,i):=\exists(B_{1}\ldots B_{i})Q_{i+1}B_{i+1}\ldots Q_{n}B_{n}.\psi$ by converting all universal quantifiers in the subprefix $Q_{1}B_{1}\ldots Q_{i}B_{i}$ to existential ones. The resulting PCNF $\mathit{Abs}(\Pi.\psi,i)$ is an abstraction of $\Pi.\psi$.

We add the negation $\overline{\mathsf{OR}_{j}}$ of the outer resolvent $\mathsf{OR}_{j}$, which is a set of unit clauses, to the abstraction $\mathit{Abs}(\Pi.\psi,i)$ to obtain the formula $\mathit{Abs}(\Pi.(\psi\wedge\overline{\mathsf{OR}_{j}}),i)$. Finally, we check whether a conflict, i.e., the empty clause $\emptyset$, is derived by applying QBF unit propagation (QBCP) [3, 5, 15, 26] to $\mathit{Abs}(\Pi.(\psi\wedge\overline{\mathsf{OR}_{j}}),i)$. If so, which we denote by $\mathit{Abs}(\Pi.(\psi\wedge\overline{\mathsf{OR}_{j}}),i)\mathrel{\vdash\kern-7.5pt_{{}^{{}_{1\forall}}}}\emptyset$, then the current outer resolvent $\mathsf{OR}_{j}$ has the quantified asymmetric tautology (QAT) [18] redundancy property.

If all possible outer resolvents of $C:=(C^{\prime}\cup\{l\})$ and clauses $D$ in the resolution neighborhood $\mathsf{RN}(C,l)$ of $C$ with respect to literal $l$ have the $\mathsf{QAT}$ property, then clause $C$ has the $\mathsf{QRAT}^{+}$ redundancy property on literal $l$. In this case, either $C$ or $l$ is redundant, depending on whether $l$ is existential or universal, respectively. Note that in general, for every outer resolvent $\mathsf{OR}_{j}$, the index $i$ for which the abstraction $\mathit{Abs}(\Pi.(\psi\wedge\overline{\mathsf{OR}_{j}}),i)$ is constructed may be different.

Eliminating redundant clauses or universal literals via the above workflow is denoted by $\mathsf{QRATE}^{+}$ and $\mathsf{QRATU}^{+}$, respectively. In QRATPre+, we apply the $\mathsf{QRATE}^{+}$ and $\mathsf{QRATU}^{+}$ rewrite rules for preprocessing. The $\mathsf{QRAT}$ redundancy property [9] differs from $\mathsf{QRAT}^{+}$ [18] in that for $\mathsf{QRAT}$ always a full abstraction $\mathit{Abs}(\Pi.(\psi\wedge\overline{\mathsf{OR}_{j}}),i)$ with $i:=n$ is constructed, regardless of the actual maximum nesting level of variables in the current outer resolvent $\mathsf{OR}_{j}$. Moreover, $\mathsf{QRAT}^{+}$ relies on QBCP which includes the universal reduction operation [14] to temporarily shorten clauses during propagation. This way, potentially more conflicts are derived. In contrast to that, $\mathsf{QRAT}$ applies propositional unit propagation to abstractions where all variables are existential. Due to that, the $\mathsf{QRAT}^{+}$ redundancy property is more general and stronger than $\mathsf{QRAT}$.

3 Implementation Details

Algorithm 1 shows the high-level workflow implemented in QRATPre+. To limit the computational costs of the relative expensive techniques $\mathsf{QRATE}^{+}$ and $\mathsf{QRATU}^{+}$, which are based on QBCP, we apply cheaper ones first to reduce the formula size upfront. In quantified blocked clause elimination (QBCE) [1], which is a restriction of $\mathsf{QRATE}^{+}$, it is checked whether every outer resolvent (cf. Fig. 1) contains a pair of complementary literals. Blocked literal elimination (BLE) [8] is a restriction of $\mathsf{QRATU}^{+}$ and, like $\mathsf{QBCE}$, checks for complementary literals in outer resolvents. Before checking whether some clause $C$ has the $\mathsf{QRAT}^{+}$ property, we check whether it has the $\mathsf{QAT}$ property. This is done analogously to checking whether an outer resolvent has the $\mathsf{QAT}$ property in $\mathsf{QRAT}^{+}$ testing (cf. Section 2). $\mathsf{QAT}$ checking is necessary in the workflow since it is not subsumed by $\mathsf{QRATE}^{+}$.

During clause elimination, all clauses found redundant in the current PCNF $\phi^{\prime}$ are cleaned up lazily in one pass after an application of a technique. In

literal elimination, redundant literals are cleaned up eagerly since clauses are shortened, which increases chances to detect conflicts in QBCP.

If the $\mathsf{QRAT}^{+}$ redundancy check fails for some clause $C$ with literal $l\in C$ and clause $D_{i}\in\mathsf{RN}(C,l)$ in the resolution neighborhood of $C$, we mark $D_{i}$ as a witness for that failure. If a witness $D$ is found redundant then all clauses in $\mathsf{RN}(D,l)$, for all literals $l\in D$, are scheduled for being checked in the next iteration as $D$ has prevented at least one of these clauses from being detected before. This witness-based scheduling potentially avoids superfluous redundancy checks. In our experiments the median number of clauses being checked in a run of QRATPre+ on a given PCNF was only by a factor of 3.3 larger than the initial number of clauses in the PCNF.

We maintain the index $i$ indicating the maximum nesting level of variables in the current outer resolvent being tested (cf. Fig. 1). Any variable with an index smaller than $i$ is treated as an existential one during QBCP. This way, abstractions $\mathit{Abs}(\Pi.\psi,i)$ are constructed implicitly. For QBCP, we implemented standard two-literal watching [4]. However, when assignments are retracted after deriving a conflict, then in general the literal watchers have to be restored to literals which are existential in the input PCNF rather than in the current abstraction. Restoring literal watchers in our implementation is necessary to maintain certain invariants, in contrast to, e.g., QBCP in QCDCL solvers.

Compared to version 1.0, version 2.0 of QRATPre+ comes with a C API that allows for easy integration in other tools. The API provides functions to import and export PCNFs and to configure the preprocessing workflow. Options include switches to toggle the individual redundancy tests in the main loop, user-defined limits, and shuffling the orderings in which clauses are tested. Shuffling may affect the result of preprocessing since the $\mathsf{QAT}$, $\mathsf{QRATE}^{+}$ and $\mathsf{QRATU}^{+}$ rewrite rules are not confluent. In the default configuration, QRATPre+ does not shuffle clauses and applies rewrite rules until saturation.

4 Experiments

QRATPre+ improves on state-of-the-art preprocessors and solvers in terms of formula size reduction and solved instances. We ran experiments with the preprocessors Bloqqer v37 [6] and HQSpre 1.3 [25], and the solvers CAQE (commit-ID 9b95754 on GitHub) [22, 23], RAReQS 1.1 [10], Ijtihad v2 [2], Qute 1.1 [21], and DepQBF 6.03 [16]. The solvers implement different solving paradigms, e.g., QCDCL (Qute and DepQBF), expansion (RAReQS and Ijtihad), and clausal abstraction (CAQE).

The following experiments were run on a cluster of Intel Xeon CPUs (E5-2650v4, 2.20 GHz) running Ubuntu 16.04.1. We used the 463 instances from the PCNF track of QBFEVAL’18. In all our experiments, we allowed 600s CPU time and 7 GB of memory for each call of Bloqqer, HQSpre, or QRATPre+. For formulas where Bloqqer or HQSpre exceeded these limits, we considered the original, unpreprocessed formula. In contrast to Bloqqer and HQSpre, we implemented a soft time limit in QRATPre+ which, when exceeding the limit, allows to print the preprocessed formula with identified redundant parts being removed.

Table 1 shows the effect of preprocessing by QRATPre+ (Q), Bloqqer (B), HQSpre (H), and combinations, where QRATPre+ is called before (QB, QH) or after

(BQ, HQ) Bloqqer or HQSpre. The table shows average numbers of clauses (#cl), qblocks (#qb), existential (#$\exists$l) and universal literals (#$\forall$l) as a percentage relative to the original benchmark set. Except for qblocks, QRATPre+ considerably further reduces the formula size when combined with both Bloqqer (B vs. QB and BQ) and HQSpre (H vs. QH and HQ). These results include solved instances: QRATPre+, Bloqqer, and HQSpre solve 18, 74, and 158 original instances, respectively. The preprocessors timed out on 12 (HQSpre), 38 (Bloqqer), and 59 (QRATPre+, soft time limit) original instances.

The application of computationally inexpensive techniques like $\mathsf{QBCE}$ and $\mathsf{BLE}$ to shrink the PCNF before applying more expensive ones like $\mathsf{QRATE}^{+}$ and $\mathsf{QRATU}^{+}$ pays off. With the original workflow (Algorithm 1 and column Q in Table 1), QRATPre+ spends 96s on average per instance, compared to 120s when disabling $\mathsf{QBCE}$ and $\mathsf{BLE}$, where it exceeds the time limit on 77 instances.

Shuffling the ordering of clauses before applying $\mathsf{QRATE}^{+}$ and $\mathsf{QRATU}^{+}$ in Algorithm 1 based on five different random seeds hardly had any effect on the aggregate data in column Q in Table 1, except for an increase in eliminated universal literals by one percent. When using the redundancy property of $\mathsf{QRAT}$, which is weaker than the one of $\mathsf{QRAT}^{+}$, by constructing full abstractions (cf. Section 2), we observed a moderate decrease of all four metrics by one percent each.

Tables 1a to 1f show the numbers of instances solved after preprocessing with different combinations of QRATPre+, Bloqqer, and HQSpre. We used a limit of 1800s CPU time and 7 GB of memory for solving. Times for preprocessing are not included in the times reported in the tables. Preprocessing by QRATPre+ increases the number of solved instances in most cases, except for Ijtihad on instances preprocessed with HQSpre and QRATPre+ (Tables 1e and 1f). Similar to formula size reduction shown in Table 1, the ordering of whether to apply QRATPre+ before or after Bloqqer or HQSpre has an impact on solving performance. Interestingly, for all solvers the combination BQ (Bloqqer before QRATPre+) results in a decrease of solved instances compared to QB (QRATPre+ before Bloqqer). We made similar observations for combinations with HQSpre (QH and HQ).333We refer to the appendix for results with combinations BQ and QH.

5 Conclusion

We presented version 2.0 of QRATPre+, a preprocessor for QBFs in PCNF that is based on strong redundancy properties of clauses and universal literals defined by the $\mathsf{QRAT}^{+}$ proof system [18]. $\mathsf{QRAT}^{+}$ is a generalization of the $\mathsf{QRAT}$ proof system [7, 9]. QRATPre+ is the first implementation of the $\mathsf{QRAT}$ and $\mathsf{QRAT}^{+}$ redundancy properties for applications in QBF preprocessing. As such, the techniques implemented in QRATPre+ are orthogonal to techniques applied in state-of-the-art preprocessors like Bloqqer and HQSpre. Our experiments demonstrate a considerable performance increase of preprocessing and solving. QRATPre+ comes with a C API that allows easy integration into other tools.

We observed a sensitivity of solvers to the ordering in which QRATPre+ is coupled with other preprocessors. To better understand the interplay between redundancy elimination and the proof systems implemented in solvers, we want to further analyze this phenomenon. We used a simple but effective witness-based scheduling to avoid superfluous redundancy checks. However, with more sophisticated watched data structures the run time of QRATPre+ could be optimized. To enhance the power of redundancy checking, it could be beneficial to selectively add redundant formula parts to enable additional simplifications afterwards.

Appendix 0.A Appendix

0.A.1 Additional Experimental Data