1 Introduction
Lifschitz, Tang, and Turner [23] recently extended the answer set semantics [12] to a class of logic programs in which arbitrarily nested formulas, formed from literals using negation as failure, conjunction, and disjunction, constitute the heads and bodies of rules. These socalled nested logic programs generalise the wellknown classes of normal, generalised, extended, and disjunctive logic programs, respectively. Despite their syntactically much more restricted format, the latter classes are well recognised as important tools for knowledge representation and reasoning. This is reflected by the fact that several practicably relevant applications have been developed recently using these types of programs (cf., e.g., [21, 3, 11, 16]), which in turn is largely fostered by the availability of efficient solvers for the answer set semantics, most notably DLV [8, 9] and Smodels [25].
In this paper, we are interested in utilising these highly performant solvers for interpreting nested logic programs. We address this problem by providing a translation of nested logic programs into disjunctive logic programs. In contrast to previous work, our translation is guaranteed to be polynomial in time and space, as suggested by related complexity results [30]. More specifically, we provide a translation, , from nested logic programs into disjunctive logic programs possessing the following properties:

maps nested logic programs over an alphabet into disjunctive logic programs over an alphabet , where ;

the size of is polynomial in the size of ;

is faithful, i.e., for each program over alphabet , there is a onetoone correspondence between the answer sets of and sets of form , where is an answer set of ; and

is modular, i.e., , for each program .
Moreover, we have implemented translation , serving as a frontend for the logic programming system DLV.
The construction of relies on the introduction of new labels, abbreviating subformula occurrences. This technique is derived from structurepreserving normal form translations [34, 31], frequently employed in the context of automated deduction (cf. [1] for an overview). We use here a method adapted from a structurepreserving translation for intuitionistic logic as described in [24].
Regarding the faithfulness of , we actually provide a somewhat stronger condition, referred to as strong faithfulness, expressing that, for any programs and over alphabet , there is a onetoone correspondence between the answer sets of and sets of form , where is an answer set of . This condition means that we can add to a given program any nested program and still recover the answer sets of the combined program from ; in particular, for any nested logic program , we may choose to translate, in a semanticspreserving way, only an arbitrary program part and leave the remaining part unchanged. For instance, if is already a disjunctive logic program, we do not need to translate it again into another (equivalent) disjunctive logic program. Strong faithfulness is closely related to the concept of strong equivalence [22] (see below).
In order to have a sufficiently general setting for our purposes, we base our investigation on equilibrium logic [26], a generalisation of the answer set semantics for nested logic programs. Equilibrium logic is a form of minimalmodel reasoning in the logic of hereandthere, which is intermediate between classical logic and intuitionistic logic (the logic of hereandthere is also known as Gödel’s threevalued logic in view of [14]). As shown in [26, 27, 22], logic programs can be viewed as a special class of formulas in the logic of hereandthere such that, for each program , the answer sets of are given by the equilibrium models of , where the latter is viewed as a set of formulas in the logic of hereandthere.
The problem of implementing nested logic programs has already been addressed in [30], where (lineartime constructible) encodings of the basic reasoning tasks associated with this language into quantified Boolean formulas are described. These encodings provide a straightforward implementation for nested logic programs by appeal to offtheshelf solvers for quantified Boolean formulas (like, e.g., the systems proposed in [4, 10, 13, 19, 20, 32]). Besides the encodings into quantified Boolean formulas, a further result of [30] is that nested logic programs possess the same worstcase complexity as disjunctive logic programs, i.e., the main reasoning tasks associated with nested logic programs lie at the second level of the polynomial hierarchy. From this result it follows that nested logic programs can in turn be efficiently reduced to disjunctive logic programs. Hence, given such a reduction, solvers for the latter kinds of programs, like, e.g., DLV or Smodels, can be used to compute the answer sets of nested logic programs. The main goal of this paper is to construct a reduction of this type.
Although results by Lifschitz, Tang, and Turner [23] (together with transformation rules given in [18]) provide a method to translate nested logic programs into disjunctive ones, that approach suffers from the drawback of an exponential blowup of the resulting disjunctive logic programs in the worst case. This is due to the fact that the “languagepreserving” nature of that translation relies on distributivity laws yielding an exponential increase of program size whenever the given program contains rules whose heads are in disjunctive normal form or whose bodies are in conjunctive normal form, and the respective expressions are not simple disjunctions or conjunctions of literals. Our translation, on the other hand, is always polynomial in the size of its input program.
Finally, we mention that structurepreserving normal form translations in the logic of hereandthere are also studied, yet in much more general settings, by Baaz and Fermüller [2] as well as by Hähnle [15]; there, whole classes of finitevalued Gödel logics are investigated. Unfortunately, these normal form translations are not suitable for our purposes, because they do not enjoy the particular form of programs required here.
2 Preliminaries
We deal with propositional languages and use the logical symbols , , , , , and to construct formulas in the standard way. We write to denote a language over an alphabet of propositional variables or atoms. Formulas are denoted by Greek lowercase letters (possibly with subscripts). As usual, literals are formulas of form or , where is some variable or one of .
Besides the semantical concepts introduced below, we also make use of the semantics of classical propositional logic. By a classical interpretation, , we understand a set of variables. Informally, a variable is true under iff . The truth value of a formula under interpretation , in the sense of classical propositional logic, is determined in the usual way.
2.1 Logic Programs
The central objects of our investigation are logic programs with nested expressions, introduced by Lifschitz et al. [23]. These kinds of programs generalise normal logic programs by allowing bodies and heads of rules to contain arbitrary Boolean formulas. For reasons of simplicity, we deal here only with languages containing one kind of negation, however, corresponding to default negation. The extension to the general case where strong negation is also permitted is straightforward and proceeds in the usual way.
We start with some basic notation. A formula whose sentential connectives comprise only , , or is called an expression. A rule,
, is an ordered pair of form
where and are expressions. is called the body of and is the head of . We say that is a generalised disjunctive rule if is a conjunction of literals and is a disjunction of literals; is a disjunctive rule iff it is a generalised disjunctive rule containing no negated atom in its head; finally, if is a rule containing no negation at all, then is called basic. A nested logic program, or simply a program, , is a finite set of rules. is a generalised disjunctive logic program iff it contains only generalised disjunctive rules. Likewise, is a disjunctive logic program iff contains only disjunctive rules, and is basic iff each rule in is basic. We say that is a program over alphabet iff all atoms occurring in are from . The set of all atoms occurring in program is denoted by . We use to denote the class of all nested logic programs over alphabet ; furthermore, stands for the subclass of containing all disjunctive logic programs over ; and is the class of all generalised disjunctive logic programs over . Further classes of programs are introduced in Section 4.
In what follows, we associate to each rule a corresponding formula and, accordingly, to each program a corresponding set of formulas .
Let be a basic program over and a (classical) interpretation. We say that is a model of iff it is a model of the associated set of formulas. Furthermore, given an (arbitrary) program over , the reduct, , of with respect to is the basic program obtained from by replacing every occurrence of an expression in which is not in the scope of any other negation by if is true under , and by otherwise. is an answer set (or stable model) of iff it is a minimal model (with respect to set inclusion) of the reduct . The collection of all answer sets of is denoted by .
Two logic programs, and , are equivalent iff they possess the same answer sets. Following Lifschitz et al. [22], we call and strongly equivalent iff, for every program , and are equivalent.
2.2 Equilibrium Logic
Equilibrium logic is an approach to nonmonotonic reasoning that generalises the answer set semantics for logic programs. We use this particular formalism because it offers a convenient logical language for dealing with logic programs under the answer set semantics. It is defined in terms of the logic of hereandthere, which is intermediate between classical logic and intuitionistic logic. Equilibrium logic was introduced in [26] and further investigated in [27]; proof theoretic studies of the logic can be found in [29, 28].
Generally speaking, the logic of hereandthere is an important tool for analysing various properties of logic programs. For instance, as shown in [22], the problem of checking whether two logic programs are strongly equivalent can be expressed in terms of the logic of hereandthere (cf. Proposition 2 below).
The semantics of the logic of hereandthere is defined by means of two worlds, and , called “here” and “there”. It is assumed that there is a total order, , defined between these worlds such that is reflexive and . As in ordinary Kripke semantics for intuitionistic logic, we can imagine that in each world a set of atoms is verified and that, once verified “here”, an atom remains verified “there”.
Formally, by an HTinterpretation, , we understand an ordered pair of sets of atoms such that . We say that is an HTinterpretation over if . The set of all HTinterpretations over is denoted by . An HTinterpretation is total if .
The truth value, , of a formula at a world in an HTinterpretation is recursively defined as follows:

if , then ;

if , then ;

if is an atom, then if , otherwise ;

if , then if, for every world with , , otherwise ;

if , then if and , otherwise ;

if , then if or , otherwise ;

if , then if for every world with , or , otherwise .
We say that is true under in iff , otherwise is false under in . An HTinterpretation satisfies , or is an HTmodel of , iff . If is true under any HTinterpretation, then is valid in the logic of hereandthere, or simply HTvalid.
Let be a set of formulas. An HTinterpretation is an HTmodel of iff is an HTmodel of each element of . We say that is an HTmodel of a program iff is an HTmodel of .
Two sets of formulas are equivalent in the logic of hereandthere, or HTequivalent, iff they possess the same HTmodels. Two formulas, and , are HTequivalent iff the sets and are HTequivalent.
It is easily seen that any HTvalid formula is valid in classical logic, but the converse does not always hold. For instance, and are valid in classical logic but not in the logic of hereandthere as the pair is not an HTmodel for either of these formulas.
Equilibrium logic can be seen as a particular type of reasoning with minimal HTmodels. Formally, an equilibrium model of a formula is a total HTinterpretation such that (i) is an HTmodel of , and (ii) for every proper subset of , is not an HTmodel of .
The following result establishes the close connection between equilibrium models and answer sets, showing that answer sets are actually a special case of equilibrium models:
Moreover, HTequivalence was shown to capture the notion of strong equivalence between logic programs:
Proposition 2 ([22])
Let and be programs, and let , for . Then, and are strongly equivalent iff and are equivalent in the logic of hereandthere.
Recently, de Jongh and Hendriks [5] have extended Proposition 2 by showing that for nested programs strong equivalence is characterised precisely by equivalence in all intermediate logics lying between hereandthere (upper bound) and the logic KC of weak excluded middle (lower bound) which is axiomatised by intuitionistic logic together with the schema .
We require the following additional concepts. By an HTliteral, , we understand a formula of form , , or , where is a propositional atom or one of , . Furthermore, a formula is in hereandthere negational normal form, or HTNNF, if it is made up of HTliterals, conjunctions and disjunctions. Likewise, we say that a program is in HTNNF iff all heads and bodies of rules in the program are in HTNNF.
Following [23], every expression can effectively be transformed into an expression in HTNNF possessing the same HTmodels as . In fact, we have the following property:
Proposition 3
Every expression is HTequivalent to an expression in HTNNF, where is constructible in polynomial time from , satisfying the following conditions, for each expression :

, if is an HTliteral;

;

, for ;

;

.
3 Faithful Translations
Next, we introduce the general requirements we impose on our desired translation from nested logic programs into disjunctive logic programs. The following definition is central:
Definition 1
Let and be two alphabets such that , and, for , let be a class of nested logic programs closed under unions.^{1}^{1}1A class of sets is closed under unions providing implies . Then, a function is

polynomial iff, for all programs , the time required to compute is polynomial in the size of ;

faithful iff, for all programs ,

strongly faithful iff, for all programs and all programs ,
and

modular iff, for all programs ,
In view of the requirement that , the general functions considered here may introduce new atoms. Clearly, if the given function is polynomial, the number of newly introduced atoms is also polynomial. Faithfulness guarantees that we can recover the stable models of the input program from the translated program. Strong faithfulness, on the other hand, states that we can add to a given program any nested logic program and still retain, up to the original language, the semantics of the combined program from . Finally, modularity enforces that we can translate programs rule by rule.
It is quite obvious that any strongly faithful function is also faithful. Furthermore, strong faithfulness of function implies that, for a given program , we can translate any program part of whilst leaving the remaining part unchanged, and determine the semantics of from . As well, for any function of form , strong faithfulness of is equivalent to the condition that and are strongly equivalent, for any . Hence, strong faithfulness generalises strong equivalence.
Following [17, 18], we say that a function as in Definition 1 is PFM, or that is a PFMfunction, iff it is polynomial, faithful, and modular. Analogously, we call PSM, or a PSMfunction, iff it is polynomial, strongly faithful, and modular.
It is easy to see that the composition of two PFMfunctions is again a PFMfunction; and likewise for PSMfunctions. Furthermore, since any PSMfunction is also PFM, in the following we focus on PSMfunctions. In fact, in the next section, we construct a function (where is a suitable extension of ) which is PSM.
Next, we discuss some sufficient conditions guaranteeing that certain classes of functions are strongly faithful. We start with the following concept.
Definition 2
Let be a function such that , and let be the class of all HTinterpretations over .
Then, the function is called a associated HTembedding iff, for each HTinterpretation over , each , and each , and , where .
Furthermore, for any and any , we define .
Intuitively, a associated HTembedding transforms HTinterpretations over the input alphabet of into HTinterpretations over the output alphabet of such that the truth values of the atoms in are retained. The following definition strengthens these kinds of mappings:
Definition 3
Let be as in Definition 2, and let be a associated HTembedding. We say that is a associated HThomomorphism if, for any and any , the following conditions hold:

is an HTmodel of iff is an HTmodel of ;

is total iff is total;

if and are HTmodels of , then and holds precisely if and , for and ; and

an HTinterpretation over is an HTmodel of only if .
Roughly speaking, associated HThomomorphisms retain the relevant properties of HTinterpretations for being equilibrium models with respect to transformation . More specifically, the first three conditions take semantical and settheoretical properties into account, respectively, whilst the last one expresses a specific “closure condition”. The inclusion of the latter requirement is explained by observation that the first three conditions alone are not sufficient to exclude the possibility that there may exist some equilibrium model of such that is not an equilibrium model of . The reason for this is that the set , comprising the images of all HTinterpretations over under with respect to program , does, in general, not cover all HTinterpretations over . Hence, for a general associated HTembedding , there may exist some HTmodel of which is not included in preventing from being an equilibrium model of albeit is an equilibrium model of . The addition of the last condition in Definition 3, however, excludes this possibility, ensuring that all relevant HTinterpretations required for checking whether is an equilibrium model of are indeed considered. The following result can be shown:
Lemma 1
For any function with , if there is some associated HThomomorphism, then is faithful.
From this, we obtain the following property:
Theorem 1
Under the circumstances of Lemma 1, if is modular and there is some associated HThomomorphism, then is strongly faithful.
We make use of the last result for showing that the translation from nested logic programs into disjunctive logic programs, as discussed next, is PSM.
4 Main Construction
In this section, we show how logic programs with nested expressions can be efficiently mapped to disjunctive logic programs, preserving the semantics of the respective programs. Although results by Lifschitz et al. [23] already provide a reduction of nested logic programs into disjunctive ones (by employing additional transformation steps as given in [18]), that method is exponential in the worst case. This is due to the fact that the transformation relies on distributive laws, yielding an exponential increase of program size whenever the given program contains rules whose heads are in disjunctive normal form or whose bodies are in conjunctive normal form, and the respective expressions are not simple disjunctions or conjunctions of HTliterals.
To avoid such an exponential blowup, our technique is based on the introduction of new atoms, called labels, abbreviating subformula occurrences. This method is derived from structurepreserving normal form translations [34, 31]
, which are frequently applied in the context of automated reasoning (cf., e.g.,
[2, 15] for general investigations about structurepreserving normal form translation in finitevalued Gödel logics, and [6, 7] for prooftheoretical issues of such translations for classical and intuitionistic logic). In contrast to theorem proving applications, where the main focus is to provide translations which are satisfiability (or, alternatively, validity) equivalent, here we are interested in somewhat stronger equivalence properties, viz. in the reconstruction of the answer sets of the original programs from the translated ones, which involves also an adequate handling of additional minimality criteria.The overall structure of our translation can be described as follows. Given a nested logic program , we perform the following steps:

For each , transform and into HTNNF;

translate the program into a program containing only rules with conjunctions of HTliterals in their bodies and disjunctions of HTliterals in their heads;

eliminate double negations in bodies and heads; and

transform the resulting program into a disjunctive logic program, i.e., make all heads negation free.
Steps 1 and 3 are realised by using properties of logic programs as described in [23]; Step 2 represents the central part of our construction; and Step 4 exploits a procedure due to Janhunen [18].
In what follows, for any alphabet , we define the following new and disjoint alphabets:

a set of labels; and

a set of atoms representing negated atoms.
Furthermore, is the class of all nested logic programs over which are in HTNNF, and is the class of all programs over which are defined like generalised logic programs, except that HTliterals may occur in rules instead of ordinary literals.
We assume that for each of the above construction stages, Step is realized by a corresponding function (). The overall transformation is then described by the composed function , which is a mapping from the set of all programs over into the set of all disjunctive logic program over . More specifically,
translates any nested logic program over into a nested program in HTNNF. Translation
takes these programs and transforms their rules into simpler ones as described by Step 2, introducing new labels. These rules are then fed into mapping
yielding generalised disjunctive logic programs. Finally,
outputs standard disjunctive logic programs.
As argued in the following, each of these functions is PSM; hence, the overall function is PSM as well.
We continue with the technical details, starting with .
For the first step, we use the procedure from Proposition 3 to transform heads and bodies of rules into HTNNF.
Definition 4
The function is defined by setting
for any .
Since, for each expression , is constructible in polynomial time and is HTequivalent to (cf. Proposition 3), the following result is immediate:
Lemma 2
The translation is PSM.
The second step is realised as follows:
Definition 5
The function is defined by setting, for any ,
where is constructed as follows:

for each HTliteral occurring in , add the two rules

for each expression occurring in , add the three rules
and

for each expression occurring in , add the three rules
This definition is basically an adaption of a structurepreserving normal form translation for intuitionistic logic, as described in [24].
It is quite obvious that is modular and, for each , we have that is constructible in polynomial time. In order to show that is strongly faithful, we define a suitable HThomomorphism as follows.
Sublemma 1
Let be the translation defined above, and let result from by setting if and if .
Then, the function , defined as
is a associated HThomomorphism, where
if , and otherwise, for any and any HTinterpretation over .
Hence, according to Theorem 1, is strongly faithful. As a consequence, is strongly faithful as well. Thus, the following holds:
Lemma 3
The function is PSM.
For Step , we use a method due to Lifschitz et al. [23] for eliminating double negations in heads and bodies of rules. The corresponding function is defined as follows:
Definition 6
Let be the function obtained by replacing, for each given program , each rule of form
as well as each rule of form
where and are expressions and .
As shown in [23], performing replacements of the above type results in programs which are strongly equivalent to the original programs. In fact, it is easy to see that such replacements yield transformed programs which are strongly faithful to the original ones. Since these transformations are clearly modular and constructible in polynomial time, we obtain that is PSM.
Lemma 4
The function is PSM.
Finally, we eliminate remaining negations possibly occurring in the heads of rules. To this end, we employ a procedure due to Janhunen [18].
Definition 7
Let be the function defined by setting, for any program ,
where results from by replacing each occurrence of a literal in the head of a rule in by .
Janhunen showed that replacements of the above kind lead to a transformation which is PFM. As a matter of fact, since his notion of faithfulness is somewhat stricter than ours, the results in [18] actually imply that, for any , is given by
However, we need a stronger condition here, viz. that the above equation holds for any and any . We show this by appeal to Theorem 1.
Sublemma 2
Let be the translation defined above, and let result from by setting if and if .
Then, the function , defined as
is a associated HThomomorphism, where
if , and otherwise, for any HTinterpretation over .
Observe that, in contrast to the definition of function from Sublemma 1, here the same set of newly introduced atoms is added to both worlds. As before, we obtain that is strongly faithful, and hence that is strongly faithful as well.
Lemma 5
The function is PSM.
Summarising, we obtain our main result, which is as follows:
Theorem 2
Let be the functions defined above. Then, the composed function , mapping nested logic programs over alphabet into disjunctive logic programs over alphabet , is polynomial, strongly faithful, and modular.
Since strong faithfulness implies faithfulness, we get the following corollary:
Corollary 1
For any nested logic program over , the answer sets of are in a onetoone correspondence to the answer sets of , determined by the following equation:
where .
We conclude with a remark concerning the construction of function . As pointed out previously, this mapping is based on a structurepreserving normal form translation for intuitionistic logic, as described in [24]. Besides the particular type of translation used here, there are also other, slightly improved structurepreserving normal form translations in which fewer rules are introduced, depending on the polarity of the corresponding subformula occurrences. However, although such optimised methods work in monotonic logics, they are not sufficient in the present setting. For instance, in a possible variant of translation based on the polarity of subformula occurrences, instead of introducing all three rules for an expression of form , only is used if occurs in the body of some rule, or both and are used if occurs in the head of some rule, and analogous manipulations are performed for atoms and disjunctions. Applying such an encoding to over yields a translated program possessing two answer sets, say and , such that and , although only is an answer set of .
5 Conclusion
We have developed a translation of logic programs with nested expressions into disjunctive logic programs. We have proven that our translation is polynomial, strongly faithful, and modular. This allows us to utilise offtheshelf disjunctive logic programming systems for interpreting nested logic programs. In fact, we have implemented our translation as a front end for the system DLV [8, 9]. The corresponding compiler is implemented in Prolog and can be downloaded from the Web at URL
http://www.cs.unipotsdam.de/torsten/nlp.
Our technique is based on the introduction of new atoms, abbreviating subformula occurrences. This method has its roots in structurepreserving normal form translations [34, 31], which are frequently used in automated deduction. In contrast to theorem proving applications, however, where the main focus is to provide satisfiability (or, alternatively, validity) preserving translations, we are concerned with much stronger equivalence properties, involving additional minimality criteria, since our goal is to reconstruct the answer sets of the original programs from the translated ones.
With the particular labeling technique employed here, our translation avoids the risk of an exponential blowup in the worstcase, faced by a previous approach of Lifschitz et al. [23] due to the usage of distributivity laws. However, this is not to say that our translation is always the better choice. As in classical theorem proving, it is rather a matter of experimental studies under which circumstances which approach is the more appropriate one. To this end, besides the implementation of our structural translation, we have also implemented the distributive translation into disjunctive logic programs in order to conduct experimental results. These experiments are subject to current research.
Also, we have introduced the concept of strong faithfulness, as a generalisation of (standard) faithfulness and strong equivalence. This allows us, for instance, to translate, in a semanticspreserving way, arbitrary program parts and leave the remaining program unaffected.
References
 [1] M. Baaz, U. Egly, and A. Leitsch. Normal Form Transformations. In A. Robinson and A. Voronkov, editors, Handbook of Automated Reasoning, volume I, chapter 5, pages 273–333. Elsevier Science B.V., 2001.
 [2] M. Baaz and C. G. Fermüller. ResolutionBased Theorem Proving for ManyValued Logics. Journal of Symbolic Computation, 19(4):353–391, 1995.

[3]
C. Baral and C. Uyan.
Declarative Specification and Solution of Combinatorial Auctions
Using Logic Programming.
In Proceedings of the Sixth International Conference on Logic
Programming and Nonmonotonic Reasoning (LPNMR01), volume 2173
of
Lecture Notes in Artificial Intelligence
, pages 186–199, Berlin, 2001. Springer Verlag.  [4] M. Cadoli, A. Giovanardi, and M. Schaerf. An Algorithm to Evaluate Quantified Boolean Formulae. In Proceedings of the Fifteenth National Conference on Artificial Intelligence (AAAI98), pages 262–267, Menlo Park, 1998. AAAI Press.
 [5] D. de Jongh and L. Hendriks. Characterization of Strongly Equivalent Logic Programs in Intermediate Logics. Technical report, 2001. Preprint at http://turing.wins.uva.nl/~lhendrik/.
 [6] U. Egly. On Different StructurePreserving Translations to Normal Form. Journal of Symbolic Computation, 22(2):121–142, 1996.
 [7] U. Egly. On Definitional Transformations to Normal Form for Intuitionistic Logic. Fundamenta Informaticae, 29(1,2):165–201, 1997.
 [8] T. Eiter, N. Leone, C. Mateis, G. Pfeifer, and F. Scarcello. A Deductive System for NonMonotonic Reasoning. In Proceedings of the Fourth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR97), volume 1265 of Lecture Notes in Artificial Intelligence, pages 363–374, Berlin, 1997. Springer Verlag.
 [9] T. Eiter, N. Leone, C. Mateis, G. Pfeifer, and F. Scarcello. The KR System dlv: Progress Report, Comparisons and Benchmarks. In Proceedings of the Sixth International Conference on Principles of Knowledge Representation and Reasoning (KR98), pages 406–417. Morgan Kaufmann Publishers, 1998.
 [10] R. Feldmann, B. Monien, and S. Schamberger. A Distributed Algorithm to Evaluate Quantified Boolean Formulas. In Proceedings of the Seventeenth National Conference on Artificial Intelligence (AAAI00), pages 285–290. AAAI Press, 2000.
 [11] M. Gelfond, M. Balduccini, and J. Galloway. Diagnosing Physical Systems in AProlog. In Proceedings of the Sixth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR01), volume 2173 of Lecture Notes in Artificial Intelligence, pages 213–225, Berlin, 2001. Springer Verlag.
 [12] M. Gelfond and V. Lifschitz. Classical Negation in Logic Programs and Disjunctive Databases. New Generation Computing, 9:365–385, 1991.
 [13] E. Giunchiglia, M. Narizzano, and A. Tacchella. QUBE: A System for Deciding Quantified Boolean Formulas Satisfiability. In Proceedings of the First International Joint Conference on Automated Reasoning (IJCAR01), volume 2083 of Lecture Notes in Computer Science, pages 364–369, 2001.
 [14] K. Gödel. Zum intuitionistischen Aussagenkalkül. Anzeiger der Akademie der Wissenschaften in Wien, pages 65–66, 1932.
 [15] R. Hähnle. Short Conjunctive Normal Forms in Finitely Valued Logics. Journal of Logic and Computation, 4(6):905–927, 1994.
 [16] K. Heljanko and I. Niemelä. Bounded LTL Model Checking with Stable Models. In Proceedings of the Sixth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR01), volume 2173 of Lecture Notes in Artificial Intelligence, pages 200–212, Berlin, 2001. Springer Verlag.
 [17] T. Janhunen. On the Intertranslatability of Autoepistemic, Default and Priority Logics, and Parallel Circumscription. In Proceedings of the Sixth European Workshop on Logics in Artificial Intelligence (JELIA98), volume 1489 of Lecture Notes in Artificial Intelligence, pages 216–232, Berlin, 1998. Springer Verlag.
 [18] T. Janhunen. On the Effect of Default Negation on the Expressiveness of Disjunctive Rules. In Proceedings of the Sixth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR01), volume 2173 of Lecture Notes in Artificial Intelligence, pages 93–106, Berlin, 2001. Springer Verlag.
 [19] H. KleineBüning, M. Karpinski, and A. Flögel. Resolution for Quantified Boolean Formulas. Information and Computation, 117(1):12–18, 1995.
 [20] R. Letz. Advances in Decision Procedures for Quantified Boolean Formulas. In Proceedings of the IJCAR01 Workshop on Theory and Applications of Quantified Boolean Formulas, Technical Report DII 12/01, Università degli Studi di Siena, Dipartimento di Ingegneria dell’Informazione, pages 55–64, 2001.
 [21] V. Lifschitz. Answer Set Planning. In Proceedings of the Sixteenth International Conference on Logic Programming (ICLP99), volume 1730 of Lecture Notes in Artificial Intelligence, pages 23–37, Berlin, 1999. Springer Verlag.
 [22] V. Lifschitz, D. Pearce, and A. Valverde. Strongly Equivalent Logic Programs. ACM Transactions on Computational Logic, 2(4):526–541, 2001.
 [23] V. Lifschitz, L. Tang, and H. Turner. Nested Expressions in Logic Programs. Annals of Mathematics and Artificial Intelligence, 25(34):369–389, 1999.
 [24] G. Mints. Resolution Strategies for the Intuitionistic Logic. In B. Mayoh, E. Tyugu, and J. Penjaam, editors, Constraint Programming: NATO ASI Series, pages 282–304. Springer Verlag, 1994.
 [25] I. Niemelä and P. Simons. Smodels: An Implementation of the Stable Model and WellFounded Semantics for Normal Logic Programs. In Proceedings of the Fourth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR97), volume 1265 of Lecture Notes in Artificial Intelligence, pages 420–429, Berlin, 1997. Springer Verlag.
 [26] D. Pearce. A New Logical Characterisation of Stable Models and Answer Sets. In NonMonotonic Extensions of Logic Programming, pages 57–70. Springer Verlag, 1997.
 [27] D. Pearce. From Here to There: Stable Negation in Logic Programming. In What is Negation? Kluwer, 1999.
 [28] D. Pearce, I. de Guzmán, and A. Valverde. A Tableau Calculus for Equilibrium Entailment. In Proceedings of the Ninth International Conference on Automated Reasoning with Analytic Tableaux and Related Methods (TABLEAUX00), volume 1847 of Lecture Notes in Artificial Intelligence, pages 352–367, Berlin, 2000. Springer Verlag.
 [29] D. Pearce, I. de Guzmán, and A. Valverde. Computing Equilibrium Models Using Signed Formulas. In Proceedings of the First International Conference on Computational Logic (CL00), volume 1861 of Lecture Notes in Computer Science, pages 688–702, Berlin, 2000. Springer Verlag.
 [30] D. Pearce, H. Tompits, and S. Woltran. Encodings for Equilibrium Logic and Logic Programs with Nested Expressions. In Progress in Artificial Intelligence: Proceedings of the Tenth Portuguese Conference on Artificial Intelligence (EPIA01), volume 2258 of Lecture Notes in Artificial Intelligence, pages 306–320, Berlin, 2001. Springer Verlag.
 [31] D. A. Plaisted and S. Greenbaum. A Structure Preserving Clause Form Translation. Journal of Symbolic Computation, 2(3):293–304, 1986.
 [32] J. Rintanen. Improvements to the Evaluation of Quantified Boolean Formulae. In Proceedings of the Sixteenth International Joint Conference on Artificial Intelligence (IJCAI99), pages 1192–1197. Morgan Kaufmann Publishers, 1999.
 [33] J. Siekmann and G. Wrightson, editors. Automation of Reasoning: Classical Papers in Computational Logic 1967–1970, volume 2. SpringerVerlag, 1983.
 [34] G. Tseitin. On the Complexity of Proofs in Propositional Logics. Seminars in Mathematics, 8, 1970. Reprinted in [33].
Comments
There are no comments yet.