An UnfoldingBased Semantics for Logic Programming with Aggregates
Abstract
The paper presents two equivalent definitions of answer sets for logic programs with aggregates. These definitions build on the notion of unfolding of aggregates, and they are aimed at creating methodologies to translate logic programs with aggregates to normal logic programs or positive programs, whose answer set semantics can be used to defined the semantics of the original programs.
The first definition provides an alternative view of the semantics for logic programming with aggregates described in [34, 32]. In particular, the unfolding employed by the first definition in this paper coincides with the translation of programs with aggregates into normal logic programs described in [33]. This indicates that the approach proposed in this paper captures the same meaning as the semantics discussed in [34, 32].
The second definition is similar to the traditional answer set definition for normal logic programs, in that, given a logic program with aggregates and an interpretation, the unfolding process produces a positive program. The paper shows how this definition can be extended to consider aggregates in the head of the rules.
These two approaches are very intuitive, general, and do not impose any syntactic restrictions on the use of aggregates, including support for use of aggregates as heads of program rules. The proposed views of logic programming with aggregates are simple and coincide with the ultimate stable model semantics [34, 32], and with other semantic characterizations for large classes of program (e.g., programs with monotone aggregates and programs that are aggregatestratified). Moreover, it can be directly employed to support an implementation using available answer set solvers. The paper describes a system, called , that is capable of computing answer sets of programs with arbitrary (e.g., recursively defined) aggregates. The paper also presents an experimental comparison of with another system for computing answer sets of programs with aggregates, DLV.
Contents
 1 Background and Motivation
 2 A Logic Programming Language with Aggregates
 3 Aggregate Solutions and Unfolding Semantics
 4 An Alternative Semantical Characterization

5 Related Work
 5.1 Pelov’s Approximation Semantics for Logic Program with Aggregates
 5.2 Answer Sets and Minimality Condition
 5.3 Logic Programs with Abstract Constraint Atoms
 5.4 Answer Sets for Propositional Theories
 5.5 Logic Programs with Weight Constraints
 5.6 Stratified Programs
 5.7 Monotone Programs
 5.8 Other Proposals
 6 Discussions
 7 Conclusions and Future Work
1 Background and Motivation
The handling of aggregates in Logic Programming (LP) has been the subject of intense studies in the late 80’s and early 90’s [20, 28, 36, 42, 43]. Most of these proposals focused on the theoretical foundations and computational properties of aggregate functions in LP. The recent development of the answer set programming paradigm, whose underlying theoretical foundation is the answer set semantics [14], has renewed the interest in the treatment of aggregates in LP, and led to a number of new proposals [5, 6, 10, 12, 13, 16, 26, 34, 33, 32, 39]. Unlike many of the earlier proposals, these new efforts provide a sensible semantics for programs that makes a general use of aggregates, including the presence of recursion through the aggregates and the ability to use nonmonotone aggregate functions. Most of these new efforts build on the spirit of answer set semantics for LP, and some have found their way in concrete implementations. For example, the current release (built BEN/Jan 13 2006)^{1}^{1}1http://www.dbai.tuwien.ac.at/proj/dlv of DLV handles aggregatestratified programs [5], and the system described in [10] supports recursive aggregates according to the semantics described in [20]. A prototype of the ASETProlog system, capable of supporting recursive aggregates, has also been developed [18].
Answer set semantics for LP [14] has been one of the most widely adopted semantics for normal logic programs—i.e., logic programs that allow negation as failure in the body of the rules. It is a natural extension of the minimal model semantics of positive logic programs to the case of normal logic programs. Answer set semantics provides the theoretical foundation for the recently emerging programming paradigm called answer set programming [23, 27, 29] which has proved to be useful in several applications [1, 2, 23].
A set of atoms is an answer set of the program if is the minimal model of the positive program (the reduct of with respect to ), obtained by

removing from all the rules whose body contains a negation as failure literal which is false in (i.e., ); and

removing all the negation as failure literals from the remaining rules.
The above transformation is often referred to as the GelfondLifschitz transformation.
This definition of answer sets satisfies several important properties. In particular, answer sets are

closed, i.e., if an answer set satisfies the body of a rule then it also satisfies its head;

supported—i.e., for each member of an answer set there exists a rule such that is the head of the rule and the body of is true in ;

minimal—i.e., no proper subset of an answer set is also an answer set.
It should be emphasized that the properties  are necessary but not sufficient conditions for a set to be an answer set of a program . For example, the set is not an answer set of the program 15], programs with weight constraint rules [30], and programs with aggregates (e.g., [5, 20]). It should also be mentioned that, for certain classes of logic programs (e.g., programs with weight constraints and choice rules [30] or with nested expressions [24]), is not satisfied. It is, however, generally accepted that and must be satisfied by any answer set definition for any extension of logic programs. , even though it satisfies the three properties. Nevertheless, these properties constitute the main principles that guided several extensions of the answer set semantics to different classes of logic programs, such as extended and disjunctive logic programs [
As evident from the literature, a straightforward extension of the GelfondLifschitz transformation to programs with aggregates leads to the loss of some of the properties  (e.g., presence of nonminimal answer sets [20]). Sufficient conditions, that characterize classes of programs with aggregates for which the properties  of answer sets hold, have been investigated, such as aggregatestratification and monotonicity (e.g., [28]). Alternatively, researchers have either accepted the loss of some of the properties  (e.g., acceptance of nonminimal answer sets [10, 16, 20]) or have explicitly introduced minimality or analogous properties as requirements in the definition of answer sets for programs with aggregates (e.g., [12, 13]).
The various approaches for defining answer set semantics for logic programs with arbitrary aggregates differ from each other in both the languages that are considered and in the treatment of aggregates. Some proposals accept languages in which aggregates, or atoms representing aggregates (e.g., the weight constraints in Smodelsnotation), are allowed to occur in the head of programs’ rules or as facts in [13, 26, 30], while this has been disallowed in other proposals [5, 6, 10, 12, 16, 34, 32]. The advantage of allowing aggregates in the head can be seen in the use of choice rules and weight constraints in generate and test programs. Allowing aggregates in the head can make the encoding of a problem significantly more declarative and compact. Similarly, some proposals do not consider negationasfailure literals with aggregates [10, 16].
The recent approaches for defining answer sets for logic programs with arbitrary aggregates can be roughly divided into three different groups. The first group can be viewed as a straightforward generalization of the work in [14], by treating aggregates in the same way as negationasfailure literals. Belonging to this group are the proposals in [10, 16, 20]. A limitation of this approach is that it leads to the acceptance of unintuitive answer sets, in presence of recursion through aggregates. Another line of work is to replace aggregates with equivalent formulae, according to some notion of equivalence, and to reduce programs with aggregates to programs for which the semantics has already been defined [10, 13, 33]. A third direction is to make use of novel semantic constructions [6, 34, 32, 12, 26, 39].
The objective of this paper is to investigate an alternative characterization of the semantics of logic programs with unrestricted use of aggregates. In this context, aggregates are simply viewed as a syntactic sugar, representing a collection of constraints on the admissible interpretations. The proposed characterization is designed to maintain the positive properties of the most recent proposals developed to address this problem (e.g., [12, 13, 32]), and to meet the following requirements:

It should apply to programs with arbitrary aggregates (e.g., no syntactic restrictions in the use of aggregates as well as no restrictions on the types of aggregates that can be used). In particular, we wish the approach to naturally support aggregates as facts and as heads of rules.

It should be as intuitive as the traditional answer set semantics, and it should extend traditional answer set semantics—i.e., it should behave as traditional answer set semantics for programs without aggregates. It should also naturally satisfy the basic properties  of answer sets.

It should offer ways to implement the semantic characterization by integrating, with minimal modifications, the definition in stateoftheart answer set solvers, such as Smodels [31], dlv [9], Cmodels [21], ASSAT [22], etc. In particular, it should require little more than the addition of a module to determine the “solutions” of an aggregate,^{2}^{2}2This concept is formalized later in the paper. without substantial modifications of the mechanisms to compute answer sets.
We achieve these objectives by defining a transformation, called unfolding, from logic programs with aggregates to normal logic programs. The key idea that makes this possible is the generalization of the supportedness property of answer sets to the case of aggregates. More precisely, our transformation ensures that, if an aggregate atom is satisfied by a model , then supports at least one of its solutions. Solutions of aggregates can be precomputed, and an answer set solver for LP with aggregates can be implemented using standard answer set solvers.
The notion of unfolding has been widely used in various areas of logic programming (e.g., [37, 35, 41]). The inspiration for the approach used in handling aggregates in this paper comes from the methodology proposed in various works on constructive negation (e.g., [40, 4, 7])—in particular, from the idea of unfolding intensional sets into sets of solutions, employed to handle intensional sets in [3, 7].
The approach developed in this paper is the continuation and improvement of the approach in [10]. It offers an alternative view of the semantics for LP with aggregates developed in [32]. In particular, the two characterizations provide the same meaning to program with aggregates, although our approach does not require the use of approximation theory. We provide two ways of using unfolding. The first is similar to the notion of transformation explored in [33]. The second is closer to the spirit of the original definition of answer sets [14], and it allows us to naturally handle more general use of aggregates (e.g., aggregates in the heads). The characterization proposed in this paper also captures the same meaning as the proposals in [12, 13, 26] for large classes of programs (e.g., stratified programs and programs with monotone aggregates). Observe that, in this work, we do not directly address the problem of negated aggregates. This problem can be tackled in different ways (e.g. [26, 13]). Our approach to aggregates can be easily extended to accommodate any of these approaches [38].
The rest of this paper is organized as follows. Section 2 presents the syntax of our logic programming language with aggregates. Section 3 describes the first definition of answer sets for programs with aggregates that do not allow for aggregates to occur in the head of rules. The definition is based on an unfolding transformation of programs with aggregates into normal logic programs. It also contains a discussion of properties of answer sets and describes an implementation. Section 4 introduces an alternative unfolding, which is useful for extending the use of aggregates to the head of program rules. Section 5 compares our approach with the relevant literature. Section 6 discusses some issues related to our approach to providing semantics of aggregates. Finally, Section 7 presents the conclusions and the future work.
2 A Logic Programming Language with Aggregates
Let us consider a signature , where

is a collection of constants (program constants),

is a collection of unary function symbols (aggregate functions),

and are denumerable collections of variables, such that ,

is a collection of arbitrary predicate symbols (program predicates), and

is a collection of unary predicate symbols (aggregate predicates).
In the rest of this paper, we will assume that is a subset of —i.e., there are distinct constants representing the integer numbers. We will refer to as the ASP signature.
We will also refer to as the program signature, where

,

, and

is finite.
We will denote with the Herbrand universe, containing the ground terms built using symbols of , and with the corresponding Herbrand base. We will refer to an atom of the form , where and , as an ASPatom. An ASPliteral is either an ASPatom or the negation as failure () of an ASPatom.
Definition 1
An extensional set has the form , where are terms of . An extensional multiset has the form are (possibly repeated) terms of . where
Definition 2
An intensional set is of the form
where is a variable, ’s are variables or constants, , and is a kary predicate in .
An intensional multiset is of the form
where , are variables or constants (of ), , and . We call and the collected variable and the predicate of the set/multiset, respectively.
Intuitively, we are collecting the values of that satisfy the atom , under the assumption that the variables are locally and existentially quantified. For example, if is true for and , then the multiset
Observe also that the variables from are used exclusively as collected or local variables in defining intensional sets or multisets, and they cannot occur anywhere else.
Definition 3
An aggregate term is of the form , where is an intensional set or multiset, and . An aggregate atom has the form where and is an aggregate term.
This notation for aggregate atoms is more general than the one used in some previous works, and resembles the abstract constraint atom notation presented in [26].
In our examples, we will focus on the “standard” aggregate functions and predicates, e.g., Count, Sum, Min, Max, Avg applied to sets/multisets and predicates such as , , , etc. Also, for the sake of readability, we will often use a more traditional notation when dealing with the standard aggregates; e.g., instead of writing we will use the more common format .
Given an aggregate atom , with kary collected predicate , we denote with the following set of ASPatoms:
Definition 4
An rule is an expression of the form
(1) 
where are ASPatoms, and are aggregate atoms (, , ).^{3}^{3}3For methods to handle negated aggregate atoms, the reader is referred to [38].
An program is a collection of rules.
For an rule of the form (1), we use the following notations:

denotes the ASPatom ,

denotes the set ,

denotes the set ,

denotes the set ,

denotes the right hand side of the rule .
For a program , denotes the set of all ASPatoms present in .
The syntax has been defined in such a way that collected and local variables of an aggregate atom have a scope that is limited to . Thus, given an rule, it is possible to rename these variables apart, so that each aggregate atom in the body of a rule makes use of different collected and local variables. Observe also that the collected and the local variables are the only occurrences of variables from , and these variables will not appear in any of , , and .
Definition 5
Given a term (atom, literal, rule) , we denote with the set of variables from present in . We will refer to these as the free variables of . The entity is ground if .
In defining the semantics of the language, we will need to consider all possible ground instances of programs. A ground substitution is a set , where the are distinct elements of and the elements are constants from . Given a substitution and an ASPatom (or an aggregate atom) , the notation describes the atom obtained by simultaneously replacing each occurrence of () with . The resulting element is the instance of w.r.t. .
Given a rule of the form (1) with , and given a ground substitution , the ground instance of w.r.t. is the rule obtained from by simultaneously replacing every occurrence of () in with .
We will denote with the set of all the possible ground instances of a rule that can be constructed in . For a program , we will denote with the set of all ground instances of all rules in , i.e., .
Observe that a ground logic program with aggregates differs from a ground logic program, in that it might still contain some local variables, which are members of , and they occur only in aggregate atoms.
Example 1
Let , , , and . Let be the rule
will contain the following rules:
Furthermore, for the aggregate atom , we have that
3 Aggregate Solutions and Unfolding Semantics
In this section, we develop our first characterization of the semantics of program with aggregates, based on answer sets, study some of its properties, and investigate an implementation based on the Smodels system.
3.1 Solutions of Aggregates
Let us start by developing the notion of interpretation, following the traditional structure [25].
Definition 6 (Interpretation Domain)
The domain of an interpretation is the set , where is the set of all (finite) subsets of , while denotes the set of all finite multisets built using elements from .
Definition 7 (Interpretation)
An interpretation is a pair , where is a function that maps ground terms to elements of and ground atoms to truth values. The interpretation function is defined as follows:

if is a constant, then

if is a ground intensional set , then is the set , where is true if and only if .

if is a ground intensional multiset

given an aggregate term , then is equal to , where

if is a ground ASPatom or a ground aggregate atom, then is , where .
In the characterization of the aggregate functions, in this work we will mostly focus on functions that maps sets/multisets to integer numbers in . We will also assume that the traditional aggregate functions and predicates are interpreted in the usual manner. E.g., is the function that sums the elements of a set/multiset, and is the predicate that is true if its argument is an element of no greater than .
Given a literal , its interpretation is true (false) iff is false (true).
For the sake of simplicity, given an atom (literal, aggregate atom) , we will denote with the fact that is true.
Definition 8 (Rule Satisfaction)
Let be an interpretation and an rule. satisfies the body of the rule () if for each . We say that satisfies if whenever .
Finally, we can define the concept of model of a program.
Definition 9 (Model of a Program)
An interpretation is a model of a program if satisfies each rule .
In the rest of this work, we will assume that the interpretation of the aggregate functions and predicates is fixed—i.e., it is the same in all the interpretations. This allows us to keep the “traditional” view of interpretations as subsets of [25].
Definition 10 (Minimal Model)
An interpretation is a minimal model of if is a model of and there is no proper subset of which is also a model of .
We will now present the notion of solution of an aggregate. One of the guiding principles behind this concept is the following observation. The satisfaction of an ASPatom is monotonic, in the sense that if and , then we have that . This property does not hold any longer when we consider aggregate atoms. Furthermore, the truth value of an aggregate atom depends on the truth value of certain atoms belonging to . For example, if we consider the aggregate atom in the program with , we can observe that
and is true if is false or is true. These two observations lead to the following definition.
Definition 11 (Aggregate Solution)
Let be a ground aggregate atom. A solution of is a pair of disjoint subsets of such that, for every interpretation , if and then .
We will denote with the set of all the solutions of the aggregate atom .
Let be the solution of an aggregate ; we denote with and the two components and of the solution.
Example 2
Let be the aggregate atom in a language where . This aggregate atom has a total of solutions of the form such that , , and (i) either ; or (ii) . These solutions are listed below.
Let be an aggregate atom. The following properties hold:
Observation 3.1

If there is at least one interpretation such that , then .

If is a solution of then, for every set with , we have that and are also solutions of .
The first property holds since the pair is a solution of . The second property is trivial from the definition of a solution.
3.2 Answer Sets
We will now define the unfolding of an aggregate atom, of a ground rule, and of a program. For simplicity, we use (resp. ) to denote the conjunction (resp. ) when ; () stands for ().^{4}^{4}4We follow the convention of denoting with and with .
Definition 12 (Unfolding of an Aggregate Atom)
Given a ground aggregate atom and a solution , the unfolding of w.r.t. , denoted by , is .
Definition 13 (Unfolding of a Rule)
Let be a ground rule
where are aggregate atoms. A ground rule is an unfolding of if there exists a sequence of aggregate solutions such that

is a solution of the aggregate atoms (),

,

,

, and

.
We say that is an unfolding of with respect to . The set of all possible unfoldings of a rule is denoted by .
For an program , denotes the set of the unfoldings of the rules in . It is easy to see that is a normal logic program.
The answer sets of programs are defined as follows.
Definition 14
A set of atoms is an answer set of iff is an answer set of .
Example 3
Let be the program:^{5}^{5}5 We would like to thank Vladimir Lifschitz for suggesting this example.
The aggregate atom has five aggregate solutions:
The unfolding of is the program
and are the two answer sets of , thus answer sets of .
Example 4
Let be the program
The only aggregate solution of is and contains:
which has as its only answer set. Thus, is the only answer set of .
The next program with aggregates does not have answer sets, even though it does not contain any negation as failure literals.
Example 5
Consider the program :
The unique aggregate solution of the aggregate atom with respect to is . The unfolding of consists of the two rules:
and it does not have any answer sets. As such, does not have any answer sets.
Observe that, in creating , we use every solution of in . Since the number of solutions of an aggregate atom can be exponential in the size of the Herbrand base, the size of can be exponential in the size of . Fortunately, as we will show later (Theorem 2), this process can be simplified by considering only minimal solutions of each aggregate atom (Definition 16). In practice, for most common uses of aggregates, we have observed a small number of elements in the minimal solution set (typically linear or quadratic in the extension of the predicate used in the intensional set).
3.3 Properties of Answer Sets
It is easy to see that the notion of answer sets extends the notion of answer sets of normal logic programs. Indeed, if does not contain aggregate atoms, then . Thus, for a program without aggregates , is an answer set of if and only if is an answer set of with respect to the GelfondLifschitz definition of answer sets.
We will now show that answer sets satisfies the same properties of minimality, closedness, and supportedness as answer sets for normal logic programs.
Lemma 1
Every model of is a model of .
Proof. Let be a model of , and let us consider a rule such that satisfies the body of . This implies that there exists a sequence of solutions for the aggregate atoms occurring in , such that , , and . Let be the unfolding of with respect to . We have that and . In other words, satisfies the body of . This implies that , i.e., .
Lemma 2
Every model of is a model of .
Proof. Let be a model of , and let us consider a rule such that satisfies the body of . Since , there exists and a sequence of aggregate solutions for the aggregate atoms in such that satisfies (for ) and is the unfolding of with respect to . This means that , , and for . In other words, satisfies . Since is a model of , we have that , which means that .
Theorem 1
Let be a program with aggregates and be an answer set of . Then, is closed, supported, and a minimal model of .
Proof. Since is an answer set of , Lemma 1 implies that is a model of . Minimality of follows from Lemma 2 and from the fact that is a minimal model of . Closedness is immediate from Lemma 1.
Supportedness can be derived from the fact that each atom in is supported by (w.r.t. ) since is an answer set of . Thus, if were not supported by w.r.t. , then this would mean that no rule in supports , which would contradict the fact that is an answer set of .
Observe that the converse of the above theorem does not hold, as illustrated by the following example.
Example 6
Let be the program
It is easy to see that is a minimal model of this ground program—i.e., is a minimal set of atoms, closed under the rules of and each atom of is supported by a rule of . On the other hand, consists of the following rules
is not an answer set of . We can easily check that this program does not have an answer set. Thus, does not have an answer set according to Definition 14.
Remark 1
The above result might seem counterintuitive, and it deserves some discussion. One might argue that, in any interpretation of the program , either
will be true. As such, would appear to be true, and hence should be an answer set of the program.
While this is a possible way to deal with aggregates, in this example, this line of reasoning might lead to circular justifications of atoms in . In fact, observe that the rules that support and in are and , respectively. In the context of the program, can be true only if is true. This is equivalent to say that is true because is true, and is true because is true. In other words, the answer set contains two elements whose truth values depend on each other.
The traditional answer set definition in [14] does not allow such type of justifications—in that it does not consider as an answer set of the program .
Example 6 shows that our approach to defining the semantics of logic programs with aggregates is closer to the spirit of the traditional answer set definition.
We should also observe that most of the recent approaches to handling aggregates (e.g., [12, 13, 32]) yield the same result on this example. Moreover, if we encode in Smodels (using weight constraints) as
p(1). p(2). q: 2[p(1)=1, p(2)=2]. q:[p(1)=1, p(2)=2]1.
we obtain an Smodels program that does not have any answer sets.
3.4 Implementation
In spite of the number of proposals dealing with aggregates in logic programming, only few implementations have been described. Dell’Armi et al. [5] describe an implementation of aggregates in the dlv engine, based on the semantics described in Section 5.8 (the current distribution is limited to aggregatestratified programs^{6}^{6}6The concept of aggregate stratification is discussed in Subsection 5.6.). Elkabani et al. [10] describe an integration of a Constraint Logic Programming engine (the ECLiPSe engine) and the Smodels answer set solver; the integration is employed to implement aggregates, with respect to the semantics of Section 5.8. Some more restricted forms of aggregation, characterized according to the semantics of Section 5.8 have also been introduced in the ASETProlog system [16]. Efficient algorithms for bottomup computation of the perfect model of aggregatestratified programs have been described in [19, 43].
In this section, we will describe an implementation of a system for computing answer sets based on the computation of the solutions of aggregate atoms, unfolding of the program, and computation of the answer sets using an offtheshelf answer set solver. We begin with a discussion of computing solutions of aggregate atoms.
3.4.1 Computing the Solutions
As we have mentioned before, the size of the program can become unmanageable in some situations. One way to reduce the size of is to find a set of “representative” solutions for the aggregate atoms occurring in , whose size is—hopefully—smaller than the size of the . Interestingly, in several situations, the number of representative solutions of an aggregate atom is small [39]. We say that a set of solutions is complete if it can be used to check the satisfiability of the aggregate atom in every interpretation of the program. First, we define when a solution covers another solution.
Definition 15
A solution of an aggregate atom covers a solution of , denoted by , if, for all interpretations ,
This can be used to define a complete and minimal sets of solutions of an aggregate atom.
Definition 16
A set of solutions of an aggregate atom is complete if for every solution of , there exists such that .
A solution set is reducible if there are two distinct solutions and in such that . The set of solutions is then called a reduction of . A solution set is minimal if it is complete and not reducible.
By definition, we have that is complete. Because of the transitivity of the covering relationship, we can conclude that any minimal solution set of is a reduction of . Given a ground program , let be the aggregate atoms present in , and let us denote with the unfolding of where has been unfolded using only the solution set .
Theorem 2
Given a ground program containing the aggregate atoms , and given a complete solution set for each aggregate atom , we have that is an answer set of iff is an answer set of .
Proof. For an interpretation , let and . We have that is an answer set of iff is an answer set of . Furthermore, , and for each rule there is a rule with and . Using this information, we can show that is an answer set of iff is an answer set of , which proves the theorem.
The above theorem shows that we can use any complete solution set (e.g., a minimal one) to unfold an aggregate atom.
We make use of the following observation to compute a complete solution set:
Observation 3.2
Let be an aggregate atom and let , be solutions of . Then .
The abstract algorithm in Figure 1 computes a complete solution set for a given aggregate atom—when called with Find_Solution and with initially . This algorithm is generic—i.e., can be used with arbitrary aggregate predicates, as long as a mechanism to perform the test in line 3 is provided. The test is used to check whether the current represents a solution of . Observe also that more effective algorithms can be provided for specific classes of aggregates, by using properties of the aggregate predicates used in the aggregate atoms [39].
Given a program containing the aggregate atoms , we can replace with . The program is a normal logic program without aggregates, whose answer sets can be computed using a standard answer set solver. The algorithm has been implemented in an extended version of lparse—using an external constraint solver to compute line 3. Note that the forall in line 9 is a nondeterministic choice of .
3.4.2 The System
We will now describe the prototype we have constructed, called , for computing answer sets of programs with aggregates. The computation is performed following the semantics given in Definition 14, simplified by Theorem 2. In other words, to compute the answer set of a program , we

Compute a complete (and possibly minimal) solution set for each aggregate atom occurring in ;

Unfold using the computed solution sets;

Compute the answer sets of the unfolded program using a standard answer set solver (in our case, both Smodels and Cmodels).
The overall structure of the system is shown in Figure 2.
The computation of answer sets is performed in five steps. In the first step, a preprocessor performs a number of simple syntactic transformations on the input program, which are aimed at rewriting the aggregate atoms in a format acceptable by lparse. For example, the aggregate atom is rewritten to and an additional rule
0{‘‘$agg’’(sum,‘‘$x’’, p(‘‘$x’’), 40, geq)}1 
is added to the program. The rewritten program is then grounded and simplified using lparse, in which aggregate atoms are treated like standard (nonaggregate) literals.
The ground program is processed by the transformer module, detailed in Figure 3, in which the unfolded program is computed. This module performs the following operations:

Creation of the atom table, the aggregate table, and the rule table, used to store the ground atoms, aggregate atoms, and rules of the program, respectively. This is performed by the Reader component in Figure 3.

Identification of the dependencies between aggregate atoms and the atoms contributing to such atoms (done by the Dependencies Analyzer);

Computation of a complete solution set for each aggregate atom (done by the Aggregate Solver—as described in the previous subsection);

Creation of the unfolded program (done by the Rule Expander).
Note that the unfolded program is passed one more time through lparse, to avail of the simplifications and optimizations that lparse can perform on a normal logic program (e.g., expansion of domain predicates and removal of unnecessary rules). The resulting program is a ground normal logic program, whose answer sets can be computed by a system like Smodels or Cmodels.
3.4.3 Some Experimental Results
We have performed a number of tests using the system. In particular, we selected benchmarks with aggregates presented in the literature. The benchmarks, drawn from various papers on aggregation, are:

Company Control: Let denotes the fact that company owns a fraction of the shares of the company . We say that a company controls a company if the sum of the shares it owns in together with the sum of the shares owned in by companies controlled by is greater than half of the total shares of :