Conformant Planning as a Case Study of
Incremental QBF Solving^{†}^{†}thanks: Supported by the Austrian Science Fund (FWF) under
grants S11409N23 and P25518N23 and the German Research Foundation (DFG) under grant ER 738/21. This article appeared in the proceedings of
Artificial Intelligence and Symbolic Computation (AISC) [11]. An extended version appeared in Annals of Mathematics
and Artificial Intelligence [12].
Abstract
We consider planning with uncertainty in the initial state as a case study of incremental quantified Boolean formula (QBF) solving. We report on experiments with a workflow to incrementally encode a planning instance into a sequence of QBFs. To solve this sequence of successively constructed QBFs, we use our generalpurpose incremental QBF solver DepQBF. Since the generated QBFs have many clauses and variables in common, our approach avoids redundancy both in the encoding phase and in the solving phase. Experimental results show that incremental QBF solving outperforms nonincremental QBF solving. Our results are the first empirical study of incremental QBF solving in the context of planning and motivate its use in other application domains.
1 Introduction
Many workflows in formal verification and model checking rely on certain logics as languages to model verification conditions or properties of the systems under consideration. Examples are propositional logic (SAT), quantified Boolean formulas (QBFs), and decidable fragments of first order logic in terms of satisfiability modulo theories (SMT). A tight integration of decision procedures to solve formulas in these logics is crucial for the overall performance of the workflows in practice.
In the context of SAT, incremental solving [1, 10, 22, 30] has become a state of the art approach. Given a sequence of related propositional formulas an incremental SAT solver reuses information that was gathered when solving in order to solve the next formula . Since incremental solving avoids some redundancy in the process of solving the sequence , it is desirable to integrate incremental solvers in practical workflows. In contrast, in nonincremental solving the solver does not keep any information from previously solved formulas and always starts from scratch.
QBFs allow for explicit universal () and existential () quantification over Boolean variables. The problem of checking the satisfiability of QBFs is complete. We consider QBFs as a natural modelling language for planning problems with uncertainty in the initial state. In conformant planning we are given a set of state variables over a specified domain, a set of actions with preconditions and effects, an initial state where some values of the variables may be unknown, and a specification of the goal. The task is to find a sequence of actions, i.e., a plan, that leads from the initial state to a state where the goal is satisfied. Many natural problems, such as repair and therapy planning [35], can be formulated as conformant planning problems. When restricted to plans of length polynomial in the input size this form of planning is complete [3], whereas classical planning is complete.
Therefore, using a transformation to QBFs in the case of conformant planning is a very natural approach. Rintanen [33] presented such transformations. Recently, Kronegger et al. [20] showed that transforming the planning instance into a sequence of QBFs can be competitive. In this approach, they generated a QBF for every plan length under consideration and invoked an external QBF solver on each generated QBF. However, the major drawback is that the QBF solver cannot reuse information from previous runs and thus has to relearn all necessary information in order to solve the QBF. In this work we overcome this problem by tightly integrating a generalpurpose incremental QBF solver in an incremental workflow to solve planning problems. To obtain a better picture of the performance gain through the incremental approach, we perform a case study where we compare incremental and nonincremental QBF solving on benchmarks for conformant planning.
The main contributions of this work are as follows.

Planning tool. We present a planning tool based on the transformation of planning instances with unknown variables in the initial state to QBFs. This tool implements an incremental and exact approach, i.e., it is guaranteed to find a plan whenever a plan exists and – if successful – it returns a plan of minimal length. Furthermore, our tool allows for the use of arbitrary (incremental) QBF solvers.

Experimental evaluation. We evaluate the performance of the incremental and the nonincremental approach to planning with incomplete information in the initial state. Thereby, we rely on incremental and nonincremental variants of the QBF solver DepQBF [25, 26].^{1}^{1}1DepQBF is free software: http://lonsing.github.io/depqbf/ Incremental QBF solving outperforms nonincremental QBF solving in our planning tool. Our results are a case study of incremental QBF solving and motivate its use in other application domains. In addition, we also compare our results to heuristic approaches.
2 Incremental QBF Solving
We focus on QBFs in prenex conjunctive normal form (PCNF). All quantifiers occur in the prefix and the CNF part is a quantifierfree propositional formula in CNF. The prefix consists of pairwise disjoint sets of quantified Boolean variables, where , and gives rise to a linear ordering of the variables: we define if , and .
The semantics of QBFs is defined recursively based on the quantifier types and the prefix ordering of the variables. The QBF consisting only of the truth constant true () or false () is satisfiable or unsatisfiable, respectively. The QBF with the universal quantification at the leftmost position in the prefix is satisfiable if and are satisfiable, where the formula () results from by replacing the free variable by (). The QBF with the existential quantification is satisfiable if or are satisfiable.
Searchbased QBF solving [8] is a generalization of the DPLL algorithm [9] for SAT. Modern searchbased QBF solvers implement a QBFspecific variant of conflictdriven clause learning (CDCL) for SAT, called QCDCL [13, 23, 27, 36]. In QCDCL the variables are successively assigned until an (un)satisfiable subcase is encountered. The subcase is analyzed and new learned constraints (clauses or cubes) are inferred by Qresolution [19, 27]. The purpose of the learned constraints is to prune the search space and to speed up proof search. Assignments are retracted by backtracking and the next subcase is determined until the formula is solved.
Let be a sequence of QBFs. In incremental QBF solving based on QCDCL, we must keep track which of the constraints that were learned on a solved QBF can be reused for solving the QBFs with . An approach to incremental QBF solving was first presented in the context of bounded model checking [29]. We rely on the generalpurpose incremental QBF solver DepQBF [25, 26].
To illustrate the potential of incremental QBF solving, we present a case study of QBFbased conformant planning in the following sections. To this end we discuss conformant planning and two types of benchmarks used in the experimental analysis.
3 Conformant Planning and Benchmark Domains
A conformant planning problem consists of a set of state variables over a specified domain, a set of actions with preconditions and effects, an initial state where some values of the variables may be unknown, and a specification of the goal. The task is to find a sequence of actions, i.e., a plan, that leads from the initial state to a state where the goal is satisfied. The plan has to reach the goal for all possible values of unknown variables, i.e., it has to be failsafe. This problem can nicely be encoded into QBFs, e.g., by building upon the encodings by Rintanen [33]. Conformant planning naturally arises, e.g., in repair and therapy planning [35], where a plan needs to succeed even if some obstacles arise.
The length of a plan is the number of actions in the plan. As one is usually looking for short plans, the following strategy is used. Starting at a lower bound on the minimal plan length, we iteratively increment the plan length until a plan is found or a limit on the plan length is reached. This strategy is readily supported by an incremental QBF solver because a large number of clauses remains untouched when moving from length to and always leads to optimal plans with respect to the plan length.
The two benchmark types we consider in our case study are called “Dungeon”. These benchmarks are inspired by adventure computergames and were first presented at the QBF workshop 2013 [20]. In this setting a player wants to defeat monsters living in a dungeon. Each monster requires a certain configuration of items to be defeated. In the beginning, the player picks at most one item from each pool of items. In addition, the player can exchange several items for one more powerful item if she holds all necessary “ingredients”. Eventually, the player enters the dungeon. When entering the dungeon, the player is forced to pick additional items. The dilemma is that the player does not know which items she will get, i.e., the additional items are represented by variables with unknown values in the initial state. It might also happen that the new items turn out to be obstructive given the previously chosen item configuration. The goal is to pick items such that irrespective of the additional items she defeats at least one monster.
We consider two variants of the Dungeon benchmark. In variant v0 the player is only allowed to enter the dungeon once, thus has to pick the items and build more powerful items in advance. In contrast, in variant v1 the player might attempt fighting the monsters several times and pick/build further items in between if she was unsuccessful.
Despite the simple concept, these benchmarks are well suited for our case study. First, they capture the full hardness of complete problems. Second, it is natural to reinterpret the game setting as a configuration or maintenance problem.
4 QBF Planning Tool
We briefly describe our planning tool that takes planning instances as input and encodes them as a sequence of QBFs. This tool generates a plan of minimal length for a given conformant planning instance with uncertainty in the initial state.
Figure 1 illustrates the architecture of our planning tool which was used for the experiments. The tool takes a planning instances given in PDDL format as input. After parsing the input, the grounder analyzes the given planning instance and calculates a lower bound on the plan length. Starting with a plan length of , the grounder then grounds only relevant parts of the instance, i.e., the grounder systematically eliminates variables from the PDDL instance. In a next step, the QBF encoder takes the ground representation as input and transforms it into a QBF that is satisfiable if and only if the planning problem has a plan of length . The encoding which is used for this transformation to QBFs builds upon the encoding described in the work of Rintanen [33]. We decided to employ the encoding rather than a encoding as this gives a more natural encoding and simplifies the PCNF transformation. Since in this work we focus on a comparison of the incremental and nonincremental approach, we do not go into the details of the encoding. After the transformation into a QBF, the QBF encoder then invokes a QBF solver on the generated QBF. If the generated QBF is satisfiable, our system extracts the optimal plan from the assignment of the leftmost block. If the QBF is unsatisfiable, the plan length is incremented, additional relevant parts of the problem may need grounding, and the subsequent QBF is passed to the solver. Below, we give an overview of the features and optimizations of our planning tool.
Since grounding the planning instance can cause an exponential blowup in the size of the input, we have implemented a dynamic grounding algorithm. This algorithm uses ideas from the concept of the planning graph [6] to only ground actions that are relevant for a certain plan length. With this optimization, we are able to make the grounding process feasible. Although the planning tool provides several methods to compute lower bounds on the plan length, in our experiments we always started with plan length to allow for a better comparison of the incremental and nonincremental approach.
Our incremental QBF solver DepQBF is written in C whereas the planning tool is written in Java. To integrate DepQBF in our tool and to employ its features for incremental solving, we implemented a Java interface for DepQBF, called DepQBF4J.^{2}^{2}2DepQBF4J is part of the release of DepQBF version 3.03 or later. This way, DepQBF can be integrated into arbitrary Java applications and its API functions can then be called via the Java Native Interface (JNI).
In our planning tool, the use of DepQBF’s API is crucial for incremental solving because we have to avoid writing the generated QBFs to a file. Instead, we add and modify the QBFs to be solved directly via the API of DepQBF. The API provides push and pop functions to add and remove frames, i.e., sets of clauses, in a stackbased manner. The CNF part of a QBF is represented as a sequence of frames.
Given a planning instance, the workflow starts with plan length . The QBF for plan length can be encoded naturally in an incremental fashion by maintaining two frames and of clauses: clauses which encode the goal state are added to . All other clauses are added to . Frame is added to DepQBF before frame . If is unsatisfiable, then is deleted by a pop operation, i.e., the clauses encoding the goal state of plan length are removed. The plan length is increased by one and additional clauses encoding the possible state transitions from plan length to are added to . The clauses encoding the goal state for plan length are added to a new . Note that in the workflow clauses are added to but this frame is never deleted.
The workflow terminates if (1) the QBF is satisfiable, indicating that the instance has a plan with optimal length , or (2) is unsatisfiable and exceeds a userdefined upper bound, indicating that the instance does not have a plan of length or smaller, or (3) the time or memory limits are exceeded. In the cases (1) and (2), we consider the planning instance as solved. For the experimental evaluation, we imposed an upper bound of 200 on the plan length.
The Dungeon benchmark captures the full hardness of problems on the second level of the polynomial hierarchy. Therefore, as shown in the following section, already instances with moderate plan lengths might be hard for QBF solvers as well as for planningspecific solvers [20]. We considered an upper bound of 200 of the plan length to be sufficient to show the difference between the incremental and nonincremental QBFbased approach. The hardness is due to the highly combinatorial nature of the Dungeon instances, which also applies to configuration and maintenance problems. Further, configuration and maintenance problems can be encoded easily into conformant planning as the Dungeon benchmark is essentially a configuration problem.
Our planning tool can also be combined with any nonincremental QBF solver to determine a plan of minimal length in a nonincremental fashion. This is done by writing the QBFs which correspond to the plan lengths under consideration to separate files and solving them with a standalone QBF solver [20].
5 Experimental Evaluation
We evaluate the incremental workflow described in the previous section using planning instances from the Dungeon benchmark. The purpose of our experimental analysis is to compare incremental and nonincremental QBF solving in the context of conformant planning. Thereby, we provide the first empirical study of incremental QBF solving in the planning domain. In addition to [28, 29], our results independently motivate the use of incremental QBF solving in other application domains.
From the Dungeon benchmark described in Section 3, we selected 144 planning instances from each variant v0 and v1, resulting in 288 planning instances. Given a planning instance, we allowed 900 seconds wall clock time and 7 GB of memory for the entire workflow, which includes grounding, QBF encoding and QBF solving. All experiments reported were run on AMD Opteron 6238, 2.6 GHz, 64bit Linux.
288 Planning Instances (Dungeon Benchmark: v0 and v1)  
Time  Solved  Plan found  No plan  
DepQBF:  112,117  168  163  5  24.40  2210  501,706 
incDepQBF:  103,378  176  163  13  14.55  965  120,166 
Uniquely Solved Planning Instances  
Solved  Plan found  No plan  
DepQBF:  2  0  2  545.04  99  1,024,200 
incDepQBF:  10  0  10  94.15  174  45,180 
We first compare the performance of incremental and nonincremental QBF solving in the planning workflow. To this end, we used incremental and nonincremental variants of our QBF solver DepQBF, referred to as incDepQBF and DepQBF, respectively. For nonincremental solving, we called the standalone solver DepQBF by system calls from our planning tool. Thereby, we generated the QBF encoding of a particular planning instance and wrote it to a file on the hard disk. DepQBF then reads the QBF from the file. For incremental solving, we called incDepQBF through its API via the DepQBF4J interface. This way, the QBF encoding is directly added to incDepQBF by its API within the planning tool (as outlined in the previous section), and no files are written. The solvers incDepQBF and DepQBF have the same codebase. Therefore, differences in their performance are due to whether incremental solving is applied or not.
The statistics in Tables 1 to 3 and Figure 4 illustrate that incremental QBF solving by incDepQBF outperforms nonincremental solving by DepQBF in the workflow in terms of solved instances, uniquely solved instances (Table 2), run time and in the number of backtracks and assignments spent in QBF solving. With incDepQBF and DepQBF, 166 instances were solved by both. For three of these 166 instances, no plan exists.
The different calling principles of incDepQBF (by the API) and DepQBF (by system calls) may have some influence on the overall run time of the workflow, depending on the underlying hardware and operating system. In general, the use of the API avoids I/O overhead in terms of hard disk accesses and thus might save run time. Due to the timeout of 900 seconds and the relatively small number of QBF solver calls in the workflow (at most 201, for plan length 0 up to the upper bound of 200), we expect that the influence of the calling principle on the overall time statistics in Tables 1 and 2 and Figure 4 is only marginal. Moreover, considering backtracks and assignments as shown in Table 3 as an independent measure of the performance of the workflow, incremental solving by incDepQBF clearly outperforms nonincremental solving by DepQBF.
Figure 2 shows how the number of backtracks evolves if the plan length is increased. On the selected instances which have a plan with optimal length , we observed peaks in the number of backtracks by incDepQBF and DepQBF on those QBFs which correspond to the plan length . Thus empirically the final unsatisfiable QBF for plan length is harder to solve than the QBF for the optimal plan length or shorter plan lengths. Figure 2 (right) shows notable exceptions. For , the number of backtracks by DepQBF increases in contrast to incDepQBF. For and , incDepQBF spent more backtracks than DepQBF. We attribute this difference to the heuristics in (inc)DepQBF. The same QBFs must be solved by incDepQBF and DepQBF in one run of the workflow. However, the heuristics in incDepQBF might be negatively influenced by previously solved QBFs. We made similar observations on instances not solved with either incDepQBF or DepQBF where DepQBF reached a longer plan length than incDepQBF within the time limit.
Incremental solving performs particularly well on instances for which no plan exists. Considering the ten instances uniquely solved with incDepQBF (Table 2), on average it took less than 0.5 seconds to encode and solve one of the 201 unsatisfiable QBFs (i.e., from plan length zero to the upper bound of 200) in the planning workflow. Considering the 13 instances solved using incDepQBF which do not have a plan (Table 1), on average the workflow took 73.80 seconds and incDepQBF spent 35,729 assignments and 135 backtracks. In contrast to that, the workflow using DepQBF took 270.92 seconds on average to solve the five instances which do not have a plan (Table 1), and DepQBF spent 421,619 assignments and 99 backtracks.
5.1 Preprocessing
The implementation of (inc)DepQBF does not include preprocessing [5, 14]. In general, preprocessing might be very beneficial for the performance of QBFbased workflows. The efficient combination of preprocessing and incremental solving is part of ongoing research in SAT [21, 30] and QBF [16, 18, 28, 34].
In order to evaluate the potential impact of preprocessing in our workflow, we carried out the following experiment. We ran the workflow using DepQBF on all 288 planning instances with a time limit of 900 seconds and collected all QBFs that were generated this way. Like for the results in Table 1, we ran DepQBF and incDepQBF on these QBFs within our workflow. Additionally, we ran the QBF solver Nenofex [24] because it performed well on QBFs generated from the Dungeon benchmark.^{3}^{3}3Results of Nenofex in the QBF Gallery 2013: http://www.kr.tuwien.ac.at/events/qbfgallery2013/sc_apps/conf_planning_dungeon.html Nenofex successively eliminates variables in a QBF by expansion at the cost of a possibly exponential blow up of the formula size. Figure 4 shows the run times of DepQBF, incDepQBF, Nenofex and DepQBFpre, which combines DepQBF with the preprocessor Bloqqer [5]. We accumulated the solving times spent on QBFs that were generated from a particular planning instance. The plot shows these accumulated times for each planning instance. Run times smaller than the time out of 900 seconds do not necessarily indicate that the planning instance was solved because we considered only a subset of the QBFs corresponding to the planning instance. The performance of DepQBFpre and Nenofex shown in Figure 4 illustrates the benefits of preprocessing in the planning workflow. Among other techniques, Bloqqer applies expansion, the core technique used in Nenofex, in a way that restricts the blow up of the formula size [4, 7].
Given the results shown in Figure 4, preprocessing might considerably improve the performance of incremental QBF solving in our workflow. To this end, it is necessary to combine QBF preprocessing and solving in an incremental way.
5.2 Comparison to Heuristic Approaches
Although our focus is on a comparison of nonincremental and incremental QBF solving, we report on additional experiments with the heuristic planning tools ConformantFF [17] and T0 [32]. In contrast to our implemented QBFbased approach to conformant planning, heuristic tools do not guarantee to find a plan with the optimal (i.e., shortest) length. In practical settings, plans with optimal length are desirable. Moreover, the QBFbased approach allows to verify the nonexistence of a plan with respect to an upper bound on the plan length. Due to these differences, a comparison based on the run times and numbers of solved instances only is not appropriate.
Related to Table 1, ConformantFF solved 169 planning instances, where it found a plan for 144 instances and concluded that no plan exists (with a length shorter than our considered upper bound of 200) for 25 instances. Considering the 124 instances where both incDepQBF and ConformantFF found a plan, for 42 instances the optimal plan found by incDepQBF was strictly shorter than the plan found by ConformantFF. On the 124 instances, the average (median) length of the plan found by incDepQBF was 2.06 (1), compared to an average (median) length of 3.45 (1) by ConformantFF.
Due to technical problems, we were not able to run the experiments with T0^{4}^{4}4Experiments with T0 were run on AMD Opteron 6176 SE, 2.3 GHz, 64bit Linux on the same system as the experiments with (inc)DepQBF and ConformantFF. Hence the results by T0 reported in the following are actually incomparable to Table 1. However, we include them here to allow for a basic comparison of the plan lengths.
Using the same time and memory limits as for incDepQBF and ConformantFF, T0 solved 206 planning instances, where it found a plan for 203 instances and concluded that no plan exists (with a length shorter than the upper bound of 200) for three instances. Given the 156 instances where both incDepQBF and T0 found a plan, for 56 instances the optimal plan found by incDepQBF was strictly shorter than the plan found by T0. On the 156 instances, the average (median) length of the plan found by incDepQBF was 2.25 (1), compared to an average (median) length of 3.08 (2) by T0.
From the 13 instances solved by incDepQBF for which no plan exists (Table 1), none was solved using T0 and 12 were solved using ConformantFF.
Our experiments confirm that the QBFbased approach to conformant planning finds optimal plans in contrast to the plans found by the heuristic approaches implemented in ConformantFF and T0. Moreover, (inc)DepQBF and other searchbased QBF solvers rely on Qresolution [19] as the underlying proof system. Given a Qresolution proof of the unsatisfiability of a QBF , it is possible to extract from a countermodel [2] or strategy [15] of in terms of a set of Herbrand functions. Intuitively, an Herbrand function represents the values that a universal variable must take to falsify with respect to the values of all existential variables with in the prefix ordering. Given a conformant planning problem , Qresolution proofs and Herbrand function countermodels allow to independently explain and verify [31] the nonexistence of a plan (of a particular length) for by verifying the unsatisfiability of the QBF encoding of . This is an appealing property of the QBFbased approach. In practical applications, it may be interesting to have an explanation of the nonexistence of a plan in addition to the mere answer that no plan exists.
The exact QBFbased approach for conformant planning can be combined with heuristic approaches in a portfoliostyle system, for example. Thereby, the two approaches are applied in parallel and independently from each other. This way, modern multicore hardware can naturally be exploited.
6 Conclusion
We presented a case study of incremental QBF solving based on a workflow to incrementally encode planning problems into sequences of QBFs. Thereby, we focused on a generalpurpose QBF solver. The incremental approach avoids some redundancy. First, parts of the QBF encodings of shorter plan lengths can be reused in the encodings of longer plan lengths. Second, the incremental QBF solver benefits from information that was learned from previously solved QBFs. Compared to heuristic approaches, the QBFbased approach has the advantage that it always finds the shortest plan and it allows to verify the nonexistence of a plan by Qresolution proofs.
Using variants of the solver DepQBF, incremental QBF solving outperforms nonincremental QBF solving in the planning workflow in terms of solved instances and statistics like the number of backtracks, assignments, and run time. The results of our experimental study independently motivate the use of incremental QBF solving in applications other than planning. We implemented the Java interface DepQBF4J to integrate the solver DepQBF in our planning tool. This interface is extensible and can be combined with arbitrary Java applications.
The experiments revealed that keeping learned information in incremental QBF solving might be harmful if the heuristics of the solver are negatively influenced. Our observations merit a closer look on these heuristics when used in incremental solving. In general, the combination of preprocessing and incremental solving [16, 18, 21, 28, 29, 30, 34] could improve the performance of QBFbased workflows.
References
 [1] Audemard, G., Lagniez, J.M., Simon, L.: Improving Glucose for Incremental SAT Solving with Assumptions: Application to MUS Extraction. In: Järvisalo, M., Van Gelder, A. (eds.) SAT. LNCS, vol. 7962, pp. 309–317. Springer (2013)
 [2] Balabanov, V., Jiang, J.H.R.: Unified QBF certification and its applications. Formal Methods in System Design 41(1), 45–65 (2012)
 [3] Baral, C., Kreinovich, V., Trejo, R.: Computational Complexity of Planning and Approximate Planning in the Presence of Incompleteness. Artificial Intelligence 122(12), 241–267 (2000)
 [4] Biere, A.: Resolve and Expand. In: Hoos, H.H., Mitchell, D.G. (eds.) SAT (Selected Papers). LNCS, vol. 3542, pp. 59–70. Springer (2004)
 [5] Biere, A., Lonsing, F., Seidl, M.: Blocked Clause Elimination for QBF. In: Bjørner, N., SofronieStokkermans, V. (eds.) CADE. LNCS, vol. 6803, pp. 101–115. Springer (2011)
 [6] Blum, A., Furst, M.L.: Fast Planning Through Planning Graph Analysis. Artificial Intelligence 90(12), 281–300 (1997)
 [7] Bubeck, U., Kleine Büning, H.: Bounded Universal Expansion for Preprocessing QBF. In: MarquesSilva, J., Sakallah, K.A. (eds.) SAT. LNCS, vol. 4501, pp. 244–257. Springer (2007)
 [8] Cadoli, M., Schaerf, M., Giovanardi, A., Giovanardi, M.: An Algorithm to Evaluate Quantified Boolean Formulae and Its Experimental Evaluation. Journal of Automated Reasoning 28(2), 101–142 (2002)
 [9] Davis, M., Logemann, G., Loveland, D.: A Machine Program for Theoremproving. Communications of the ACM 5(7), 394–397 (1962)
 [10] Eén, N., Sörensson, N.: Temporal Induction by Incremental SAT Solving. Electronic Notes in Theoretical Computer Science 89(4), 543–560 (2003)
 [11] Egly, U., Kronegger, M., Lonsing, F., Pfandler, A.: Conformant Planning as a Case Study of Incremental QBF Solving. In: ArandaCorral, G.A., Calmet, J., MartínMateos, F.J. (eds.) AISC. LNCS, vol. 8884, pp. 120–131. Springer (2014)
 [12] Egly, U., Kronegger, M., Lonsing, F., Pfandler, A.: Conformant planning as a case study of incremental QBF solving. Annals of Mathematics and Artificial Intelligence pp. 1–25 (2016), http://dx.doi.org/10.1007/s1047201695012
 [13] Giunchiglia, E., Narizzano, M., Tacchella, A.: Clause/Term Resolution and Learning in the Evaluation of Quantified Boolean Formulas. Journal of Artificial Intelligence Research 26, 371–416 (2006)
 [14] Giunchiglia, E., Marin, P., Narizzano, M.: sQueezeBF: An Effective Preprocessor for QBFs Based on Equivalence Reasoning. In: Strichman, O., Szeider, S. (eds.) SAT. LNCS, vol. 6175, pp. 85–98. Springer (2010)
 [15] Goultiaeva, A., Van Gelder, A., Bacchus, F.: A Uniform Approach for Generating Proofs and Strategies for Both True and False QBF Formulas. In: Walsh, T. (ed.) IJCAI. pp. 546–553. AAAI Press (2011)
 [16] Heule, M., Seidl, M., Biere, A.: A Unified Proof System for QBF Preprocessing. In: Demri, S., Kapur, D., Weidenbach, C. (eds.) IJCAR. LNCS, vol. 8562, pp. 91–106. Springer (2014)
 [17] Hoffmann, J., Brafman, R.I.: Conformant planning via heuristic forward search: A new approach. Artificial Intelligence 170(67), 507–541 (2006)
 [18] Janota, M., Grigore, R., MarquesSilva, J.: On QBF Proofs and Preprocessing. In: McMillan, K.L., Middeldorp, A., Voronkov, A. (eds.) LPAR19. LNCS, vol. 8312, pp. 473–489. Springer (2013)
 [19] Kleine Büning, H., Karpinski, M., Flögel, A.: Resolution for Quantified Boolean Formulas. Information and Computation 117(1), 12–18 (1995)
 [20] Kronegger, M., Pfandler, A., Pichler, R.: Conformant planning as a benchmark for QBFsolvers. In: Report Int. Workshop on Quantified Boolean Formulas (QBF 2013). pp. 1–5 (2013), http://fmv.jku.at/qbf2013/reportQBFWS13.pdf
 [21] Kupferschmid, S., Lewis, M.D.T., Schubert, T., Becker, B.: Incremental Preprocessing Methods for Use in BMC. Formal Methods in System Design 39(2), 185–204 (2011)
 [22] Lagniez, J.M., Biere, A.: Factoring Out Assumptions to Speed Up MUS Extraction. In: Järvisalo, M., Van Gelder, A. (eds.) SAT. LNCS, vol. 7962, pp. 276–292. Springer (2013)
 [23] Letz, R.: Lemma and Model Caching in Decision Procedures for Quantified Boolean Formulas. In: Egly, U., Fermüller, C.G. (eds.) TABLEAUX. LNCS, vol. 2381, pp. 160–175. Springer (2002)
 [24] Lonsing, F., Biere, A.: Nenofex: Expanding NNF for QBF Solving. In: Kleine Büning, H., Zhao, X. (eds.) SAT. LNCS, vol. 4996, pp. 196–210. Springer (2008)
 [25] Lonsing, F., Egly, U.: Incremental QBF Solving. In: O’Sullivan, B. (ed.) CP. LNCS, vol. 8656, pp. 514–530. Springer (2014)
 [26] Lonsing, F., Egly, U.: Incremental QBF Solving by DepQBF. In: Hong, H., Yap, C. (eds.) ICMS. LNCS, vol. 8592, pp. 307–314. Springer (2014)
 [27] Lonsing, F., Egly, U., Van Gelder, A.: Efficient Clause Learning for Quantified Boolean Formulas via QBF Pseudo Unit Propagation. In: Järvisalo, M., Van Gelder, A. (eds.) SAT. LNCS, vol. 7962, pp. 100–115. Springer (2013)
 [28] Marin, P., Miller, C., Becker, B.: Incremental QBF Preprocessing for Partial Design Verification  (Poster Presentation). In: Cimatti, A., Sebastiani, R. (eds.) SAT. LNCS, vol. 7317, pp. 473–474. Springer (2012)
 [29] Marin, P., Miller, C., Lewis, M.D.T., Becker, B.: Verification of Partial Designs using Incremental QBF Solving. In: Rosenstiel, W., Thiele, L. (eds.) DATE. pp. 623–628. IEEE (2012)
 [30] Nadel, A., Ryvchin, V., Strichman, O.: Ultimately Incremental SAT. In: Sinz, C., Egly, U. (eds.) SAT. LNCS, vol. 8561, pp. 206–218. Springer (2014)
 [31] Niemetz, A., Preiner, M., Lonsing, F., Seidl, M., Biere, A.: ResolutionBased Certificate Extraction for QBF  (Tool Presentation). In: Cimatti, A., Sebastiani, R. (eds.) SAT. LNCS, vol. 7317, pp. 430–435. Springer (2012)
 [32] Palacios, H., Geffner, H.: Compiling Uncertainty Away in Conformant Planning Problems with Bounded Width. Journal of Artificial Intelligence Research 35, 623–675 (2009)
 [33] Rintanen, J.: Asymptotically Optimal Encodings of Conformant Planning in QBF. In: Holte, R.C., Howe, A.E. (eds.) AAAI. pp. 1045–1050. AAAI Press (2007)
 [34] Seidl, M., Könighofer, R.: Partial witnesses from preprocessed quantified Boolean formulas. In: DATE. pp. 1–6. IEEE (2014)
 [35] Smith, D.E., Weld, D.S.: Conformant Graphplan. In: Mostow, J., Rich, C. (eds.) AAAI/IAAI. pp. 889–896. AAAI Press / The MIT Press (1998)
 [36] Zhang, L., Malik, S.: Towards a Symmetric Treatment of Satisfaction and Conflicts in Quantified Boolean Formula Evaluation. In: Hentenryck, P.V. (ed.) CP. LNCS, vol. 2470, pp. 200–215. Springer (2002)