A Polynomial Translation of Logic Programs with Nested Expressions into Disjunctive Logic Programs: Preliminary Report

07/19/2002 ∙ by David Pearce, et al. ∙ Universität Potsdam 0

Nested logic programs have recently been introduced in order to allow for arbitrarily nested formulas in the heads and the bodies of logic program rules under the answer sets semantics. Nested expressions can be formed using conjunction, disjunction, as well as the negation as failure operator in an unrestricted fashion. This provides a very flexible and compact framework for knowledge representation and reasoning. Previous results show that nested logic programs can be transformed into standard (unnested) disjunctive logic programs in an elementary way, applying the negation as failure operator to body literals only. This is of great practical relevance since it allows us to evaluate nested logic programs by means of off-the-shelf disjunctive logic programming systems, like DLV. However, it turns out that this straightforward transformation results in an exponential blow-up in the worst-case, despite the fact that complexity results indicate that there is a polynomial translation among both formalisms. In this paper, we take up this challenge and provide a polynomial translation of logic programs with nested expressions into disjunctive logic programs. Moreover, we show that this translation is modular and (strongly) faithful. We have implemented both the straightforward as well as our advanced transformation; the resulting compiler serves as a front-end to DLV and is publicly available on the Web.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

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 so-called nested logic programs generalise the well-known 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 one-to-one 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 front-end for the logic programming system DLV.

The construction of relies on the introduction of new labels, abbreviating subformula occurrences. This technique is derived from structure-preserving 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 structure-preserving 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 one-to-one 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 semantics-preserving 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 minimal-model reasoning in the logic of here-and-there, which is intermediate between classical logic and intuitionistic logic (the logic of here-and-there is also known as Gödel’s three-valued 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 here-and-there 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 here-and-there.

The problem of implementing nested logic programs has already been addressed in [30], where (linear-time 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 off-the-shelf 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 worst-case 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 blow-up of the resulting disjunctive logic programs in the worst case. This is due to the fact that the “language-preserving” 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 structure-preserving normal form translations in the logic of here-and-there 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 finite-valued 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 lower-case 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 here-and-there, 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 here-and-there 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 here-and-there (cf. Proposition 2 below).

The semantics of the logic of here-and-there 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 HT-interpretation, , we understand an ordered pair of sets of atoms such that . We say that is an HT-interpretation over if . The set of all HT-interpretations over is denoted by . An HT-interpretation is total if .

The truth value, , of a formula at a world in an HT-interpretation is recursively defined as follows:

  1. if , then ;

  2. if , then ;

  3. if is an atom, then if , otherwise ;

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

  5. if , then if and , otherwise ;

  6. if , then if or , otherwise ;

  7. if , then if for every world with , or , otherwise .

We say that is true under in iff , otherwise is false under in . An HT-interpretation satisfies , or is an HT-model of , iff . If is true under any HT-interpretation, then is valid in the logic of here-and-there, or simply HT-valid.

Let be a set of formulas. An HT-interpretation is an HT-model of iff is an HT-model of each element of . We say that is an HT-model of a program iff is an HT-model of .

Two sets of formulas are equivalent in the logic of here-and-there, or HT-equivalent, iff they possess the same HT-models. Two formulas, and , are HT-equivalent iff the sets and are HT-equivalent.

It is easily seen that any HT-valid 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 here-and-there as the pair is not an HT-model for either of these formulas.

Equilibrium logic can be seen as a particular type of reasoning with minimal HT-models. Formally, an equilibrium model of a formula is a total HT-interpretation such that (i) is an HT-model of , and (ii) for every proper subset of , is not an HT-model 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:

Proposition 1 ([26, 22])

For any program , is an answer set of iff is an equilibrium model of .

Moreover, HT-equivalence 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 here-and-there.

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 here-and-there (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 HT-literal, , we understand a formula of form , , or , where is a propositional atom or one of , . Furthermore, a formula is in here-and-there negational normal form, or HT-NNF, if it is made up of HT-literals, conjunctions and disjunctions. Likewise, we say that a program is in HT-NNF iff all heads and bodies of rules in the program are in HT-NNF.

Following [23], every expression can effectively be transformed into an expression in HT-NNF possessing the same HT-models as . In fact, we have the following property:

Proposition 3

Every expression is HT-equivalent to an expression in HT-NNF, where is constructible in polynomial time from , satisfying the following conditions, for each expression :

  1. , if is an HT-literal;

  2. ;

  3. , for ;

  4. ;

  5. .

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.111A class of sets is closed under unions providing implies . Then, a function is

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

  2. faithful iff, for all programs ,

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

    and

  4. 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 PFM-function, iff it is polynomial, faithful, and modular. Analogously, we call PSM, or a PSM-function, iff it is polynomial, strongly faithful, and modular.

It is easy to see that the composition of two PFM-functions is again a PFM-function; and likewise for PSM-functions. Furthermore, since any PSM-function is also PFM, in the following we focus on PSM-functions. 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 HT-interpretations over .

Then, the function is called a -associated HT-embedding iff, for each HT-interpretation over , each , and each , and , where .

Furthermore, for any and any , we define .

Intuitively, a -associated HT-embedding transforms HT-interpretations over the input alphabet of into HT-interpretations 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 HT-embedding. We say that is a -associated HT-homomorphism if, for any and any , the following conditions hold:

  1. is an HT-model of iff is an HT-model of ;

  2. is total iff is total;

  3. if and are HT-models of , then and holds precisely if and , for and ; and

  4. an HT-interpretation over is an HT-model of only if .

Roughly speaking, -associated HT-homomorphisms retain the relevant properties of HT-interpretations for being equilibrium models with respect to transformation . More specifically, the first three conditions take semantical and set-theoretical 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 HT-interpretations over under with respect to program , does, in general, not cover all HT-interpretations over . Hence, for a general -associated HT-embedding , there may exist some HT-model 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 HT-interpretations 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 HT-homomorphism, 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 HT-homomorphism, 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 HT-literals.

To avoid such an exponential blow-up, our technique is based on the introduction of new atoms, called labels, abbreviating subformula occurrences. This method is derived from structure-preserving normal form translations [34, 31]

, which are frequently applied in the context of automated reasoning (cf., e.g., 

[2, 15] for general investigations about structure-preserving normal form translation in finite-valued Gödel logics, and [6, 7] for proof-theoretical 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:

  1. For each , transform and into HT-NNF;

  2. translate the program into a program containing only rules with conjunctions of HT-literals in their bodies and disjunctions of HT-literals in their heads;

  3. eliminate double negations in bodies and heads; and

  4. 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 HT-NNF, and is the class of all programs over which are defined like generalised logic programs, except that HT-literals 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 HT-NNF. 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 HT-NNF.

Definition 4

The function is defined by setting

for any .

Since, for each expression , is constructible in polynomial time and is HT-equivalent 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:

  1. for each HT-literal occurring in , add the two rules

  2. for each expression occurring in , add the three rules

    and

  3. for each expression occurring in , add the three rules

This definition is basically an adaption of a structure-preserving 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 HT-homomorphism 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 HT-homomorphism, where

if , and otherwise, for any and any HT-interpretation 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 HT-homomorphism, where

if , and otherwise, for any HT-interpretation 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 one-to-one 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 structure-preserving normal form translation for intuitionistic logic, as described in [24]. Besides the particular type of translation used here, there are also other, slightly improved structure-preserving 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 off-the-shelf 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.uni-potsdam.de/torsten/nlp.

Our technique is based on the introduction of new atoms, abbreviating subformula occurrences. This method has its roots in structure-preserving 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 blow-up in the worst-case, 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 semantics-preserving 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. Resolution-Based Theorem Proving for Many-Valued 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 (LPNMR-01), 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 (AAAI-98), 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 Structure-Preserving 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 Non-Monotonic Reasoning. In Proceedings of the Fourth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR-97), 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 (KR-98), 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 (AAAI-00), pages 285–290. AAAI Press, 2000.
  • [11] M. Gelfond, M. Balduccini, and J. Galloway. Diagnosing Physical Systems in A-Prolog. In Proceedings of the Sixth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR-01), 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 (IJCAR-01), 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 (LPNMR-01), 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 (JELIA-98), 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 (LPNMR-01), volume 2173 of Lecture Notes in Artificial Intelligence, pages 93–106, Berlin, 2001. Springer Verlag.
  • [19] H. Kleine-Bü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 IJCAR-01 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 (ICLP-99), 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(3-4):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 Well-Founded Semantics for Normal Logic Programs. In Proceedings of the Fourth International Conference on Logic Programming and Nonmonotonic Reasoning (LPNMR-97), 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 Non-Monotonic 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 (TABLEAUX-00), 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 (CL-00), 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 (EPIA-01), 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 (IJCAI-99), 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. Springer-Verlag, 1983.
  • [34] G. Tseitin. On the Complexity of Proofs in Propositional Logics. Seminars in Mathematics, 8, 1970. Reprinted in [33].