# Answer Sets for Logic Programs with Arbitrary Abstract Constraint Atoms

In this paper, we present two alternative approaches to defining answer sets for logic programs with arbitrary types of abstract constraint atoms (c-atoms). These approaches generalize the fixpoint-based and the level mapping based answer set semantics of normal logic programs to the case of logic programs with arbitrary types of c-atoms. The results are four different answer set definitions which are equivalent when applied to normal logic programs. The standard fixpoint-based semantics of logic programs is generalized in two directions, called answer set by reduct and answer set by complement. These definitions, which differ from each other in the treatment of negation-as-failure (naf) atoms, make use of an immediate consequence operator to perform answer set checking, whose definition relies on the notion of conditional satisfaction of c-atoms w.r.t. a pair of interpretations. The other two definitions, called strongly and weakly well-supported models, are generalizations of the notion of well-supported models of normal logic programs to the case of programs with c-atoms. As for the case of fixpoint-based semantics, the difference between these two definitions is rooted in the treatment of naf atoms. We prove that answer sets by reduct (resp. by complement) are equivalent to weakly (resp. strongly) well-supported models of a program, thus generalizing the theorem on the correspondence between stable models and well-supported models of a normal logic program to the class of programs with c-atoms. We show that the newly defined semantics coincide with previously introduced semantics for logic programs with monotone c-atoms, and they extend the original answer set semantics of normal logic programs. We also study some properties of answer sets of programs with c-atoms, and relate our definitions to several semantics for logic programs with aggregates presented in the literature.

## Authors

• 1 publication
• 1 publication
• 1 publication
• ### Semantics and Compilation of Answer Set Programming with Generalized Atoms

Answer Set Programming (ASP) is logic programming under the stable model...
05/06/2014 ∙ by Mario Alviano, 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

• ### Embedding Description Logic Programs into Default Logic

Description logic programs (dl-programs) under the answer set semantics ...
11/07/2011 ∙ by Yisong Wang, et al. ∙ 0

• ### Two New Definitions of Stable Models of Logic Programs with Generalized Quantifiers

We present alternative definitions of the first-order stable model seman...
01/08/2013 ∙ by Joohyung Lee, et al. ∙ 0

• ### Random Logic Programs: Linear Model

This paper proposes a model, the linear model, for randomly generating l...
06/23/2014 ∙ by Kewen Wang, et al. ∙ 0

• ### The Good, the Bad, and the Odd: Cycles in Answer-Set Programs

Backdoors of answer-set programs are sets of atoms that represent clever...
02/15/2012 ∙ by Johannes Klaus Fichte, et al. ∙ 0

• ### Properties of Answer Set Programming with Convex Generalized Atoms

In recent years, Answer Set Programming (ASP), logic programming under t...
12/20/2013 ∙ by Mario Alviano, 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 and Motivation

Logic programming under the answer set semantics has been introduced as an attractive and suitable knowledge representation language for AI research [BaralBaral2005], as it offers several desirable properties for this type of applications. Among other things, the language is declarative and it has a simple syntax; it naturally supports non-monotonic reasoning, and it is sufficiently expressive for representing several classes of problems (e.g., normal logic programs capture the class of NP-complete problems); it has solid theoretical foundations with a large body of building block results (e.g., equivalence between programs, systematic program development, relationships to other non-monotonic formalisms), which is extremely useful in the development and validation of large knowledge bases; it also has a large number of efficient computational tools. For further discussion of these issues, the interested reader is referred to the book of Baral Baral03, the overview paper of Gelfond and Leone GelfondL02, the paper of Marek and Truszczyński MarekT99, and the paper of Niemelä Niemela99.

A large number of extensions of logic programming, aimed at improving its usability in the context of knowledge representation and reasoning, have been proposed. The Smodels system introduces weight and cardinality constraint atoms to facilitate the encoding of constraints on atom definitions [Simons, Niemelä,  SoininenSimons et al.2002]. These constructs can be generalized to aggregates; aggregates have been extensively studied in the general context of logic programming by the work of (see, e.g., KempS91,MumickPR90,Gelder92), and further developed in recent years (see, e.g., Dell-ArmiFILP03,DeneckerPB01,ElkabaniPS04,FaberLP04,a-prolog,Pelov04,SonP05). Both dlv [Eiter, Leone, Mateis, Pfeifer,  ScarcelloEiter et al.1998] and Smodels have been extended to deal with various classes of aggregates [Dell’Armi, Faber, Ielpa, Leone,  PfeiferDell’Armi et al.2003, Elkabani, Pontelli,  SonElkabani et al.2005]. The semantics of these extensions have been defined either indirectly, by translating programs with these extensions to normal logic programs, or directly, by providing new characterizations of the concept of answer sets for programs with such extensions.

Each of the above mentioned extensions to logic programming has been introduced to facilitate the representation of a desirable type of knowledge in logic programming. As such, it is not a surprise that the focus has been on the definition of the semantics and little has been done to investigate the basic building block results for the new classes of logic programs. In this context, the study of a uniform framework covering various classes of extensions will provide us with several benefits. For example, to prove (or disprove) whether a basic building block result (e.g., splitting theorem) can be extended to the new classes of logic programs, we will need to prove (or disprove) this result only once; new results in the study of the generic framework are applicable to the study of one of the aforementioned extensions; etc. Naturally, for these studies to be possible, a uniform framework whose semantical definition exhibits the behavior of various extensions of logic programming, needs to be developed. The main goal in this paper is to address this issue.

The concept of logic programs with abstract constraint atoms (or c-atoms) has been introduced by Marek, Remmel, and Truszczyński as an elegant theoretical framework for investigating, in a uniform fashion, various extensions of logic programming, including cardinality constraint atoms, weight constraint atoms, and more general forms of aggregates [Marek  RemmelMarek  Remmel2004, Marek  TruszczyńskiMarek  Truszczyński2004]. Intuitively, a c-atom represents a constraint on models of the program containing —and the description of includes an explicit description of what conditions each interpretation has to meet in order to satisfy . This view is very general, and it can be shown to subsume the description of traditional classes of aggregates (e.g., Sum, Count, Min, etc.).111One could also argue that c-atoms and general aggregates capture analogous notions. Thus, programs with weight constraint atoms or other aggregates can be represented as logic programs with c-atoms.

The first explicit definition of answer sets for positive programs with arbitrary c-atoms (i.e., programs without the negation-as-failure operator)—called programs with set constraints or SC-programs—has been introduced in the work of Marek and Remmel MarekR04. In this work answer sets for programs with c-atoms are defined by extending the notion of answer sets for programs with weight constraint atoms proposed in the work of Niemelä, Simons, and Soininen nie99b. Nevertheless, this approach provides, in certain cases, unintuitive answer sets (see, e.g., Examples 7 and 20). In particular, the approach of Marek and Remmel does not naturally capture some of the well-agreed semantics for aggregates. One of our main goals in this paper is to investigate alternative solutions to the problem of characterizing answer sets for programs with arbitrary c-atoms. Our aim is to match the semantics provided in the more recent literature for monotone c-atoms, and to avoid the pitfalls of the approach developed in the work of Marek and Remmel MarekR04.

The concept of answer sets for programs with c-atoms has been later revisited by Marek and Truszczyński MarekT04, focusing on answer sets for programs with monotone constraint atoms, where a c-atom is monotone if, for each pair of interpretations and with , we have that satisfies implies that satisfies . This proposal has been further extended to the case of disjunctive logic programs with monotone c-atoms [Pelov  TruszczyńskiPelov  Truszczyński2004]. In another paper [Liu  TruszczyńskiLiu  Truszczyński2005b], it is extended to deal with convex c-atoms where a c-atom is convex if, for every pair of interpretations and with , we have that and satisfy implies that satisfies for every . This paper also proves several properties of programs with monotone and convex c-atoms. It is shown that many well-known properties of standard logic programming under answer set semantics are preserved in the case of programs with monotone c-atoms.

The main advantage of focusing on monotone c-atoms lies in that monotonicity provides a relatively simpler way for defining answer sets of logic programs with c-atoms. On the other hand, this restriction does not allow several important classes of problems to be directly expressed. For example222 Although variables appear in the definition of aggregates, they are locally quantified. As such, an aggregate literal is nothing but a shorthand of a collection of ground terms. , the aggregate atom cannot be viewed as a monotone aggregate atom—since monotonic extensions of the definition of might make the aggregate false; e.g., the aggregate is true if is the definition of , but it becomes false if we consider a definition containing . Similarly, the cardinality constraint atom is not a monotone constraint. Neither of these two examples can be directly encoded using monotone c-atoms.

The studies in MarekR04,MarekT04 and in LiuT05 lead to the following question: “what are the alternatives to the approach to defining answer sets of programs with arbitrary c-atoms developed by MarekR04?” Furthermore, will these alternatives—if any— capture the semantics of programs with monotone c-atoms proposed by MarekT04 and avoid the pitfalls of the notion of answer sets for arbitrary c-atoms in MarekR04?

We present two equivalent approaches for defining answer sets for logic programs with arbitrary c-atoms.

• The first approach is inspired by the notion of conditional satisfaction—originally developed in SonP05—to characterize the semantics of logic programs with aggregates. We generalize this notion to the case of programs with c-atoms. The generalization turns out to be significantly more intuitive and easier to understand than the original definition in SonP05. Using this notion, we define an immediate consequence operator for answer set checking.

• The second approach is inspired by the notion of well-supportedness, proposed by Fages Fages94 for normal logic programs.

The approaches are very intuitive, and, we believe, they improve over the only other semantics proposed for logic programs with arbitrary c-atoms in MarekR04.

We show that the newly defined semantics coincide with the previously introduced semantics in MarekT04 in the case of programs with monotone c-atoms, and they extend the original stable model semantics for normal logic programs. We discuss different approaches for treating negation-as-failure c-atoms. We also relate our definitions to several semantics for logic programs with aggregates, since the notion of c-atom can be used to encode arbitrary aggregates. These results show that the proposed framework naturally subsumes many existing treatments of aggregates in logic programming.

In summary, the main contributions of the paper are:

• A new notion of fixpoint answer set for programs with arbitrary c-atoms, which is inspired by the fixpoint construction proposed in SonP05 (but simpler) and which differs significantly from the only proposal for programs with arbitrary c-atoms in MarekR04; this will lead to two different definitions of answer sets (answer set by reduct and answer set by complement);

• A generalization of the notion of well-supported models in Fages94 to programs with arbitrary c-atoms, which—to the best of our knowledge—has not been investigated by any other researchers, which leads to the notions of weakly and strongly well-supported models;

• A result showing that the set of answer sets by reduct (resp. by complement) is equivalent to the set of weakly (resp. strongly) well-supported models; and

• A number of results showing that the newly defined notions of answer sets capture the answer set semantics of various extensions to logic programming, in those cases all the previously proposed semantics agree.

The rest of this paper is organized as follows. Section 2 presents preliminary definitions, including the syntax of the language of logic programming with c-atoms, the basic notion of satisfaction, and the notion of answer set for programs with monotone c-atoms in MarekT04 and for positive programs with arbitrary c-atoms in MarekR04. Section 3 presents our first approach to defining answer sets for logic programs with arbitrary c-atoms based on a fixpoint operator, while Section 4 introduces an alternative definition based on well-supportedness. Section 5 extends the semantics to programs with arbitrary c-atoms in the head of rules. Section 6 relates the semantics presented in this paper with early work on abstract constraint atoms and aggregates. Section 7 provides conclusions and future work. Proofs of theorems and propositions are deferred to the appendix.

## 2 Preliminaries—Logic Programs with Abstract Constraint Atoms

We follow the syntax used in LiuT05 to define programs with abstract constraint atoms. Throughout the paper, we assume a fixed propositional language with a countable set of propositional atoms.

### 2.1 Syntax

An abstract constraint atom (or c-atom) is an expression of the form , where is a set of atoms (the domain of the c-atom), and is a collection of sets of atoms belonging to , i.e., (the solutions of the c-atom). Intuitively, a c-atom is a constraint on the set of atoms , and represents its admissible solutions. Given a c-atom , we use and to denote and , respectively.

A c-atom of the form is called an elementary c-atom and will be simply written as . A c-atom of the form , representing a constraint which does not admit any solutions, will be denoted by . A c-atom is said to be monotone if for every , implies that .

A rule is of the form

 A←A1,…,Ak,notAk+1,…,notAn (1)

where , ’s are c-atoms. The literals () are called negation-as-failure c-atoms (or naf-atoms). For a rule of the form (1), we define:

• ,

• ,

• ,

• .

For a program , denotes the set .

We recognize special types of rules:

1. A rule is positive if ;

2. A rule is basic if is an elementary c-atom;

3. A rule is a constraint rule if .

A logic program with c-atoms (or logic program, for simplicity)333Whenever we want to refer to traditional logic programs (without c-atoms), we will explicitly talk about normal logic programs. is a set of rules. A program is called a basic program if each rule is a basic or a constraint rule. is said to be positive if every rule in is positive. is monotone (resp. naf-monotone) if each c-atom occurring in (resp. in a naf-atom in ) is monotone. Clearly, a monotone program is also naf-monotone.

### 2.2 Models and Satisfaction

In this subsection, we introduce the basic definitions for the study of logic programs with constraints. We will begin with the definition of the satisfaction of c-atoms. We then introduce the notion of a model of programs with c-atoms.

#### 2.2.1 Satisfaction of C-Atoms

A set of atoms satisfies a c-atom , denoted by , if . satisfies , denoted by , if .

It has been shown in MarekR04 and in MarekT04 that the notion of c-atom is more general than extended atoms such as cardinality constraint atoms and aggregate atoms; thus, c-atoms can be used to conveniently represent weight constraints, cardinality constraints [Simons, Niemelä,  SoininenSimons et al.2002], and various other classes of aggregates, such as maximal cardinality constraints. For example,

• Let us consider an arbitrary choice atom of the form ; this can be represented by the c-atom where:

• Let us consider an arbitrary aggregate of the form where is a set function (e.g., Sum, Avg), is a number, and is a comparison operation (e.g., ). This can be represented by the c-atom , where:

###### Example 1

Let us consider the aggregate , defined in a language where . From the considerations above, we have that this aggregate can be represented by the c-atom where

 S={T|T⊆{p(1),p(−2)},\textscsum(T)≥−1}={∅,{p(1)},{p(−2),p(1)}}

###### Example 2

Let us consider the cardinality constraint atom . This can be represented by the c-atom where

 S={T∣T⊆{p(1),p(−1)},1≤|(T∩{p(1),p(−1)}|≤1}={{p(1)},{p(−1)}}

C-atoms allow us to compactly represent properties that would require complex propositional combinations of traditional aggregates. E.g., a condition like “either all elements or no elements of the set are true” can be simply written as the single c-atom . Further motivations behind the use of c-atoms can be found in MarekR04 and MarekT04.

In the rest of the paper, we will often use in our examples the notation of cardinality constraint atoms, weight constraint atoms, or general aggregate atoms instead of c-atoms, whenever no confusion is possible.

#### 2.2.2 Models

A set of atoms satisfies the body of a rule of the form (1), denoted by , if for and for . satisfies a rule if it satisfies or if it does not satisfy .

A set of atoms is a model of a program if satisfies every rule of . is a minimal model of if it is a model of and there is no proper subset of which is also a model of . In particular, programs may have more than one minimal model (see, for example, Example 5).

Given a program , a set of atoms is said to support an atom if there exists some rule in and such that the following conditions are met:

• ,

• , and

• .

###### Example 3

Let 444Remember that the notation is a short form for the c-atom . be the program

 p(a)←p(b)←p(c)←qq←\sc Count({X∣p(X)})>2

The aggregate notation represents the c-atom where . has two models:

 M1={p(a),p(b),p(c),q}M2={p(a),p(b)}

is a minimal model of , while is not.

###### Example 4

Let be the program

 p(1)←p(−1)←p(2)p(2)←\textscSum({X∣p(X)})≥1

The aggregate notation represents the c-atom where

 D={p(1),p(2),p(−1)}andC=\omit\span\omit\span\omit{{p(1)},{p(2)},{p(1),p(2)},{p(2),p(−1)},{p(1),p(2),p(−1)}}

Because of the first rule, any model of will need to contain . It is easy to see that and are models of but is not a model of .

###### Example 5

Let be the program

 p←({q},{∅})q←({p},{∅})

has three models , , and , of which and are minimal.

### 2.3 Previously Proposed Semantics

In this section, we will overview the semantical characterizations for programs with c-atoms proposed in the existing literature. In particular, we will review the notion of answer sets for monotone programs (i.e., program that contain only monotone c-atoms), as defined in MarekT04. A formal comparison between these semantics and the novel approach we propose in this paper is described in Section 6.

Given a set of atoms , a rule is applicable in if . The set of applicable rules in is denoted by . A set is nondeterministically one-step provable from by means of if and for every . The nondeterministic one-step provability operator is a function from to such that for every , consists of all sets that are nondeterministically one-step provable from by means of .

A -computation is a sequence where and for every non-negative integer ,

• (i) , and

• (ii)

is called the result of the computation . A set of atoms is a derivable model of if there exists a -computation such that . The Gelfond-Lifschitz reduct for normal logic programs is generalized to monotone programs as follows.

###### Definition 1

Let be a monotone program. For a set of atoms , the reduct of with respect to , denoted by , is obtained from by

1. removing from every rule containing in the body a literal such that ; and

2. removing all literals of the form from the remaining rules.

Answer sets for monotone programs are defined next.

###### Definition 2

A set of atoms is an answer set of a monotone program if is a derivable model of the reduct .

The next example shows that, for programs with non-monotone c-atoms, Definition 2 is, in general, not applicable.

###### Example 6

Consider the program from Example 5. We can check that this program does not allow the construction of any -computation. In fact, and . Hence, would not be an answer set of (according to Definition 2) since it is not a derivable model of the reduct of with respect to (which is ).

On the other hand, it is easy to see that is intuitively equivalent to the normal logic program . As such, should accept as one of its answer sets.

The main reason for the inapplicability of Definition 2 lies in that the nondeterministic one-step provability operator might become non-monotone in the presence of non-monotone c-atoms.

### 2.4 Answer Sets for Positive Programs

Positive programs are characterized by the lack of negation-as-failure atoms. Positive programs with arbitrary c-atoms have been investigated in MarekR04, under the name of SC-programs. Let us briefly review the notion of answer sets for SC-programs—which, in turn, is a generalization of the notion of answer sets for logic programs with weight constraints, as presented in nie99b. A detailed comparison between the approach in MarekR04 and our work is given in Section 6.

For a c-atom , the closure of , denoted by , is the c-atom

Intuitively, the closure is constructed by including all the supersets of the existing solutions.

A c-atom is said to be closed if . A rule of the form (1) is a Horn-rule if (i) its head is an elementary c-atom; and (ii) each c-atom in the body is a closed c-atom. A SC-program is said to be a Horn SC-program if each rule in is a Horn-rule. The one-step provability operator, defined by , associated to a Horn SC-program is monotone. Hence, every Horn SC-program has a least fixpoint which is the only minimal model of (w.r.t. set inclusion). Given a set of atoms and a SC-program , the NSS-reduct of with respect to , denoted by , is obtained from by

• removing all rules whose body is not satisfied by ; and

• replacing each rule

 A←e1,…,en,A1,…,Am

where ’s are elementary c-atoms and ’s are non-elementary c-atoms by the set of rules

A model of a program is an answer set of if it is the least fixpoint of the one-step provability operator of the program , i.e., . It sometimes yields answer sets that are not accepted by other extensions to logic programming. The next example illustrates this point.

###### Example 7

Consider the program :

 c←a←({a,c},{∅,{a,c}})

We have that and are models of . Furthermore, is the program

 c←

and consists of the rules

 c←a←({a,c},{∅,{a},{c},{a,c})}

It is easy to see that and . Thus, observe that has a non-minimal answer set according to MarekR04. Note that the program can be viewed as the following program with aggregates

 c←a←\textscCount({a,c})≠1

which does not have as an answer set under most of the proposed semantics for aggregates [Denecker, Pelov,  BruynoogheDenecker et al.2001, Faber, Leone,  PfeiferFaber et al.2004, FerrarisFerraris2005, PelovPelov2004, Son  PontelliSon  Pontelli2007]. Furthermore, all these approaches accept as the only answer set of this program.

## 3 Answer Sets for Basic Programs: A Fixpoint Based Approach

In this section, we define the notion of answer sets of basic programs. In this approach, we follow the traditional way for defining answer sets of logic programs, i.e., by:

1. first characterizing the semantics of positive programs (Definition 4), and then

2. extending it to deal with naf-atoms (Definitions 7 and 8).

### 3.1 Answer Sets for Basic Positive Programs

Example 5 shows that a basic positive program might have more than one minimal model. This leads us to define a -like operator for answer set checking, whose construction is based on the following observation.

###### Observation 1

Let be a propositional normal logic program (i.e., without c-atoms)555For a rule from a normal logic program ,

, , and denote , , and , respectively.
and let be two sets of atoms. Given a set of atoms , we define the operator and the monotone sequence of interpretations as follows.

Let us denote with the limit of this sequence of interpretations. It is possible to prove that is an answer set of w.r.t. GelfondL88 iff .

As we can see from the above observation, the (modified) consequence operator takes two sets of atoms, and , as its arguments, and generates one set of atoms which could be viewed as the consequences of given that is true and is assumed to be an answer set of . It is easy to see that is monotone w.r.t. its first argument, i.e., if , then . Thus, the sequence is monotone and converges to for a given . We will next show how can be generalized to programs with c-atoms.

Observe that the definition of requires that or, equivalently, . For normal logic programs, this is sufficient to guarantee the monotonicity of . If this definition is naively generalized to the case of programs with c-atoms, the monotonicity of is guaranteed only under certain circumstances, e.g., when c-atoms in are monotone. To deal with arbitrary c-atoms, we need to introduce the notion of conditional satisfaction of a c-atom.

###### Definition 3 (Conditional Satisfaction)

Let and be sets of atoms. The set conditionally satisfies a c-atom w.r.t. , denoted by , if

1. and,

2. for every such that and , we have that .

Observe that this notion of conditional satisfaction has been inspired by the conditional satisfaction used to characterize aggregates in SonP05, but it is significantly simpler.

We say that conditionally satisfies a set of c-atoms w.r.t. , denoted by , if for every . Intuitively, implies that for every such that . Thus, conditional satisfaction ensures that if the body of a rule is satisfied in then it is also satisfied in , provided that . This allows us to generalize the operator defined in Observation 1 as follows. For a set of atoms and a positive basic program , let

The following proposition holds.

###### Proposition 1

Let be a model of , and let . Then

Let and, for , let

 Ti+1P(∅,M)=TP(TiP(∅,M),M)

Then, the following corollary is a natural consequence of Proposition 1.

###### Corollary 1

Let be a positive, basic program and be a model of . Then, we have

 T0P(∅,M)⊆T1P(∅,M)⊆⋯⊆M

The above corollary implies that the sequence is monotone and limited (w.r.t. set inclusion) by . Therefore, it converges to a fixpoint. We denote this fixpoint by .

###### Definition 4

Let be a model of a basic positive program . is an answer set of iff .

Observe that the constraint rules present in (i.e., rules whose head is ) do not contribute to the construction performed by ; nevertheless, the requirement that should be a model of implies that all the constraint rules will have to be satisfied by each answer set. We illustrate Definition 4 in the next examples.

###### Example 8

Consider the program from Example 3.

• is an answer set of since:

 T0P1(∅,M1)=∅T1P1(∅,M1)={p(a),p(b)}=M1T2P1(∅,M1)=TP1({p(a),p(b)},M1)=M1
• is not an answer set of , since:

 T0P1(∅,M2)=∅T1P1(∅,M2)={p(a),p(b)}=M1T2P1(∅,M2)=TP1({p(a),p(b)},M2)=M1

###### Example 9

Consider again the program (Example 5). Let and . We have that

 T0P3(∅,M1)=∅T0P3(∅,M2)=∅T1P3(∅,M1)={p}=M1T1P3(∅,M2)={q}=M2

Thus, both and are answer sets of . On the other hand, for , we have that because and . Hence, is not an answer set of .

We conclude this section by observing that the answer sets obtained from the above construction are minimal models.

###### Corollary 2

Let be a positive basic program and be an answer set of . Then, is a minimal model of .

The next example shows that not every positive program has an answer set.

###### Example 10

Consider (Example 4). Since answer sets of positive programs are minimal models (Corollary 2) and is the only minimal model of , we have that is the only possible answer set of . Since

 T0P2(∅,M)=∅T1P2(∅,M)={p(1)}T2P2(∅,M)=TP2({p(1)},M)={p(1)}

we can conclude that is not an answer set of . Thus, does not have answer sets.

The example highlights that supportedness, in our approach, is not a sufficient condition for being an answer set— is a supported model, but it is not accepted as an answer set. The reason for rejecting is the fact that the element is essentially self-supporting itself (cyclically) in . Note that is rejected, as an answer set, in most approaches to aggregates in logic programming—e.g., the approach in FaberLP04 rejects for not being a minimal model of the FLP-reduct of the program.

### 3.2 Answer Sets for Basic Programs

We will now define answer sets for basic programs, i.e., programs with elementary c-atoms in the head of the rules, and rule bodies composed of c-atoms and naf-atoms.

In the literature, two main approaches have been considered to deal with negation of aggregates and of other complex atoms. Various extensions of logic programming (e.g., weight constraints in sim02 and aggregates in FaberLP04) support negation-as-failure atoms by replacing each naf-atom with a c-atom , where is obtained from by replacing the predicate relation of with its “negation”. For example, following this approach, the negated cardinality constraint atom can be replaced by . Similarly, the negated aggregate atom can be replaced by .

On the other hand, other researchers (see, e.g., MarekT04,Ferraris05a) have suggested to handle naf-atoms by using a form of program reduct—in the same spirit as in GelfondL88.

Following these perspectives, we study two different approaches for dealing with naf-atoms, described in the next two subsections. It is worth mentioning that both approaches coincide in the case of monotone programs (Proposition 2).

#### 3.2.1 Negation-as-Failure by Complement

In this approach, we treat a naf-atom by replacing it with its complement. We define the notion of complement of a c-atom as follows.

###### Definition 5

The complement of a c-atom is the c-atom .

We next define the complement of a program .

###### Definition 6

Given a basic program , we define (the complement of ) to be the program obtained from by replacing each occurrence of in with the complement of .

The program is a basic positive program, whose answer sets have been defined in Definition 4. This allows us to define the notion of answer sets of basic programs as follows.

###### Definition 7

A set of atoms is an answer set by complement of a basic program iff it is an answer set of .

It is easy to see that each answer set of a program is indeed a minimal model of .

###### Example 11

Let us consider the program , which consists of the following rules:

 a←c←not({a,b},{{a,b}})

The complement of is

 a←c←({a,b},{∅,{a},{b}})

which has as its only answer set. Thus, is an answer set by complement of .

###### Example 12

Let be the program

 c←not1{a,b}1a←cb←a

We have that is the program

 c←({a,b},{∅,{a,b}})a←cb←a

This program does not have an answer set (w.r.t. Definition 4); thus does not have an answer set by complement.

#### 3.2.2 Negation-as-Failure by Reduction

Another approach for dealing with naf-atoms is to adapt the Gelfond-Lifschitz reduction of normal logic programs [Gelfond  LifschitzGelfond  Lifschitz1988] to programs with c-atoms—this approach has been considered in MarekT04 and Ferraris05a. We can generalize this approach to programs with arbitrary c-atoms as follows. For a basic program and a set of atoms , the reduct of P w.r.t. M () is the set of rules obtained by

1. removing all rules containing s.t. ; and

2. removing all from the remaining rules.

The program is a positive basic program. Thus, we can define answer sets for as follows:

###### Definition 8

A set of atoms is an answer set by reduct of iff is an answer set of (w.r.t. Definition 4).

###### Example 13

Let us reconsider the program from Example 11 and let us consider . If we perform a reduct, we are left with the rules

 a←c←

whose minimal model is itself. Thus, is an answer set by reduct of the program .

The next example shows that this approach can lead to different answer sets than the case of negation by complement (for non-monotone programs).

###### Example 14

Consider the program from Example 12. Let . The reduct of w.r.t. is the program

 c←a←cb←a

which has as its answer set, i.e., is an answer set by reduct of .

One consequence of the negation by reduct approach is the fact that it might lead to non-minimal answer sets—in the presence of non-monotone atoms. For instance, if we replace the atom in with , the new program is (by replacing the aggregate with a c-atom):

 p(a)←p(b)←p(c)←qq←not({p(a),p(b),p(c)},{∅,{p(a)},{p(b)},{p(c)},{p(a),p(b)},{p(b),p(c)},{p(a),p(c)}})

This program admits the following two interpretations as answer sets by reduct: and . Since , we have that a non-minimal answer set exists.

This result indicates that, for certain programs with c-atoms, there might be different ways to treat naf-atoms, leading to different semantical characterizations. This problem has been mentioned in Ferraris05a. Investigating other methodologies for dealing with naf-atoms is an interesting topic of research, that we plan to pursue in the future.

### 3.3 Properties of Answer Sets of Basic Programs

We will now show that the notion of answer sets for basic programs with c-atoms is a natural generalization of the notions of answer sets for normal logic programs. We prove that answer sets of basic positive programs are minimal and supported models and characterize situations in which these properties hold for basic programs. We begin with a result stating that, for the class of naf-monotone programs, the two approaches for dealing with naf-atoms coincide.

###### Proposition 2

Let be a basic program. Each answer set by complement of is an answer set by reduct of . Furthermore, if is naf-monotone, then each answer set by reduct of is also an answer set by complement of .

The above proposition implies that, in general, the negation-as-failure by complement approach is more ‘skeptical’ than the negation-as-failure by reduct approach, in that it may accept fewer answer sets.666Note that we use the term “skeptical” to indicate acceptance of fewer models, which is somewhat different than the use of the term in model theory. Furthermore, Examples 12 and 14 show that a minimal (w.r.t. set inclusion) answer set by reduct is not necessarily an answer set by complement of a program.

Let be a normal logic program (without c-atoms) and let be the program obtained by replacing each occurrence of an atom in with . Since is a monotone c-atom, is a monotone program. Proposition 2 implies that, for , answer sets by reduct and answer sets by complement coincide. In the next proposition, we prove that the notion of answer sets for programs with c-atoms preserves the notion of answer set for normal logic programs, in the following sense.

###### Proposition 3 (Preserving Answer Sets)

For a normal logic program , is an answer set (by complement or by reduct) of iff is an answer set of (w.r.t. the definition in GelfondL88).

The above proposition, together with Proposition 2, implies that normal logic programs can be represented by positive basic programs. This is stated in the following corollary.

###### Corollary 3

Every answer set of a normal logic program is an answer set of and vice versa.

In the next proposition, we study the minimality and supportedness properties of answer sets of basic programs.

###### Proposition 4 (Minimality of Answer Sets)

The following properties hold:

1. Every answer set by complement of a basic program is a minimal model of .

2. Every answer set by reduct of a basic, naf-monotone program is a minimal model of .

3. Every answer set (by complement/reduct) of a basic program supports each of its members.

## 4 Answer Sets for Basic Programs: A Level Mapping Based Approach

The definition of answer sets provided in the previous section can be viewed as a generalization of the answer set semantics for normal logic programs—in the sense that it relies on a fixpoint operator, defined for positive programs. In this section, we discuss another approach for defining answer sets for programs with c-atoms, which is based on the notion of well-supported models.

The notion of well-supported models for normal logic programs was introduced in Fages94, and it provides an interesting alternative characterization of answer sets. Intuitively, a model of a program is a well-supported model iff there exists a level mapping, from atoms in to the set of positive integers, such that each atom is supported by a rule , whose body is satisfied by and the level of each positive atom in is strictly smaller than the level of .777This implicitly means that and , i.e., naf-atoms are dealt with by reduct. Fages proved that answer sets are well-supported models and vice versa [FagesFages1994]. The notion of well-supportedness has been extended to deal with dynamic logic programs in BantiABH05. Level mapping has also been used as an effective tool to analyze different semantics of logic programs in a uniform way [Hitzler  WendtHitzler  Wendt2005].

In what follows, we will show that the notion of well-supported models can be effectively applied to programs with c-atoms. A key to the formulation of this notion is the answer to the following question:

“what is the level of a c-atom given a set of atoms and a level mapping of ?”

On one hand, one might argue that the level mapping of should be defined independently from the mapping of the other atoms, being an atom itself. On the other hand, it is reasonable to assume that the level of depends on the levels of the atoms in , since the satisfaction of (w.r.t. a given interpretation) depends on the satisfaction of the elements in . The fact that every existing semantics of programs with c-atoms evaluates the truth value of a c-atom based on the truth value assigned to elements of stipulates us to adopt the second view.

It is worth to mention that this view also allows us to avoid undesirable circular justifications of elements of a well-supported model: if we follow the first view, the program consisting of the following rules

 a←bb←aa←({a,b},{∅,{a,b}})

would have as a well-supported model in which , , and are supported by , , and respectively. This means that is true because both and are true, i.e., there is a circular justification for w.r.t. the model .

Let be a set of atoms, be a mapping from to positive integers, and let be a c-atom. We define , and

 L(A,M)=min({H(X)∣X∈Ac,X⊆M,X⊨MA}).

Intuitively, the “level” of each atom is given by the smallest of the levels of the solutions of the atom compatible with —where the level of a solution is given by the maximum level of atoms in the solution. We assume that , while is undefined. We will now introduce two different notions of well-supported models. The first notion, called weakly well-supported models, is a straightforward generalization of the definition given in Fages94—in that it ignores the naf-atoms. The second notion,, called strongly well-supported models, does take into consideration the naf-atoms in its definition.

###### Definition 9 (Weakly Well-Supported Model)

Let be a basic program. A model of is said to be weakly well-supported iff there exists a level mapping such that, for each , contains a rule with , , and for each , is defined and .

We illustrate this definition in the next example.

###### Example 15

Let us consider again the program and the set of atoms . Let . Obviously, is a model of . Assume that is a weakly well-supported model of . This means that there exists a mapping from to the set of positive integers satisfying the condition of Definition 9. Since and there is only one rule in with as head, we can conclude that . Observe that and . Thus, by the definition of , we have that

 L(A,M)=max({ℓ(a),ℓ(b)})=ℓ(b).

This implies that there exists no rule in , which satisfies the condition of Definition 9 and has as its head. In other words, is not a weakly well-supported model of .

The next proposition generalizes Fages’ result to answer sets by reduct for programs with c-atoms.

###### Proposition 5

A set of atoms is an answer set by reduct of a basic program iff it is a weakly well-supported model of .

As we have seen in the previous section, different ways to deal with naf-atoms lead to different semantics for basic programs with c-atoms. To take into consideration the fact that naf-atoms can be dealt with by complement, we develop an alternative generalization of Fages’s definition of a well-supported model to programs with abstract c-atoms as follows.

###### Definition 10 (Strongly Well-Supported Model)

Let be a basic program. A model of is said to be strongly well-supported iff there exists a level mapping such that, for each , contains a rule with , , for each , is defined and , and for each , is defined and ,

Using Proposition 5 and Proposition 2, we can easily show that the following result holds.

###### Proposition 6

A set of atoms is an answer set by complement of a basic program iff it is a strongly well-supported model of .

The above two propositions, together with Proposition 2, lead to the following corollary.

###### Corollary 4

For every naf-monotone basic program , each weakly well-supported model of is also a strongly well-supported model of and vice versa.

As we have discussed in the previous section, each normal logic program can be easily translated into a monotone basic program with c-atoms of the form , . Thus, Corollary 4 indicates that the notion of weakly/strongly well-supported model is indeed a generalization of Fages’s definition of well-supported model to programs with c-atoms.

## 5 Answer Sets for General Programs

General programs are programs with non-elementary c-atoms in the head. The usefulness of rules with non-elementary c-atoms in the head, in the form of a weight constraint or an aggregate, has been discussed in Ferraris05a,sim02 and in SonPE06. For example, a simple atom888 Recall that aggregates are special form of c-atoms.

 \textscCount({X∣taken(X,ai)})≤10

can be used to represent the constraint that no more than 10 students can take the AI class. The next example shows how the 3-coloring problem of a graph can be represented using c-atoms.

###### Example 16

Let the three colors be red (), blue (), and green (). The program contains the following rules:

• the set of atoms for every edge of ,

• for each vertex of , the following rule:

 ({color(u,b),color(u,r),color(u,g)},{{color(u,b)},{color(u,r)},{color(u,g)}})←

which states that must be assigned one and only one of the colors red, blue, or green.

• for each edge of , three rules representing the constraint that and must have different color:

 ⊥←color(u,r),color(v,r),edge(u,v) ⊥←color(u,b),color(v,b),edge(u,v) ⊥←color(u,g),color(v,g),edge(u,v)

We note that, with the exception of the proposals in Ferraris05a,SonPE06, other approaches to defining answer sets of logic programs with aggregates do not deal with programs with aggregates in the head. On the other hand, weight constraint and choice atoms are allowed in the head [Simons, Niemelä,  SoininenSimons et al.2002]. Similarly, c-atoms are considered as head of rules in the framework of logic programs with c-atoms by MarekR04 and by MarekT04.

In this section, we define answer sets for general programs—i.e., programs where the rule heads can be arbitrary c-atoms. Our approach is to convert a program with c-atoms in the head into a collection of basic programs, whose answer sets are defined as answer sets of . To simplify the presentation, we will talk about “an answer set of a basic program” to refer to either an answer set by complement, an answer set by reduct, or a well-supported model of the program. The distinction will be stated clearly whenever it is needed.

Let be a program, , and let be a model of . The instance of w.r.t. , denoted by is defined as follows

The instance of w.r.t. , denoted by , is the program

 inst(P,M)=⋃r∈Pinst(r,M)

It is easy to see that the instance of w.r.t. is a basic program. This allows us to define answer sets of general programs as follows.

###### Definition 11

Let be a general program. is an answer set of iff is a model of and is an answer set of .

This definition is illustrated in the next examples.

###### Example 17

Let be the program consisting of a single fact:

 ({a,b},{{a},{b}})←

Intuitively, is the choice atom in the notation of Smodels.

This program has two models, and . The instance contains the single fact

 a←

whose only answer set is . Similarly, the instance is the single fact

 b←

whose only answer set is . Thus, has the two answer sets and .

The next example shows that in the presence of non-elementary c-atoms in the head, answer sets might not be minimal.

###### Example 18

Let be the program consisting of the following rules:

 ({a,b},{{a},{b},{a,