# Embedding Description Logic Programs into Default Logic

Description logic programs (dl-programs) under the answer set semantics formulated by Eiter et al. have been considered as a prominent formalism for integrating rules and ontology knowledge bases. A question of interest has been whether dl-programs can be captured in a general formalism of nonmonotonic logic. In this paper, we study the possibility of embedding dl-programs into default logic. We show that dl-programs under the strong and weak answer set semantics can be embedded in default logic by combining two translations, one of which eliminates the constraint operator from nonmonotonic dl-atoms and the other translates a dl-program into a default theory. For dl-programs without nonmonotonic dl-atoms but with the negation-as-failure operator, our embedding is polynomial, faithful, and modular. In addition, our default logic encoding can be extended in a simple way to capture recently proposed weakly well-supported answer set semantics, for arbitrary dl-programs. These results reinforce the argument that default logic can serve as a fruitful foundation for query-based approaches to integrating ontology and rules. With its simple syntax and intuitive semantics, plus available computational results, default logic can be considered an attractive approach to integration of ontology and rules.

## Authors

• 4 publications
• 12 publications
• 5 publications
• 9 publications
• 21 publications
• ### Answer Sets for Logic Programs with Arbitrary Abstract Constraint Atoms

In this paper, we present two alternative approaches to defining answer ...
10/10/2011 ∙ by E. Pontelli, et al. ∙ 0

• ### Two results for proiritized logic programming

Prioritized default reasoning has illustrated its rich expressiveness an...
03/05/2002 ∙ by Yan Zhang, et al. ∙ 0

In recent work we defined resource-based answer set semantics, which is ...
08/04/2016 ∙ by Stefania Costantini, et al. ∙ 0

• ### On Strong and Default Negation in Logic Program Updates (Extended Version)

04/27/2014 ∙ by Martin Slota, et al. ∙ 0

• ### Characterizations of Stable Model Semantics for Logic Programs with Arbitrary Constraint Atoms

This paper studies the stable model semantics of logic programs with (ab...
04/30/2009 ∙ by Yi-Dong Shen, et al. ∙ 0

• ### Revisiting Explicit Negation in Answer Set Programming

A common feature in Answer Set Programming is the use of a second negati...

• ### Preferred well-founded semantics for logic programming by alternating fixpoints: Preliminary report

We analyze the problem of defining well-founded semantics for ordered lo...
07/15/2002 ∙ by Torsten Schaub, et al. ∙ 0

##### 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

Logic programming under the answer set semantics (ASP) has been recognized as an expressive nonmonotonic reasoning framework for declarative problem solving and knowledge representation [Marek  TruszczynskiMarek  Truszczynski1999, NiemeläNiemelä1999]. Recently, there has been an extensive interest in combining ASP with other logics or reasoning mechanisms. One of the main interests in this direction is the integration of ASP with description logics (DLs) for the Semantic Web. This is due to the fact that, although ontologies expressed in DLs and rules in ASP are two prominent knowledge representation formalisms, each of them has limitations on its own. As (most) DLs are fragments of (many sorted) first order logic, they do not support default, typicality, or nonmonotonic reasoning in general. On the other hand, thought there are some recent attempts to extend ASP beyond propositional logic, the core, effective reasoning methods are designed essentially for computation of ground programs; in particular, ASP typically does not reason with unbounded or infinite domains, nor does it support quantifiers. An integration of the two can offer features of both.

A number of proposals for integrating ontology and (nonmonotonic) rules have been put forward [de Bruijn, Eiter, Polleres,  Tompitsde Bruijn et al.2007, de Bruijn, Pearce, Polleres,  Valverdede Bruijn et al.2007, Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008, Motik  RosatiMotik  Rosati2010, RosatiRosati2005, RosatiRosati2006, Analyti, Antoniou,  DamásioAnalyti et al.2011, LukasiewiczLukasiewicz2010, Lee  PallaLee  Palla2011]

. The existing approaches can be roughly classified into three categories. In the first, typically a nonmonotonic formalism is adopted which naturally embodies both first-order logic and rules, where ontology and rules are written in the same language resulting in a tight coupling

[de Bruijn, Eiter, Polleres,  Tompitsde Bruijn et al.2011, Motik  RosatiMotik  Rosati2010, LukasiewiczLukasiewicz2010]. The second is a loose approach: an ontology knowledge base and rules share the same constants but not the same predicates, and inference-based communication is via a well-designed interface, called dl-atoms [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008]. In the third approach, rules are treated as hybrid formulas where in model building the predicates in the language of the ontology are interpreted classically, whereas those in the language of rules are interpreted nonmonotonically [RosatiRosati2005, RosatiRosati2006, de Bruijn, Pearce, Polleres,  Valverdede Bruijn et al.2007].

The loose coupling approach above stands out as quite unique and it possesses some advantages. In many practical situations, we would like to combine existing knowledge bases, possibly under different logics. In this case, a notion of interface is natural and necessary. The formulation of dl-programs adopts such interfaces to ontology knowledge bases. It is worth noticing that dl-programs share many similarities with another recent interesting formalism, called nonmonotonic multi-context systems, in which knowledge bases under arbitrary logics communicate through bridge rules [Brewka  EiterBrewka  Eiter2007].

Informally, a dl-program is a pair , where is an ontology knowledge base expressed in a description logic, and a logic program, where rule bodies may contain queries to the knowledge base , called dl-atoms. Such queries allow to specify inputs from a logic program to the ontology knowledge base. In more detail, a dl-atom is of the form

 DL[S1 op1 p1,…,Sm opm pm;Q](→t)

where is a query to , and for each , is a concept or a role in , is a predicate symbol in having the same arity as , and the operator . Intuitively, (resp., ) increases (resp., ) by the extension of , while (called the constraint operator) constrains to , i.e., for an expression , for any tuple of constants , in the absence of ) we infer . Eiter et al. proposed weak and strong answer sets for dl-programs [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008], which were further investigated from the perspective of loop formulas [Wang, You, Yuan,  ShenWang et al.2010] and from the perspective of the logic of here-and-there [Fink  PearceFink  Pearce2010].

The interest in dl-programs is also due to a technical aspect - it has been a challenging task to embed dl-programs into a general nonmonotonic logic. For example, MKNF [LifschitzLifschitz1991] is arguably among the most expressive and versatile formalisms for integrating rules and description logic knowledge bases [Motik  RosatiMotik  Rosati2010]. Although Motik and Rosati were able to show a polynomial embedding of a number of other integration formalisms into MKNF, for dl-programs they only showed that if a dl-program does not contain the constraint operator , then it can be translated to a (hybrid) MKNF knowledge base while preserving its strong answer sets.111The theorem given in [Motik  RosatiMotik  Rosati2010] (Theorem 7.6) only claims to preserve satisfiability. In a personal communication with Motik, it is confirmed that the proof of the theorem indeed establishes a one-to-one correspondence. The embedding into quantified equilibrium logic in [Fink  PearceFink  Pearce2010] is under the assumption that all dl-atoms containing an occurrence of are nonmonotonic. They do not deal with the case when a dl-atom involving may be monotonic. The embedding into first-order autoepistemic logic (AEL) is under the weak answer set semantics [de Bruijn, Eiter,  Tompitsde Bruijn et al.2008]. For the strong answer set semantics, it is obtained by an embedding of MKNF into first-order autoepistemic logic together with the embedding of dl-programs into MKNF. Thus it only handles the dl-programs without the constraint operator.

In this paper, we investigate the possibility of embedding dl-programs into default logic [ReiterReiter1980], under various notions of answer set semantics. Our interest in default logic is due to the fact that it is one of the dominant nonmonotonic formalisms, yet despite the fact that default logic naturally accommodates first-order logic and rules (defaults), curiously it has not been considered explicitly as a framework for integrating ontology and rules. Since the loose approach can be viewed as query-based, the question arises as whether default logic can be viewed as a foundation for query-based approaches to integration of ontologies and rules.

We shall note that the problem of embedding dl-programs into default logic is nontrivial. In fact, given the difficulties in dealing with dl-programs by other expressive nonmonotonic logics, one can expect great technical subtlety in this endeavor. Especially, the treatment of equality is a nontrivial issue.

A main technical result of this paper is that dl-programs can be translated to default theories while preserving their strong and weak answer sets. This is achieved in two steps. In the first, we investigate the operators in dl-programs and observe that the constraint operator is the only one causing a dl-atom to be nonmonotonic, and a dl-atom may still be monotonic even though it mentions the constraint operator . To eliminate from nonmonotonic dl-atoms, we propose a translation and show that, given a dl-program , the strong and weak answer sets of correspond exactly to the strong and weak answer sets of , respectively, i.e., when restricted to the language of , the strong and weak answer sets of are precisely those of , and vice versa. An immediate consequence of this result is that it improves a result of [Motik  RosatiMotik  Rosati2010], in that we now know that a much larger class of dl-programs, the class of normal dl-programs, can be translated to MKNF knowledge bases, where a dl-program is normal if it has no monotonic dl-atoms that mention the constraint operator .

For the weak answer set semantics, the translation above can be relaxed so that all dl-atoms containing can be translated uniformly, and the resulting translation is polynomial. However, for the strong answer set semantics, the above translation relies on the knowledge whether a dl-atom is monotonic or not. In this paper, we present a number of results regarding the upper and lower bounds of determining this condition for description logics and [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008]. These results have a broader implication as they apply to the work of [Fink  PearceFink  Pearce2010] in embedding dl-programs under strong answer sets into quantified equilibrium logic.

In the second step, we present two approaches to translating dl-programs to default theories in a polynomial, faithful, and modular manner [JanhunenJanhunen1999].222This means a polynomial time transformation that preserves the intended semantics, uses the symbols of the original language, and translates parts (modules) of the given dl-program independently of each other. The difference between the two is on the handling of inconsistent ontology knowledge bases. In the first one, an inconsistent ontology knowledge base trivializes the resulting default theory, while following the spirit of dl-programs, in the second approach nontrivial answer sets may still exist in the case of an inconsistent ontology knowledge base. We show that, for a dl-program without nonmonotonic dl-atoms, there is a one-to-one correspondence between the strong answer sets of and the extensions of its corresponding default theory (whenever the underlying knowledge base is consistent for the first approach). This, along with the result given in the first step, shows that dl-programs under the strong answer set semantics can be embedded into default logic.

It has been argued that some strong answers may incur self-supports. To overcome this blemish, weakly and strongly well-supported answer set semantics are recently proposed [ShenShen2011]. Surprisingly, dl-programs under the weakly well-supported semantics can be embedded into default logic by a small enhancement to our approach in the second step above, and the resulting translation is again polynomial, faithful and modular. Furthermore, if nonmonotonic dl-atoms do not appear in the scope of the default negation , the strongly well-supported semantics coincides with the weakly well-supported semantics. Since default negation already provides a language construct to express default inferences, it can be argued that one need not use the constraint operator inside it. In this sense, our default logic encoding captures the strongly well-supported semantics as well.

We note that, in embedding dl-programs without nonmonotonic dl-atoms into default logic, one still can use the negation-as-failure operator in dl-programs to express nonmonotonic inferences. The same assumption was adopted in defining a well-founded semantics for dl-programs [Eiter, Lukasiewicz, Ianni,  SchindlauerEiter et al.2011]. Under this assumption, all the major semantics for dl-programs coincide, and they all can be embedded into default logic by a polynomial, faithful, and modular translation. Thus, the results of this paper not only reveal insights and technical subtleties in capturing dl-programs under various semantics by default logic, but also strengthen the prospect that the latter can serve as a foundation for query-based integration of rules and ontologies.

The main advantage of using default logic to characterize integration of ontology and rules in general, and semantics of dl-programs in particular, is its simple syntax and intuitive semantics, which has led to a collection of computational results in the literature (see, e.g., [Li  YouLi  You1992, Cholewiński, Marek, Mikitiuk,  TruszczyńskiCholewiński et al.1999, Nicolas, Saubion,  StéphanNicolas et al.2001, Chen, Wan, Zhang,  ZhouChen et al.2010]). Interestingly, the more recent effort is on applying ASP techniques to compute default extensions. As long as defaults can be finitely grounded, which is the case for the approach of this paper, these techniques can be extended by combining an ASP-based default logic engine with a description logic reasoner, with the latter being applied as a black box. In contrast, the computational issues are completely absent in the approach under AEL [de Bruijn, Eiter,  Tompitsde Bruijn et al.2008], and only addressed briefly at an abstract level for the approach based on MKNF [Motik  RosatiMotik  Rosati2010]. Furthermore, the representation of dl-programs in default logic leads to new insights in computation for dl-programs, one of which is that the iterative construction of default extensions provides a direct support to well-supportedness for answer sets, so that justifications for positive dependencies can be realized for free.

The main contributions of this paper are summarized as follows.

• We show that dl-programs under the weak and strong answer set semantics can be faithfully and modularly rewritten without constraint operators. The rewriting is polynomial for the weak answer set semantics.

• To embed arbitrary dl-programs into default logic, we present faithful and modular [JanhunenJanhunen1999] translations for the strong answer set semantics, the weak answer set semantics and the weakly well-supported semantics. The translations are also polynomial for the latter two semantics.

• For the strong answer set semantics, the embedding depends on the knowledge of monotonicity of dl-atoms and is polynomial relative to this knowledge, i.e., if the set of monotonic dl-atoms is known. In general, determining this set is intractable; as we show, determining whether a dl-atom is monotonic is EXP-complete under the description logic and -complete under the description logic (and thus not more expensive than deciding the existence of some strong or weak answer set of a dl-program under these description logics).

• For the two semantics for which we do not provide a polynomial embedding, namely the strong answer set semantics and the strongly well-supported semantics, there are broad classes of dl-programs for which a polynomial embedding can be easily inferred from our results. For the class of dl-programs where nonmonotonic dl-atoms do not appear in the scope of default negation , our embedding is polynomial, faithful, and modular under the strongly well-supported semantics; and for the class of dl-programs where the constraint operator does not appear in a positive dl-atom in rules, our embedding is again polynomial, faithful, and modular under the strong answer set semantics.

The paper is organized as follows. In the next section, we recall the basic definitions of description logics and dl-programs. In Section 3, we present a transformation to eliminate the constraint operator from nonmonotonic dl-atoms. In Section 4, we give transformations from dl-programs to default theories, followed by Sections 5 and 6 on related work and concluding remarks respectively.

## 2 Preliminaries

In this section, we briefly review the basic notations for description logics [Baader, Calvanese, McGuinness, Nardi,  Patel-SchneiderBaader et al.2007] and description logic programs [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008].

### 2.1 Description logics

Description Logics are a family of class-based (concept-based) knowledge representation formalisms. We assume a set E of elementary datatypes and a set V of data values. A datatype theory consists of a datatype (or concrete) domain and a mapping that assigns to every elementary datatype a subset of and to every data value an element of . Let be a vocabulary, where , and I are pairwise disjoint (denumerable) sets of atomic concepts, abstract roles, datatype (or concrete) roles, and individuals, respectively.

A role is an element of , where means the set of inverses of all . Concepts are inductively defined as: (1) every atomic concept is a concept, (2) if are individuals from I, then is a concept (called oneOf), (3) if and are concepts, then also , , and are concepts (called conjunction, disjunction, and negation respectively). (4) if is a concept, is an abstract role from , and is a nonnegative integer, then and are concepts (called exists, value, atleast, and atmost restriction, respectively), (5) if is a datatype, is a datatype role from , and is a nonnegative integer, then , and are concepts (called datatype exists, value, atleast, and atmost restriction, respectively).

An axiom is an expression of one of the forms: (1) , called concept inclusion axiom, where and are concepts; (2) , called role inclusion axiom, where either or ; (3) Trans(), called transitivity axiom, where ; (4) , called concept membership axiom, where is a concept and ; (5) (resp., ), called role membership axiom where (resp., ) (resp., and is a data value), (6) (resp., ), called equality (resp., inequality) axiom where .

A description logic (DL) knowledge base is a finite set of axioms. The knowledge base consists of a finite set of above axioms, while the knowledge base is the one of , but without the oneOf constructor and with the atleast and atmost constructors limited to 0 and 1.

The semantics of the two description logics are defined in terms of general first-order interpretations. An interpretation with respect to a datatype theory consists of a nonempty (abstract) domain disjoint from , and a mapping that assigns to each atomic concept a subset of , to each individual an element of , to each abstract role a subset of , and to each datatype role a subset of . The mapping is extended to all concepts and roles as usual (where denotes the cardinality of a set ):

• ;

• ;

• , , ;

• ;

• ;

• ;

• ;

• ;

• ;

• ;

• .

Let be an interpretation respect to , and an axiom. We say that satisfies , written , is defined as follows: (1) iff ; (2) iff ; (3) iff is transitive; (4) iff ; (5) (resp., iff ; (6) iff (resp., iff ). satisfies a DL knowledge base , written , if for any . In this case, we call a model of . An axiom is a logical consequence of a DL knowledge base , written , if any model of is also a model of .

### 2.2 Description logic programs

Let be a first-order vocabulary with nonempty finite sets and of constant symbols and predicate symbols respectively such that is disjoint from and . Atoms are formed from the symbols in and as usual.

A dl-atom is an expression of the form

 DL[S1 op1 p1,…,Sm opm pm;Q](→t),  (m≥0) (1)

where

• each is either a concept, a role or its negation,333 We allow negation of a role for convenience, so that we can replace “” with an equivalent form “” in dl-atoms. The negation of a role is not explicitly present in [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008]. As discussed there, negative role assertions can be emulated in and (and in fact also in ). or a special symbol in ;

• (we call the constraint operator);

• is a unary predicate symbol in if is a concept, and a binary predicate symbol in otherwise. The ’s are called input predicate symbols;

• is a dl-query, i.e., either (1) where ; (2) where is an empty argument list; (3) where ; (4) where ; or their negations, where and are concepts, is a role, and is a tuple of constants.

The precise meanings of will be defined shortly. Intuitively, extends by the extension of . Similarly, extends by the extension of , and constrains to . A dl-rule (or simply a rule) is an expression of the form

 A←B1,…,Bm,notBm+1,…,notBn,(n≥m≥0) (2)

where is an atom, each is an atom444Different from that of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008], we consider ground atoms instead of literals for convenience. or a dl-atom. We refer to as its head, while the conjunction of and is its body. For convenience, we abbreviate a rule in the form (2) as

 A←Pos,notNeg (3)

where and . Let be a rule of the form (3). If and , is a fact and we may write it as “” instead of “”. A description logic program (dl-program) consists of a DL knowledge base and a finite set of dl-rules. In what follows we assume the vocabulary of is implicitly given by the constant symbols and predicate symbols occurring in , consists of the constants occurring in atoms of , and is grounded (no atoms containing variables) unless stated otherwise.

Given a dl-program , the Herbrand base of , denoted by , is the set of atoms occurring in and the ones formed from the predicate symbols of occurring in some dl-atoms of and the constant symbols in . 555Note that this slightly deviates from the usual convention of the Herbrand base; ground atoms that are not in the Herbrand base as considered here are always false in answer sets. It is clear that is in polynomial size of . An interpretation (relative to ) is a subset of . Such an is a model of an atom or dl-atom under , written , if the following holds:

• if , then iff ;

• if is a dl-atom of the form (1), then iff where and, for ,

 Ai(I)=⎧⎪⎨⎪⎩{Si(→e)∣pi(→e)∈I},if opi=⊕;{¬Si(→e)∣pi(→e)∈I},if opi=⊙;{¬Si(→e)∣pi(→e)∉I},if opi=⊖;%

where is a tuple of constants over . As we allow negation of role, can be replaced with in any dl-atom. In addition, we can shorten as where appears in for all and . Thus dl-atoms can be equivalently rewritten into ones without using the operator , and every predicate appears at most once for each operator and . For instance, the dl-atom can be equivalently written as .

An interpretation is a model of “”, written , if is not a model of , i.e., . The interpretation is a model of a dl-rule of the form (3) iff for any and for any implies that . An interpretation is a model of a dl-program , written , iff is a model of each rule of .

#### 2.2.1 Monotonic dl-atoms

A dl-atom is monotonic (relative to a dl-program ) if implies , for all such that , otherwise is nonmonotonic. It is clear that if a dl-atom does not mention the constraint operator then it is monotonic. However, a dl-atom may be monotonic even if it mentions the constraint operator. For example, the dl-atom is a tautology (which is monotonic).

Evidently, the constraint operator is the only one that may cause a dl-atom to be nonmonotonic. This sufficient condition for monotonicity can be efficiently checked; for the case where the constraint operator may appear, the following generic upper bound on complexity is easily derived. We refer to the query complexity of a ground dl-atom of form (1) in as the complexity of deciding, given , , and an arbitrary interpretation , whether holds.

###### Proposition 1

Let be a (ground) dl-program, and be a dl-atom occurring in which has query complexity in class . Then deciding whether is monotonic is in .

Proof: Indeed, to show that of form (1) is nonmonotonic, one can guess restrictions and of interpretations and , respectively, to the predicates occurring in such that and but (clearly, iff for arbitrary interpretations ). The guess for and is of polynomial size in the size of (assuming that the set of constants is explicit in , or is constructible in polynomial time), and preparing and is feasible in polynomial time (in fact, easily in logarithmic space). Using the oracle, we can decide and , and thus but . Overall, the complexity is in .

Depending on the underlying description logic, this upper bound might be lower or complemented by a matching hardness result. In fact, for and , the latter turns out to be the case. DL-atoms over these description logics have a query complexity that is complete for = EXP and = NEXP, respectively. By employing well-known identities of complexity classes, we obtain the following result.

###### Theorem 1

Given a (ground) dl-program and a dl-atom occurring in , deciding whether is monotonic is (i) EXP-complete, if is a knowledge base and (ii) -complete, if is a knowledge base.

Proof: The membership part for (i) follows easily from Proposition 1 and the fact that has query complexity in EXP; indeed, each dl-query evaluation can be transformed in polynomial time to deciding satisfiability of a knowledge base, which is EXP-complete in general [TobiesTobies2001, Horrocks  Patel-SchneiderHorrocks  Patel-Schneider2003]. Now = EXP =

; indeed, the computation tree of a nondeterministic Turing machine with polynomial running time and

EXP oracle access has single exponential (in the input size) many nodes, which can be traversed in exponential time; simulating an oracle call in a node is possible in exponential time in the size of the (original) input. Overall, this yields an exponential time upper bound.

The membership part for (ii) follows analogously from Proposition 1 and the fact that has co-NEXP-complete query complexity, which follows from NEXP-completeness of the knowledge base satisfiability problem in (for both unary and binary number encoding; see [Horrocks  Patel-SchneiderHorrocks  Patel-Schneider2003, Pratt-HartmannPratt-Hartmann2005]). Now = = (= ); here the second equality holds by results in [HemachandraHemachandra1989].

The hardness parts for (i) and (ii) are shown by reductions of suitable EXP- resp. -complete problems, building on constructions in [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008] (see Appendix A).

For convenience, we use to denote the set of all dl-atoms that occur in , to denote the set of monotonic dl-atoms, and . Note that this is different from that of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008] where is assumed to be a set of ground dl-atoms in which are known to be monotonic, while denotes the set of remaining dl-atoms. Thus is allowed to contain monotonic dl-atoms as well in [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008]. Our definition represents the ideal situation where monotonicity can be finitely verified, which is the case for decidable description logic knowledge bases. Note also that by Theorem 1, for and knowledge bases computing is possible with no respectively mild complexity increase compared to basic reasoning tasks in the underlying description logic.

#### 2.2.2 Some classes of dl-programs

A dl-program is positive, if (i) is “not”-free, and (ii) every dl-atom is monotonic relative to . Positive dl-programs have attractive semantics properties; e.g., it is evident that a positive dl-program has a (set inclusion) least model.

From the results above, we easily obtain the following results on recognizing positive dl-programs.

###### Proposition 2

Deciding whether a given (not necessarily ground) dl-program is positive is in co-NP, if every dl-atom in the ground version of has query complexity in .

Proof: is not positive if either (i) is not “not”-free, which can be checked in polynomial time, or (ii) some dl-atom in the ground version of is nonmonotonic; such an can be guessed and verified, by the hypothesis, in polynomial time with an oracle for ; hence the result.

###### Theorem 2

Deciding whether a given (not necessarily ground) dl-program is positive is (i) EXP-complete, if is a knowledge base and (ii) -complete, if is a knowledge base.

Proof: The membership parts are immediate from Proposition 2, and the hardness parts from the hardness proofs in Theorem 1: the atom is monotonic relative to the constructed dl-program iff is positive.

Thus, the test whether a dl-program is positive (and similarly, whether all dl-atoms in it are monotonic) for and knowledge bases is also not expensive compared to basic reasoning tasks.

Besides positive dl-programs, another important subclass are canonical dl-programs, where a dl-program is canonical, if mentions no constraint operator. Clearly, canonical dl-programs are easy to recognize. The same holds for the more general class of normal dl-programs, where a dl-program is normal, if no monotonic dl-atom occurs in that mentions the constraint operator. Note that normal dl-programs are not positive in general; since monotonic dl-atoms mentioning the constraint operator are rather exceptional, the normal dl-programs include most dl-programs relevant for practical applications.

###### Example 1

Consider the following dl-programs, which we will refer to repeatedly in the sequel.

• where and . The single dl-atom in has no constraint operator, and thus is canonical (hence also normal); moreover, since ‘” does not occur in , is also positive.

• where and . Here, the constraint operator occurs in , thus is not canonical. Furthermore, the single dl-atom in is nonmonotonic, hence is also not positive. However, is normal.

#### 2.2.3 Strong and weak answer sets

Let be a positive dl-program. The immediate consequence operator is defined as, for any ,

 γK(I)={h∣h←Pos∈P%andI⊨OA for any A∈Pos}.

Since is monotonic, the least fix-point of always exists which is the least model of . By we denote the least fix-point of , which can be iteratively constructed as below:

• ;

• .

It is clear that the least fixpoint .

We are now in the position to recall the semantics of dl-programs. Let be a dl-program. The strong dl-transform of relative to and an interpretation , denoted by , is the positive dl-program ), where is obtained from by deleting:

• the dl-rule of the form (2) such that either for some and , or for some ; and

• the nonmonotonic dl-atoms and from the remaining dl-rules where is an atom or a dl-atom.

The interpretation is a strong answer set of if it is the least model of , i.e., .666Note that, under our notion of , namely is the set of nonmonotonic dl-atoms w.r.t. a given dl-program, the strong answer set semantics is the strongest among possible variations under the definition of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008], where may contain monotonic dl-atoms, in that given a dl-program , any strong answer set of under our definition is a strong answer set of under the definition of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008].

The weak dl-transform of relative to and an interpretation , denoted by , is the positive dl-program , where is obtained from by deleting:

• the dl-rules of the form (2) such that either for some and , or for some ; and

• the dl-atoms and from the remaining dl-rules where is an atom or dl-atom.

The interpretation is a weak answer set of if is the least model of , i.e., .

The following proposition shows that, given a dl-program , if is inconsistent then strong and weak answer sets of coincide, and are minimal.

###### Proposition 3

Let be a dl-program where is inconsistent and . Then

1. is a strong answer set of if and only if is a weak answer set of .

2. The strong and weak answer sets of are minimal under set inclusion.

Proof: By the inconsistency of , it is clear that every dl-atom occurring in is monotonic and for any .

(i) Note that the only difference between and is that there exist some dl-atoms in but not in , i.e., for any dl-rule in , belongs to if and only if belongs to where . However note that for any dl-atom . It follows that . Consequently is a strong answer set of if and only if is a weak answer set of .

(ii) By Theorem 4.13 of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008], the strong answer sets of are minimal. It implies that the weak answer sets of are minimal as well by (i) of the proposition.

###### Example 2

[Continued from Example 1] Reconsider the dl-programs in Example 1.

• The dl-program , where and , has a unique strong answer set and two weak answer sets and . The interested reader may verify the following: , and clearly and . So the weak dl-transformation relative to and is . Since coincides with the least model of , it is a weak answer set of . Similarly, one can verify that the strong dl-transformation relative to and is . Its least model is the empty set, so is not a strong answer set of .

• For the dl-program , where and , both and are strong and weak answer sets.

These dl-programs show that strong (and weak) answer sets may not be (set inclusion) minimal. It has been shown that if a dl-program contains no nonmonotonic dl-atoms then its strong answer sets are minimal (cf. Theorem 4.13 of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008]). However, this does not hold for weak answer sets as shown by the dl-program above, even if it is positive. It has also been shown that strong answer sets are always weak answer sets, but not vice versa. Thus the question rises: is it the case that, for any dl-program and interpretation , if is a weak answer set of , then there is such that is a strong answer of ? We give a negative answer to this question by the following example.

###### Example 3

Let where consists of

 p(a)←DL[S⊕p;S](a),p(a)←notDL[S⊕p;S](a).

Note that is canonical and normal, but not positive. Intuitively, expresses reasoning by cases: regardless of whether the dl-atom evaluates to false, should be true. Let . We have that , thus is a weak answer set of . However, note that . The least model of is . So that is not a strong answer set of . Now consider . We have . The least model of is . Thus is not a strong answer set of . In fact, has no strong answer sets at all. This is in line with the intuition that, as is empty, can not be foundedly derived without the assumption that is true.

## 3 Eliminating the Constraint Operator from Nonmonotonic Dl-atoms

Intuitively, translating a nonmonotonic dl-atom into a monotonic is to replace with where is a fresh predicate having the same arity as and stands for the negation of . In what follows, we show that the constraint operator can be eliminated from nonmonotonic dl-atoms while preserving both weak and strong answer sets. As mentioned previously, we assume that the signatures and are implicitly given for a given dl-program . Any predicate symbol not occurring in is a fresh one.

###### Definition 1 (π(K))

Let be a dl-program. We define where and , assuming is of the form (2), consists of

1. the rule

 A←π(B1),…,π(Bm),π(notBm+1),…,π(notBn) (4)

where

 π(B)={B,if B is an atom or a monotonic dl-% atom;notπB,if B is a nonmonotonic dl-atom,

in which is a fresh propositional atom, and

 π(notB)={notB,if B is an atom;notDL[π(λ);Q](→t),if B=DL[λ,Q](→t),

where is obtained from by replacing each “” with “”, and is a fresh predicate having the same arity as ;

2. for each nonmonotonic dl-atom , the following rule:

 πB←π(notB) (5)

where is the same atom as mentioned in (i) and

3. for each predicate such that “” occurs in some nonmonotonic dl-atom of , the instantiations of the rule:

 πp(→x)←notp(→x) (6)

where is a tuple of distinct variables matching the arity of , and is the same predicate as mentioned in (i).

Intuitively, the idea in is the following. Recall that “” means “infer in absence of ”. Thus if stands for the absence of then “” should have the same meaning as that of “”. Thus, a nonmonotonic dl-atom can be re-expressed by a monotonic dl-atom and “not”. Note that may still contain dl-atoms with the constraint operator, but they are all monotonic dl-atoms.

###### Example 4

Let us consider the following dl-programs.

• Let where consists of

 p(a)←notDL[S⊖p;¬S](a).

Note that is normal but neither canonical nor positive. It is not difficult to verify that has two weak answer sets and . They are strong answer sets of as well. According to the translation , we have , where consists of

It is easy to see that has only two weak answer sets, and , which are also strong answer sets of . They correspond to and respectively when restricted to .

• Let where consists of

 p(a)←notDL[S⊖p,S′⊙q,S′⊖q;¬S⊓¬S′](a).

Recall that the dl-atom is a tautology, hence monotonic; thus is not normal. The strong and weak answer sets of are the same as those of . Please note that consists of

 p(a)←notDL[S⊙πp,S′⊙q,S′⊙πq;¬S⊓¬S′](a), πp(a)←notp(a),πq(a)←notq(a).

The strong and weak answer sets of are and . They correspond to and respectively when restricted to .

• Let be the dl-program in Example 1. Then where consists of

 p(a)←notπA,πq(a)←notq(a), πA←notDL[S⊕p,S′⊙πq,S⊓¬S′](a)

where . One can check that has two strong answer sets, and , which are and whenever restricted to the original Herbrand base.

The main insight revealed by the translation is, while a negative dl-atom is rewritten by replacing a expression by a expression, any positive nonmonotonic dl-atom is negated twice, which emulates “double negation” in nested expressions [Lifschitz, Tang,  TurnerLifschitz et al.1999].777A similar logic treatment has been found in a number of recent approaches to the semantics of various classes of logic programs, e.g., in the “double negation” interpretation of weight constraint programs [Ferraris  LifschitzFerraris  Lifschitz2005, Liu  YouLiu  You2011].

Although the translation provides an interesting characterization, due to the difficulty of checking the monotonicity of a dl-atom, for an arbitrary dl-program the translation can be expensive as it depends on checking the entailment relation over the underlying description logic. However, for the class of normal dl-programs, takes polynomial time since checking the monotonicity of dl-atoms amounts to checking the existence of the constraint operator, and predicates occurring in dl-atoms have the arity at most 2.

We now proceed to show some properties of the translation .

For any dl-program , has no nonmonotonic dl-atoms left. Thus, by Theorem 4.13 of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008], we have

###### Proposition 4

Let be a dl-program. If is a strong answer set of then is minimal, i.e, there is no such that is a strong answer set of .

Proof: It is evident by Theorem 4.13 of [Eiter, Ianni, Lukasiewicz, Schindlauer,  TompitsEiter et al.2008] and .

The dl-programs in the above example show that the translation preserves both strong and weak answer sets of a given dl-program in the extended language, i.e., the strong and weak answer sets of are those of when restricted to the language of . In what follows, we formally build up a one-to-one mapping between answer sets of a dl-program and those of .

For convenience, given a dl-program and , we denote where

 π1(I)={πp(→c)∈HBπ(P)∣p(→c)∉I}, and π2(I)={πA∈HBπ(P)∣A∈DL?P & I⊭OA}.
###### Lemma 1

Let be a dl-program, . Then

1. for any atom occurring in

 I⊨OA  iff  I∪π1(I)⊨Oπ(A)  % iff  π(I)⊨Oπ(A);
2. for any dl-atom occurring in ,

 I⊨OA  iff  I∪π1(I)⊨ODL[π(λ);Q](→t)  iff  π(I)⊭Oπ(notA).

Proof: (i) It is obvious since and predicates of the form and do not occur in .

(ii) If there is no constraint operator occurring in then . Thus in this case, it is trivial as predicates of the form and do not occur in , and .

Suppose there exists at least one constraint operator in . It is clear that