View source for True quantified Boolean formula

{{Redirect|QBF|the governing body of basketball in Qatar|Qatar Basketball Federation}}
In [[computational complexity theory]], the language '''TQBF''' is a [[formal language]] consisting of the '''true quantified Boolean formulas'''.  A (fully) quantified Boolean formula is a formula in [[Quantification (logic)|quantified]] [[propositional logic]] (also known as [[Second-order propositional logic]]) where every variable is quantified (or [[Bound variable|bound]]), using either [[existential quantification|existential]] or [[universal quantification|universal]] quantifiers, at the beginning of the sentence. Such a formula is equivalent to either true or false (since there are no [[Bound variable|free variable]]s). If such a formula evaluates to true, then that formula is in the language TQBF. It is also known as '''QSAT''' (Quantified [[Boolean satisfiability problem|SAT]]).

==Overview==
In computational complexity theory, the '''quantified Boolean formula problem''' ('''QBF''') is a generalization of the [[Boolean satisfiability problem]] in which both [[existential quantification|existential quantifiers]] and [[universal quantification|universal quantifiers]] can be applied to each variable. Put another way, it asks whether a quantified sentential form over a set of Boolean variables is true or false. For example, the following is an instance of QBF:

: <math>\forall x\  \exists y\  \exists z\  ((x  \lor z) \land y)</math>

QBF is the canonical [[complete problem]] for [[PSPACE]], the class of problems solvable by a deterministic or nondeterministic [[Turing machine]] in polynomial space and unlimited time.<ref>{{cite book |author1=M. Garey  |author2=D. Johnson  |name-list-style=amp | title = Computers and Intractability: A Guide to the Theory of NP-Completeness |title-link=Computers and Intractability: A Guide to the Theory of NP-Completeness | publisher = W. H. Freeman, San Francisco, California | year = 1979 | isbn = 0-7167-1045-5}}</ref> Given the formula in the form of an [[abstract syntax tree]], the problem can be solved easily by a set of mutually recursive procedures which evaluate the formula. Such an algorithm uses space proportional to the height of the tree, which is linear in the worst case, but uses time exponential in the number of quantifiers.

Provided that [[MA (complexity)|MA]] ⊊ PSPACE, which is widely believed, QBF cannot be solved, nor can a given solution even be verified, in either deterministic or [[probabilistic Turing machine|probabilistic]] polynomial time (in fact, unlike the satisfiability problem, there's no known way to specify a solution succinctly). It can be solved using an [[alternating Turing machine]] in linear time, since [[AP (complexity)|AP]] = PSPACE, where AP is the class of problems alternating machines can solve in polynomial time.<ref>{{cite journal | author = A. Chandra, D. Kozen, and [[Larry Stockmeyer|L. Stockmeyer]] | title = Alternation | journal = Journal of the ACM | volume = 28 | issue = 1 | pages = 114&ndash;133 | year = 1981 | doi = 10.1145/322234.322243| s2cid=238863413 | doi-access = free }}</ref>

When the seminal result [[IP (complexity)|IP]] = PSPACE was shown (see [[interactive proof system]]), it was done by exhibiting an interactive proof system that could solve QBF by solving a particular arithmetization of the problem.<ref>{{cite journal | author = Adi Shamir| title = Ip = Pspace | journal = Journal of the ACM | volume = 39 | issue = 4 | pages = 869&ndash;877 | year = 1992 | doi = 10.1145/146585.146609|s2cid = 315182| doi-access = free }}</ref>

QBF formulas have a number of useful canonical forms. For example, it can be shown that there is a [[polynomial-time many-one reduction]] that will move all quantifiers to the front of the formula and make them alternate between universal and existential quantifiers. There is another reduction that proved useful in the IP = PSPACE proof where no more than one universal quantifier is placed between each variable's use and the quantifier binding that variable. This was critical in limiting the number of products in certain subexpressions of the arithmetization.

== Prenex normal form ==

A fully quantified Boolean formula can be assumed to have a very specific form, called [[prenex normal form]]. It has two basic parts: a portion containing only quantifiers and a portion containing an unquantified Boolean formula usually denoted as <math>\displaystyle \phi</math>. If there are <math>\displaystyle n</math> Boolean variables, the entire formula can be written as

:<math>\displaystyle  \exists x_1 \forall x_2 \exists x_3 \cdots Q_n x_n \phi(x_1, x_2, x_3, \dots, x_n)</math>

where every variable falls within the [[Free variables and bound variables|scope]] of some quantifier. By introducing dummy variables, any formula in prenex normal form can be converted into a sentence where existential and universal quantifiers alternate. Using the dummy variable <math>\displaystyle y_1</math>,

:<math>\displaystyle  \exists x_1 \exists x_2 \phi(x_1, x_2) \quad \mapsto \quad
\exists x_1 \forall y_1 \exists x_2 \phi(x_1, x_2)</math>

The second sentence has the same [[truth value]] but follows the restricted syntax. Assuming fully quantified Boolean formulas to be in prenex normal form is a frequent feature of proofs.

== QBF solvers ==

=== Naive ===
{{Original research section|date=May 2021}}
There is a simple recursive algorithm for determining whether a QBF is in TQBF (i.e. is true).  Given some QBF

:<math>Q_1 x_1 Q_2 x_2 \cdots Q_n x_n \phi(x_1, x_2, \dots, x_n).</math>

If the formula contains no quantifiers, we can just return the formula. Otherwise, we take off the first quantifier and check both possible values for the first variable:

:<math>A = Q_2 x_2 \cdots Q_n x_n \phi(0, x_2, \dots, x_n),</math>
:<math>B = Q_2 x_2 \cdots Q_n x_n \phi(1, x_2, \dots, x_n).</math>

If <math>Q_1 = \exists</math>, then return <math>A \lor B</math>. If <math>Q_1 = \forall</math>, then return <math>A \land B</math>.<ref>{{Citation|last1=Arora|first1=Sanjeev|title=Space complexity|url=http://dx.doi.org/10.1017/cbo9780511804090.007|work=Computational Complexity|pages=78–94|place=Cambridge|publisher=Cambridge University Press|isbn=978-0-511-80409-0|access-date=2021-05-26|last2=Barak|first2=Boaz|year=2009|doi=10.1017/cbo9780511804090.007|s2cid=262800930 }}</ref>

How fast does this algorithm run?
For every quantifier in the initial QBF, the algorithm makes two recursive calls on only a linearly smaller subproblem. This gives the algorithm an exponential runtime [[Big O notation|O(2<sup>''n''</sup>)]].{{Citation needed|date=February 2021}}

How much space does this algorithm use?
Within each invocation of the algorithm, it needs to store the intermediate results of computing A and B.  Every recursive call takes off one quantifier, so the total recursive depth is linear in the number of quantifiers.  Formulas that lack quantifiers can be evaluated in space logarithmic in the number of variables. The initial QBF was fully quantified, so there are at least as many quantifiers as variables.  Thus, this algorithm uses ''O''(''n'' + log ''n'') = ''O''(''n'') space. This makes the TQBF language part of the [[PSPACE]] [[complexity class]].{{Citation needed|date=February 2021}}

=== State of the art ===
{{Expand section|date=May 2021}}
Despite the PSPACE-completeness of QBF, many solvers have been developed to solve these instances. (This is analogous to the situation with [[Boolean satisfiability problem|SAT]], the single existential quantifier version; even though it is [[NP-completeness|NP-complete]], it is still possible to solve many SAT instances heuristically.)<ref name=":0">{{Cite web|title=QBFEVAL Home Page|url=http://www.qbflib.org/index_eval.php|access-date=2021-02-13|website=www.qbflib.org}}</ref><ref name=":1">{{Cite web|title=QBF Solvers {{!}} Beyond NP|url=http://beyondnp.org/pages/solvers/qbf-solvers/|access-date=2021-02-13|website=beyondnp.org}}</ref> The case where there are only 2 quantifiers, known as 2QBF, has received special attention.<ref name=":2">{{Cite journal|last1=Balabanov|first1=Valeriy|last2=Roland Jiang|first2=Jie-Hong|last3=Scholl|first3=Christoph|last4=Mishchenko|first4=Alan|last5=K. Brayton|first5=Robert|date=2016|title=2QBF: Challenges and Solutions|url=https://people.eecs.berkeley.edu/~alanmi/publications/2016/sat16_qbf.pdf|url-status=live|journal=International Conference on Theory and Applications of Satisfiability Testing|volume=|pages=453–459|archive-url=https://web.archive.org/web/20210213172709/https://people.eecs.berkeley.edu/~alanmi/publications/2016/sat16_qbf.pdf|archive-date=13 February 2021|via=SpringerLink}}</ref>{{Weasel inline|date=May 2021}}

The QBF solver competition QBFEVAL has been running more-or-less annually since 2004;<ref name=":0" /><ref name=":1" /> solvers are required to read instances in QDIMACS format and either the QCIR or QAIGER formats.<ref name=":3">{{Cite web|title=QBFEVAL'20|url=http://www.qbflib.org/qbfeval20.php|access-date=2021-05-29|website=www.qbflib.org}}</ref> High-performing QBF solvers generally use QDPLL (a generalization of [[DPLL algorithm|DPLL]]) or CEGAR.<ref name=":0" /><ref name=":1" /><ref name=":2" /> Research into QBF solving began with the development of backtracking DPLL for QBF in 1998, followed by the introduction of clause learning and variable elimination in 2002;<ref name=":4">{{Cite web|last=Lonsing|first=Florian|date=December 2017|title=An Introduction to QBF Solving|url=http://www.florianlonsing.com/talks/Lonsing-SAT-SMT-school-india-2017.pdf|access-date=29 May 2021|website=www.florianlonsing.com}}</ref> thus, as compared to SAT solving, which has been under development since the 1960s, QBF is a relatively young field of research as of 2017.<ref name=":4" />{{Weasel inline|date=May 2021}}

Some prominent QBF solvers include:

* CADET, which solves quantified Boolean formulas restricted to one quantifier alternation (with the ability to compute [[Skolem normal form|Skolem functions]]), based on ''incremental determinization''{{Clarify|date=May 2021}} and with the ability to prove its answers.<ref>{{Citation|last=Rabe|first=Markus N.|title=MarkusRabe/cadet|date=2021-04-15|url=https://github.com/MarkusRabe/cadet|access-date=2021-05-06}}</ref>
* CAQE - a CEGAR-based solver for quantified Boolean formulas; winner of the recent editions of QBFEVAL as of 2021.<ref>{{Citation|last=Tentrup|first=Leander|title=ltentrup/caqe|date=2021-05-06|url=https://github.com/ltentrup/caqe|access-date=2021-05-06}}</ref>{{not in ref|date=December 2024}}
* DepQBF - a search-based solver for quantified Boolean formulas<ref>{{Cite web|title=DepQBF Solver|url=https://lonsing.github.io/depqbf/|access-date=2021-05-06|website=lonsing.github.io}}</ref>
*sKizzo - the first solver ever to use symbolic skolemization, extract certificates of satisfiability, use a hybrid inference engine, implement abstract branching, deal with limited quantifiers, and enumerate valid assignments, and winner of QBFEVAL 2005, 2006, and 2007.<ref>{{Cite web|title=sKizzo - a QBF solver|url=http://www.skizzo.site/|access-date=2021-05-06|website=www.skizzo.site}}</ref>

== Applications ==
{{Expand section|date=May 2021}}
QBF solvers can be applied to planning (in artificial intelligence), including safe planning; the latter is critical in applications of robotics.<ref name=":5">{{Cite conference|last1=Shukla|first1=Ankit|last2=Biere|first2=Armin|last3=Seidl|first3=Martina|last4=Pulina|first4=Luca|date=2019|title=A Survey on Applications of Quantified Boolean Formulas|url=http://fmv.jku.at/seidl/papers/shukla19.pdf|conference=2019 IEEE 31st International Conference on Tools for Artificial Intelligence|pages=78–84|doi=10.1109/ICTAI.2019.00020|access-date=29 May 2021}}</ref> QBF solvers can also be applied to [[Model checking|bounded model checking]] as they provide a shorter encoding than would be needed for a SAT-based solver.<ref name=":5" />

The evaluation of a QBF can be seen as a [[two-player game]] between a player who controls existentially quantified variables and a player who controls universally quantified variables. This makes QBFs suitable for encoding [[reactive synthesis]] problems.<ref name=":5" /> Similarly, QBF solvers can be used to model adversarial games in [[game theory]]. For example, QBF solvers can be used to find [[Winning strategy|winning strategies]] for games of [[Geography (game)|geography]], which can then be automatically played interactively.<ref>{{Cite thesis|last=Shen|first=Zhihe|title=Using QBF Solvers to Solve Games and Puzzles|publisher=Boston College|url=https://www.bc.edu/content/dam/bc1/schools/mcas/cs/pdf/honors-thesis/sample5.pdf}}</ref>

QBF solvers can be used for [[formal equivalence checking]], and can also be used to synthesize Boolean functions.<ref name=":5" />

Other types of problems that can be encoded as QBFs include:

* Detecting whether a clause in an unsatisfiable formula in [[conjunctive normal form]] belongs to some minimally unsatisfiable subset<ref name=":4" /><ref name=":6">{{Cite conference|last1=Janota|first1=Mikoláš|last2=Marques-Silva|first2=Joao|date=2011|title=On Deciding MUS Membership with QBF|url=https://www.researchgate.net/publication/227320440|conference=Principles and Practice of Constraint Programming – CP 2011|volume=6876|pages=414–428|doi=10.1007/978-3-642-23786-7_32|isbn=978-3-642-23786-7}}</ref> and whether a clause in a satisfiable formula belongs to a maximally satisfiable subset<ref name=":6" />
* Encodings of conformant planning<ref name=":4" />{{Clarify|date=May 2021}}
* ASP-related problems<ref name=":4" />{{Clarify|date=May 2021}}
* Abstract argumentation<ref name=":4" />{{Clarify|date=May 2021}}
* [[Linear temporal logic]] model checking<ref name=":4" />{{Clarify|date=May 2021}}
* [[Nondeterministic finite automaton]] language inclusion<ref name=":4" />{{Clarify|date=May 2021}}
* Synthesis and reliability of distributed systems<ref name=":4" />{{Clarify|date=May 2021}}

== Extensions ==
In QBFEVAL 2020, a "DQBF Track" was introduced where instances were allowed to have [[Henkin quantifier]]s (expressed in DQDIMACS format).<ref name=":3" />

== PSPACE-completeness ==

The TQBF language serves in [[computational complexity theory|complexity theory]] as the canonical [[PSPACE-complete]] problem. Being PSPACE-complete means that a language is in PSPACE and that the language is also [[PSPACE-hard]].  The algorithm above shows that TQBF is in PSPACE.
Showing that TQBF is PSPACE-hard requires showing that any language in the complexity class PSPACE can be reduced to TQBF in polynomial time. I.e.,

:<math>\forall L\in \mathsf{PSPACE}, L\leq_p \mathrm{TQBF}.</math>

This means that, for a PSPACE language L, whether an input {{mvar|x}} is in L can be decided by checking whether <math>f(x)</math> is in TQBF, for some function {{mvar|f}} that is required to run in polynomial time (relative to the length of the input). Symbolically,

:<math>x\in L\iff f(x)\in \mathrm{TQBF}.</math>

Proving that TQBF is PSPACE-hard, requires specification of {{mvar|f}}.

So, suppose that L is a PSPACE language. This means that L can be decided by a polynomial space deterministic [[Turing machine]] (DTM). This is very important for the reduction of L to TQBF, because the configurations of any such Turing Machine can be represented as Boolean formulas, with Boolean variables representing the state of the machine as well as the contents of each cell on the Turing Machine tape, with the position of the Turing Machine head encoded in the formula by the formula's ordering. In particular, our reduction will use the variables <math>c_1</math> and <math>c_2</math>, which represent two possible configurations of the DTM for L, and a natural number t, in constructing a QBF <math>\phi_{c_1,c_2,t}</math> which is true if and only if the DTM for L can go from the configuration encoded in <math>c_1</math> to the configuration encoded in <math>c_2</math> in no more than t steps. The function {{mvar|f}}, then, will construct from the DTM for L a QBF <math>\phi_{c_\text{start},c_\text{accept},T}</math>, where <math>c_{start}</math> is the DTM's starting configuration, <math>c_\text{accept}</math> is the DTM's accepting configuration, and T is the maximum number of steps the DTM could need to move from one configuration to the other. We know that ''T'' = [[Big-o notation|''O''(exp(''n''<sup>k</sup>))]] for some ''k'', where ''n'' is the length of the input, because this bounds the total number of possible configurations of the relevant DTM. Of course, it cannot take the DTM more steps than there are possible configurations to reach <math>c_\mathrm{accept}</math> unless it enters a loop, in which case it will never reach <math>c_\mathrm{accept}</math> anyway.

At this stage of the proof, we have already reduced the question of whether an input formula {{mvar|w}} (encoded, of course, in <math>c_\text{start}</math>) is in L to the question of whether the QBF <math>\phi_{c_\text{start},c_\text{accept},T}</math>, i.e., <math>f(w)</math>, is in TQBF. The remainder of this proof proves that {{mvar|f}} can be computed in polynomial time.

For <math>t=1</math>, computation of <math>\phi_{c_1,c_2,t}</math> is straightforward—either one of the configurations changes to the other in one step or it does not. Since the Turing Machine that our formula represents is deterministic, this presents no problem.

For <math>t>1</math>, computation of <math>\phi_{c_1,c_2,t}</math> involves a recursive evaluation, looking for a so-called "middle point" <math>m_1</math>. In this case, we rewrite the formula as follows:

:<math>\phi_{c_1,c_2,t}=\exists m_1(\phi_{c_1,m_1,\lceil t/2\rceil}\wedge\phi_{m_1,c_2,\lceil t/2\rceil}).</math>

This converts the question of whether <math>c_1</math> can reach <math>c_2</math> in t steps to the question of whether <math>c_1</math> reaches a middle point <math>m_1</math> in <math>t/2</math> steps, which itself reaches <math>c_2</math> in <math>t/2</math> steps. The answer to the latter question of course gives the answer to the former.

Now, t is only bounded by T, which is exponential (and so not polynomial) in the length of the input. Additionally, each recursive layer virtually doubles the length of the formula. (The variable <math>m_1</math> is only one midpoint—for greater t, there are more stops along the way, so to speak.) So the time required to recursively evaluate <math>\phi_{c_1,c_2,t}</math> in this manner could be exponential as well, simply because the formula could become exponentially large. This problem is solved by universally quantifying using variables <math>c_3</math> and <math>c_4</math> over the configuration pairs (e.g., <math>\{ (c_1,m_1),(m_1,c_2)\}</math>), which prevents the length of the formula from expanding due to recursive layers. This yields the following interpretation of <math>\phi_{c_1,c_2,t}</math>:

:<math>\phi_{c_1,c_2,t}=\exists m_1\forall (c_3,c_4)\in \{ (c_1,m_1),(m_1,c_2)\}(\phi_{c_3,c_4,\lceil t/2\rceil}).</math>

This version of the formula can indeed be computed in polynomial time, since any one instance of it can be computed in polynomial time. The universally quantified ordered pair simply tells us that whichever choice of <math>(c_3,c_4)</math> is made, <math>\phi_{c_1,c_2,t}\iff\phi_{c_3,c_4,\lceil t/2\rceil}</math>.

Thus, <math>\forall L\in \mathsf{PSPACE}, L\leq_p \mathrm{TQBF}</math>, so TQBF is PSPACE-hard. Together with the above result that TQBF is in PSPACE, this completes the proof that TQBF is a PSPACE-complete language.

(This proof follows Sipser 2006 pp.&nbsp;310–313 in all essentials. Papadimitriou 1994 also includes a proof.)

==Miscellany==

*One important subproblem in TQBF is the [[Boolean satisfiability problem]].  In this problem, you wish to know whether a given Boolean formula <math>\phi</math> can be made true with some assignment of variables.  This is equivalent to the TQBF using only existential quantifiers: <math display="block">\exists x_1 \cdots \exists x_n \phi(x_1, \ldots, x_n)</math> This is also an example of the larger result NP ⊆ PSPACE which follows directly from the observation that a polynomial time verifier for a proof of a language accepted by a NTM ([[Non-deterministic Turing machine]]) requires polynomial space to store the proof.
*Any class in the [[polynomial hierarchy]] ([[PH (complexity)|PH]]) has TQBF as a hard problem. In other words, for the class comprising all languages L for which there exists a poly-time TM V, a verifier, such that for all input x and some constant i, <math display="block">x \in L \Leftrightarrow \exists y_1 \forall y_2 \cdots Q_i y_i \  V(x,y_1,y_2,\dots,y_i)\ =\ 1</math> which has a specific QBF formulation that is given as <math display="block">\exists \phi</math>  such that <math>\exists \vec{x_1} \forall \vec{x_2} \cdots Q_i \vec{x_i}\  \phi(\vec{x_1},\vec{x_2},\dots,\vec{x_i})\ =\ 1</math> where the <math>\vec{x_i}</math>'s are vectors of Boolean variables.
*It is important to note that while TQBF the language is defined as the collection of true quantified Boolean formulas, the abbreviation TQBF is often used (even in this article) to stand for a totally quantified Boolean formula, often simply called a QBF (quantified Boolean formula, understood as "fully" or "totally" quantified). It is important to distinguish contextually between the two uses of the abbreviation TQBF in reading the literature.
*A TQBF can be thought of as a game played between two players, with alternating moves. Existentially quantified variables are equivalent to the notion that a move is available to a player at a turn. Universally quantified variables mean that the outcome of the game does not depend on what move a player makes at that turn. Also, a TQBF whose first quantifier is existential corresponds to a [[formula game]] in which the first player has a winning strategy.
*A TQBF for which the quantified formula is in [[conjunctive normal form|2-CNF]] may be solved in [[linear time]], by an algorithm involving [[strongly connected component|strong connectivity analysis]] of its [[implication graph]]. The [[2-satisfiability]] problem is a special case of TQBF for these formulas, in which every quantifier is existential.<ref>{{Cite journal
| last1 = Krom | first1 = Melven R. 
| title = The Decision Problem for a Class of First-Order Formulas in Which all Disjunctions are Binary 
| journal = Zeitschrift für Mathematische Logik und Grundlagen der Mathematik 
| volume = 13 
| pages = 15–20 
| year = 1967 
| issue = 1–2 
| doi = 10.1002/malq.19670130104
}}.</ref><ref>{{Cite journal
 | last1 = Aspvall | first1 = Bengt
 | last2 = Plass | first2 = Michael F.
 | authorlink3 = Robert Tarjan | last3 = Tarjan | first3 = Robert E.
 | title = A linear-time algorithm for testing the truth of certain quantified boolean formulas
 | url = http://www.math.ucsd.edu/~sbuss/CourseWeb/Math268_2007WS/2SAT.pdf
 | journal = [[Information Processing Letters]]
 | volume = 8 | issue = 3 | pages = 121–123 | year = 1979
 | doi = 10.1016/0020-0190(79)90002-4
 }}.</ref>
*There is a systematic treatment of restricted versions of quantified Boolean formulas (giving Schaefer-type classifications) provided in an expository paper by Hubie Chen.<ref>{{cite journal|first1=Hubie|last1=Chen|date=December 2009|title=A Rendezvous of Logic, Complexity, and Algebra|journal=ACM Computing Surveys|publisher=ACM|doi=10.1145/1592451.1592453|pages=1–32 |volume=42|issue=1|arxiv=cs/0611018|s2cid=11975818}}</ref>
*Planar TQBF, generalizing [[Planar SAT]], was proved PSPACE-complete by D. Lichtenstein.<ref>{{Cite journal|last=Lichtenstein|first=David|date=1982-05-01|title=Planar Formulae and Their Uses|url=https://epubs.siam.org/doi/10.1137/0211025|journal=SIAM Journal on Computing|volume=11|issue=2|pages=329–343|doi=10.1137/0211025|s2cid=207051487 |issn=0097-5397}}</ref>

== Notes and references ==
<references/>
* Fortnow & Homer (2003) provides some historical background for PSPACE and TQBF.
* Zhang (2003) provides some historical background of Boolean formulas.
* Arora, Sanjeev. (2001). [http://www.cs.princeton.edu/~arora/pubs/aroracom.ps ''COS 522: Computational Complexity''].  Lecture Notes, Princeton University.  Retrieved October 10, 2005.
* Fortnow, Lance & Steve Homer. (2003, June).  [https://lance.fortnow.com/papers/files/history.pdf A short history of computational complexity].  ''Bulletin of the European Association for Theoretical Computer Science'', The Computational Complexity Column, 80. Retrieved May 14, 2024.
* Papadimitriou, C. H.  (1994).  ''Computational Complexity.''  Reading: Addison-Wesley.
* Sipser, Michael.  (2006).  ''Introduction to the Theory of Computation.''  Boston: Thomson Course Technology.
* Zhang, Lintao. (2003).  [http://research.microsoft.com/users/lintaoz/thesis_lintao_zhang.pdf ''Searching for truth: Techniques for satisfiability of Boolean formulas''].  Retrieved October 10, 2005.

== See also ==
* [[Cook–Levin theorem]], stating that [[Boolean satisfiability problem|SAT]] is [[NP-complete]]
* [[Generalized geography]]

==External links==
* The Quantified Boolean Formulas Library [http://www.qbflib.org (QBFLIB)]
* [http://fmv.jku.at/qbf15/ International Workshop on Quantified Boolean Formulas]

[[Category:Satisfiability problems]]
[[Category:Boolean algebra]]
[[Category:PSPACE-complete problems]]