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 firstorder 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 inferencebased communication is via a welldesigned interface, called dlatoms [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 dlprograms adopts such interfaces to ontology knowledge bases. It is worth noticing that dlprograms share many similarities with another recent interesting formalism, called nonmonotonic multicontext systems, in which knowledge bases under arbitrary logics communicate through bridge rules [Brewka EiterBrewka Eiter2007].
Informally, a dlprogram 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 dlatoms. Such queries allow to specify inputs from a logic program to the ontology knowledge base. In more detail, a dlatom is of the form
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 dlprograms [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 hereandthere [Fink PearceFink Pearce2010].
The interest in dlprograms is also due to a technical aspect  it has been a challenging task to embed dlprograms 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 dlprograms they only showed that if a dlprogram does not contain the constraint operator , then it can be translated to a (hybrid) MKNF knowledge base while preserving its strong answer sets.^{1}^{1}1The 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 onetoone correspondence. The embedding into quantified equilibrium logic in [Fink PearceFink Pearce2010] is under the assumption that all dlatoms containing an occurrence of are nonmonotonic. They do not deal with the case when a dlatom involving may be monotonic. The embedding into firstorder 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 firstorder autoepistemic logic together with the embedding of dlprograms into MKNF. Thus it only handles the dlprograms without the constraint operator.
In this paper, we investigate the possibility of embedding dlprograms 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 firstorder 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 querybased, the question arises as whether default logic can be viewed as a foundation for querybased approaches to integration of ontologies and rules.
We shall note that the problem of embedding dlprograms into default logic is nontrivial. In fact, given the difficulties in dealing with dlprograms 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 dlprograms 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 dlprograms and observe that the constraint operator is the only one causing a dlatom to be nonmonotonic, and a dlatom may still be monotonic even though it mentions the constraint operator . To eliminate from nonmonotonic dlatoms, we propose a translation and show that, given a dlprogram , 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 dlprograms, the class of normal dlprograms, can be translated to MKNF knowledge bases, where a dlprogram is normal if it has no monotonic dlatoms that mention the constraint operator .
For the weak answer set semantics, the translation above can be relaxed so that all dlatoms 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 dlatom 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 dlprograms under strong answer sets into quantified equilibrium logic.
In the second step, we present two approaches to translating dlprograms to default theories in a polynomial, faithful, and modular manner [JanhunenJanhunen1999].^{2}^{2}2This means a polynomial time transformation that preserves the intended semantics, uses the symbols of the original language, and translates parts (modules) of the given dlprogram 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 dlprograms, in the second approach nontrivial answer sets may still exist in the case of an inconsistent ontology knowledge base. We show that, for a dlprogram without nonmonotonic dlatoms, there is a onetoone 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 dlprograms under the strong answer set semantics can be embedded into default logic.
It has been argued that some strong answers may incur selfsupports. To overcome this blemish, weakly and strongly wellsupported answer set semantics are recently proposed [ShenShen2011]. Surprisingly, dlprograms under the weakly wellsupported 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 dlatoms do not appear in the scope of the default negation , the strongly wellsupported semantics coincides with the weakly wellsupported 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 wellsupported semantics as well.
We note that, in embedding dlprograms without nonmonotonic dlatoms into default logic, one still can use the negationasfailure operator in dlprograms to express nonmonotonic inferences. The same assumption was adopted in defining a wellfounded semantics for dlprograms [Eiter, Lukasiewicz, Ianni, SchindlauerEiter et al.2011]. Under this assumption, all the major semantics for dlprograms 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 dlprograms under various semantics by default logic, but also strengthen the prospect that the latter can serve as a foundation for querybased integration of rules and ontologies.
The main advantage of using default logic to characterize integration of ontology and rules in general, and semantics of dlprograms 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 ASPbased 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 dlprograms in default logic leads to new insights in computation for dlprograms, one of which is that the iterative construction of default extensions provides a direct support to wellsupportedness 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 dlprograms 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 dlprograms into default logic, we present faithful and modular [JanhunenJanhunen1999] translations for the strong answer set semantics, the weak answer set semantics and the weakly wellsupported 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 dlatoms and is polynomial relative to this knowledge, i.e., if the set of monotonic dlatoms is known. In general, determining this set is intractable; as we show, determining whether a dlatom is monotonic is EXPcomplete 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 dlprogram 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 wellsupported semantics, there are broad classes of dlprograms for which a polynomial embedding can be easily inferred from our results. For the class of dlprograms where nonmonotonic dlatoms do not appear in the scope of default negation , our embedding is polynomial, faithful, and modular under the strongly wellsupported semantics; and for the class of dlprograms where the constraint operator does not appear in a positive dlatom 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 dlprograms. In Section 3, we present a transformation to eliminate the constraint operator from nonmonotonic dlatoms. In Section 4, we give transformations from dlprograms 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, PatelSchneiderBaader 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 classbased (conceptbased) 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 firstorder 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 firstorder 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 dlatom is an expression of the form
(1) 
where

each is either a concept, a role or its negation,^{3}^{3}3 We allow negation of a role for convenience, so that we can replace “” with an equivalent form “” in dlatoms. 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 dlquery, 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 dlrule (or simply a rule) is an expression of the form
(2) 
where is an atom, each is an atom^{4}^{4}4Different from that of [Eiter, Ianni, Lukasiewicz, Schindlauer, TompitsEiter et al.2008], we consider ground atoms instead of literals for convenience. or a dlatom. 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
(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 (dlprogram) consists of a DL knowledge base and a finite set of dlrules. 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 dlprogram , 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 dlatoms of and the constant symbols in . ^{5}^{5}5Note 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 dlatom under , written , if the following holds:

if , then iff ;

if is a dlatom of the form (1), then iff where and, for ,
where is a tuple of constants over . As we allow negation of role, can be replaced with in any dlatom. In addition, we can shorten as where appears in for all and . Thus dlatoms can be equivalently rewritten into ones without using the operator , and every predicate appears at most once for each operator and . For instance, the dlatom 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 dlrule of the form (3) iff for any and for any implies that . An interpretation is a model of a dlprogram , written , iff is a model of each rule of .
2.2.1 Monotonic dlatoms
A dlatom is monotonic (relative to a dlprogram ) if implies , for all such that , otherwise is nonmonotonic. It is clear that if a dlatom does not mention the constraint operator then it is monotonic. However, a dlatom may be monotonic even if it mentions the constraint operator. For example, the dlatom is a tautology (which is monotonic).
Evidently, the constraint operator is the only one that may cause a dlatom 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 dlatom of form (1) in as the complexity of deciding, given , , and an arbitrary interpretation , whether holds.
Proposition 1
Let be a (ground) dlprogram, and be a dlatom 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. DLatoms over these description logics have a query complexity that is complete for = EXP and = NEXP, respectively. By employing wellknown identities of complexity classes, we obtain the following result.
Theorem 1
Given a (ground) dlprogram and a dlatom occurring in , deciding whether is monotonic is (i) EXPcomplete, 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 dlquery evaluation can be transformed in polynomial time to deciding satisfiability of a knowledge base, which is EXPcomplete in general [TobiesTobies2001, Horrocks PatelSchneiderHorrocks PatelSchneider2003]. 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 coNEXPcomplete query complexity, which follows from NEXPcompleteness of the knowledge base satisfiability problem in (for both unary and binary number encoding; see [Horrocks PatelSchneiderHorrocks PatelSchneider2003, PrattHartmannPrattHartmann2005]). 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 dlatoms that occur in , to denote the set of monotonic dlatoms, 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 dlatoms in which are known to be monotonic, while denotes the set of remaining dlatoms. Thus is allowed to contain monotonic dlatoms 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 dlprograms
A dlprogram is positive, if (i) is “not”free, and (ii) every dlatom is monotonic relative to . Positive dlprograms have attractive semantics properties; e.g., it is evident that a positive dlprogram has a (set inclusion) least model.
From the results above, we easily obtain the following results on recognizing positive dlprograms.
Proposition 2
Deciding whether a given (not necessarily ground) dlprogram is positive is in coNP, if every dlatom 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 dlatom 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) dlprogram is positive is (i) EXPcomplete, 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 dlprogram iff is positive.
Thus, the test whether a dlprogram is positive (and similarly, whether all dlatoms in it are monotonic) for and knowledge bases is also not expensive compared to basic reasoning tasks.
Besides positive dlprograms, another important subclass are canonical dlprograms, where a dlprogram is canonical, if mentions no constraint operator. Clearly, canonical dlprograms are easy to recognize. The same holds for the more general class of normal dlprograms, where a dlprogram is normal, if no monotonic dlatom occurs in that mentions the constraint operator. Note that normal dlprograms are not positive in general; since monotonic dlatoms mentioning the constraint operator are rather exceptional, the normal dlprograms include most dlprograms relevant for practical applications.
Example 1
Consider the following dlprograms, which we will refer to repeatedly in the sequel.

where and . The single dlatom 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 dlatom in is nonmonotonic, hence is also not positive. However, is normal.
2.2.3 Strong and weak answer sets
Let be a positive dlprogram. The immediate consequence operator is defined as, for any ,
Since is monotonic, the least fixpoint of always exists which is the least model of . By we denote the least fixpoint 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 dlprograms. Let be a dlprogram. The strong dltransform of relative to and an interpretation , denoted by , is the positive dlprogram ), where is obtained from by deleting:

the dlrule of the form (2) such that either for some and , or for some ; and

the nonmonotonic dlatoms and from the remaining dlrules where is an atom or a dlatom.
The interpretation is a strong answer set of if it is the least model of , i.e., .^{6}^{6}6Note that, under our notion of , namely is the set of nonmonotonic dlatoms w.r.t. a given dlprogram, 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 dlatoms, in that given a dlprogram , 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 dltransform of relative to and an interpretation , denoted by , is the positive dlprogram , where is obtained from by deleting:

the dlrules of the form (2) such that either for some and , or for some ; and

the dlatoms and from the remaining dlrules where is an atom or dlatom.
The interpretation is a weak answer set of if is the least model of , i.e., .
The following proposition shows that, given a dlprogram , if is inconsistent then strong and weak answer sets of coincide, and are minimal.
Proposition 3
Let be a dlprogram where is inconsistent and . Then

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

The strong and weak answer sets of are minimal under set inclusion.
Proof: By the inconsistency of , it is clear that every dlatom occurring in is monotonic and for any .
(i) Note that the only difference between and is that there exist some dlatoms in but not in , i.e., for any dlrule in , belongs to if and only if belongs to where . However note that for any dlatom . 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 dlprograms in Example 1.

The dlprogram , 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 dltransformation 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 dltransformation relative to and is . Its least model is the empty set, so is not a strong answer set of .

For the dlprogram , where and , both and are strong and weak answer sets.
These dlprograms show that strong (and weak) answer sets may not be (set inclusion) minimal. It has been shown that if a dlprogram contains no nonmonotonic dlatoms 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 dlprogram 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 dlprogram 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
Note that is canonical and normal, but not positive. Intuitively, expresses reasoning by cases: regardless of whether the dlatom 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 Dlatoms
Intuitively, translating a nonmonotonic dlatom 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 dlatoms while preserving both weak and strong answer sets. As mentioned previously, we assume that the signatures and are implicitly given for a given dlprogram . Any predicate symbol not occurring in is a fresh one.
Definition 1 ()
Let be a dlprogram. We define where and , assuming is of the form (2), consists of

the rule
(4) where
in which is a fresh propositional atom, and
where is obtained from by replacing each “” with “”, and is a fresh predicate having the same arity as ;

for each nonmonotonic dlatom , the following rule:
(5) where is the same atom as mentioned in (i) and

for each predicate such that “” occurs in some nonmonotonic dlatom of , the instantiations of the rule:
(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 dlatom can be reexpressed by a monotonic dlatom and “not”. Note that may still contain dlatoms with the constraint operator, but they are all monotonic dlatoms.
Example 4
Let us consider the following dlprograms.

Let where consists of
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
Recall that the dlatom 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
The strong and weak answer sets of are and . They correspond to and respectively when restricted to .

Let be the dlprogram in Example 1. Then where consists of
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 dlatom is rewritten by replacing a expression by a expression, any positive nonmonotonic dlatom is negated twice, which emulates “double negation” in nested expressions [Lifschitz, Tang, TurnerLifschitz et al.1999].^{7}^{7}7A 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 dlatom, for an arbitrary dlprogram the translation can be expensive as it depends on checking the entailment relation over the underlying description logic. However, for the class of normal dlprograms, takes polynomial time since checking the monotonicity of dlatoms amounts to checking the existence of the constraint operator, and predicates occurring in dlatoms have the arity at most 2.
We now proceed to show some properties of the translation .
For any dlprogram , has no nonmonotonic dlatoms left. Thus, by Theorem 4.13 of [Eiter, Ianni, Lukasiewicz, Schindlauer, TompitsEiter et al.2008], we have
Proposition 4
Let be a dlprogram. 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 dlprograms in the above example show that the translation preserves both strong and weak answer sets of a given dlprogram 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 onetoone mapping between answer sets of a dlprogram and those of .
For convenience, given a dlprogram and , we denote where
Lemma 1
Let be a dlprogram, . Then

for any atom occurring in

for any dlatom occurring in ,
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
Comments
There are no comments yet.