Towards Well-Behaved Semantics Suitable for Aggregation

Towards Well-Behaved Semantics Suitable for Aggregation Ju  rgen Dix, Mauricio Osorio

11/97

Fachberichte INFORMATIK

Universitat Koblenz-Landau Institut fur Informatik, Rheinau 1, D-56075 Koblenz E-mail: [email protected], WWW: http://www.uni-koblenz.de/fb4/

Towards Well-Behaved Semantics Suitable for Aggregation Jurgen Dix1 and Mauricio Osorio2 1 University of Koblenz

Department of Computer Science Rheinau 1, D-56075 Koblenz, Germany [email protected]

2 Universidad de las Americas

Departamento de Ingenieria en Sistemas Computacionales Sta. Catarina Martir, Cholula, Puebla, 72820 Mexico, Mexico [email protected]

Abstract. Real Applications of Databases ask for the support of Aggregation . This, however, needs stronger semantics than usual. In particular, such semantics should extend the wellfounded semantics WFS. We study such extensions and determine which semantics are possible given certain abstract properties like partial evaluation , cumulativity , partial monotony and supraclassicality . While WFS+ (introduced independently by Dix and Schlipf for other purposes) has recently been shown by Osorio and Jayaraman to be well suited for aggregation, it has higher complexity than WFS: it is on the rst level of the polynomial hierarchy. We present in this paper polynomial-time computable semantics which are also well suited. Our de nitions use a con uent and terminating calculus introduced by Brass and Dix and further re ned by Brass, Freitag and Zukowski. This allows us to generalize our results to disjunctive logic programs. Finally, such semantics can also be used to improve the stable semantics by extending its scope (the class of programs where the stable semantics is consistent).

1 Introduction De nite clause programs are programs formed from Horn clauses of the form A A1 ; : : : ; An , with A; A1 ; : : : ; An being positive atoms. They can be considered as the heart of the logic programming paradigm because they possess a very

simple and clear declarative semantics and a sound and complete operational semantics, namely SLD ([CKPR73,Kow74,Kow79]). The problem is that almost any application goes beyond the limits of de nite clauses. Normal programs extend de nite programs by allowing negation :. The logic programming community has decided to use some variants of negation-as-failure (NAF): if A is a ground atom the goal :A succeeds if A fails, and the goal :A fails if A succeeds.

The rst proposal to provide a convincing declarative semantics to NAF was given in [Cla78] and it is called the Clark's completion. The main idea is that, to deduce negative information from a normal program, we could \complete" the program by adding the only-if halves of the de nitions of the predicate symbols1 . However, it is now accepted that Clark's completion is often too weak and does not always capture the intended meaning of logic programs necessary for e.g knowledge representation tasks ([BG94,BD96]). Hence it became necessary to nd new forms for specifying the semantics of logic programs. Most approaches can be seen as either to restrict the class of programs to ensure that a canonical model for this restricted class exists, or to associate to a program a set of models. The rst idea led to various forms of strati cation semantics ([ABW88,CB94,Ros90,BF91]). The second idea led to the discovery of two quite dominant approaches: the wellfounded semantics WFS ([vGRS91]) and the stable semantics STABLE ([GL88]). The well founded semantics for logic programs with negation has received great interest since its introduction, because it has several desirable properties: it is consistent and every program possesses exactly one 3-valued model. In addition, this model is computable in polynomial time. In contrast to this, the stable semantics is not consistent and answering a query does not depend on the callgraph below that query. This implies that there is no goal-directed computation possible. In addition, computing stable models is NP-hard and can therefore not be done in polynomial time (unless the polynomial hierarchy collapses). More recently, Brass and Dix introduced in [BD97c,BD97b] a calculus of simple transformations for disjunctive logic programs. This calculus has a strong and appealing property: it is con uent and terminating (for DATALOG and allowed programs). Moreover, its restriction to non-disjunctive programs characterizes exactly the WFS. As already said above, despite its computational and structural advantages, WFS is considered much too weak for real applications. Consequently, lots of extensions of WFS have been de ned in recent years. Most of them can be seen as approximations of the stable semantics, by trying to avoid STABLE's irregularities. In [Dix95a,Dix95b] the rst author investigated most of these extensions with respect to their properties. Most of them had very irregular behaviour, only some of them are \well-behaved" (like WFS+ , WFS0 , REG-SEM). But all of them are on the rst level of the polynomial hierarchy, so they are not polynomial. In this paper we consider the problem of using a semantics that handles aggregation-predicates in a natural way. This leads us to introduce two semantics WFS1 , WFS2 for DATALOG programs. WFS1 is de ned by extending the calculus of Brass and Dix with one more transformation rule. This extended calculus still shares the nice properties: it is con uent and terminating. In addition, WFS1 is well-behaved , satis es partial evaluation but it looses the cumulativity property. WFS2 is also well-behaved , satis es cumulativity and rationality but it looses the partial evaluation property. 1 For the details we refer to [Llo87].

2

In fact we show that partial evaluation and cumulativity are in a very general sense incompatible (Theorem 23). Our experiments suggest that our semantics can be used for potential applications in modelling aggregation in deductive databases. Previous work has been done by the second author recently ([OJ97]). Furthermore, due to the speci c features of our approach, it can be generalized to disjunctive logic programs which extend the D-WFS introduced in [BD97c]. We restrict this paper to nite propositional programs, although the original construction of the normalform of a program holds for the wider class of allowed and DATALOG programs. Our paper is structured as follows. After giving some background information on the concepts involved (Section 2), we give in Section 3 some realistic examples showing the problems occurring with aggregation . We discuss the intended semantics and formulate two principles for achieving this. In Section 4, we study carefully what extensions of WFS handling aggregates (in view of the examples of the previous sections) are possible. We introduce two extensions of WFS: WFS1 and WFS2 . In Section 5 we investigate the properties of our two semantics and present characterizations of them using our introduced principles. We end with Section 6, where we give some hints to generalize our results to disjunctive logic programs.

2 Background We rst collect some general results about rewriting systems that are needed later. We then de ne the notion of SEMmin , stating the minimal requirements any semantics should have. Finally we brie y review the notion of a well-behaved semantics and give a con uent calculus of program transformations to compute the wellfounded semantics WFS.

De nition 1 (Rewriting System).

An abstract rewriting system is a pair hS; !i where ! is a binary relation on S . Let ! be the re exive, and transitive closure of !. When x ! y we say that x reduces to y. An irreducible element is said to be in normal form . We say that a rewriting system is

noetherian: if there is no in nite chain x ! x ! : : : ! xi ! xi ! : : : con uent: if whenever u ! x and u ! y then there is a z such that x ! z and y ! z . locally con uent: if whenever u ! x and u ! y then there is a z such that x ! z and y ! z . 1

2

+1

It is well known that if a rewriting system is noetherian then it is con uent if and only if it is locally con uent. In a noetherian and con uent rewriting system, every element x reduces to a unique normal form that we denote by norm (x). 3

A signature L is a nite set of elements that we call atoms . A literal is an atom or the negation of an atom a that we denote by :a. Given a set of atoms fa1 ; : : : ; an g , we write :fa1 ; : : : ; an g to denote f:a1 ; : : : ; :an g. Let ProgL be the set of all normal propositional programs with atoms from L. By LP we understand the signature of P , i.e. the set of atoms that occur in P . We may denote a clause C as usual [Llo87] or by a B+ ; :B? , where B+ contains all the positive body atoms and B? contains all the negative body literals. We also use body(C ) to denote B+ [ :B? .

De nition 2 (SEMmin ).

For any program P we de ne HEAD(P ) = faj a B+; :B? 2 P g | the set of all head-atoms of P . We also de ne SEMmin (P ) = hP true ; P false i; where

P true := fpj p

2 P g; P false := fpj p 2 LP nHEAD(P )g

SEMmin (P) is the set of atoms that are already determined independently of what semantics we choose: if an atom does not occur in any head of a program, it must be false. Dually, if there is a rule with empty body, then the head of this rule must be true. These are just minimal assumptions for any semantics whatsoever. But a semantics should also be closed under the rules, i.e. it should be a (three-valued) model of the program. Moreover, if an atom a is contained in SEM(P ) and b is contained in SEM(P [ fag), then b should already belong to SEM(P ): we call this property cut . Also, to do ecient query-answering, answering a query with respect to a program should only depend on the callgraph of the program with respect to the query: we call this property relevance . Another property is that the introduction of new names (introducing a new atom anew by a rule anew body) should be a conservative extension, i.e. should not aect the semantics of the other literals (we call it weak PPE). Finally, we want that tautological clauses (clauses that contain the same atom in their head and in their body) can be removed without changing the semantics. A semantics having all these properties is called well-behaved and this notion was studied in detail in [Dix95b]:

De nition 3 (Well-Behavedness).

A semantics satisfying relevance , weak partial evaluation , tautology and cut is called well-behaved. One of the main results of [Dix95b] is that WFS is the weakest well-behaved semantics2. 2 Given two interpretations = h 1 2 i, = h 1 2 i, we de ne  i  , = 1 2. Clearly  is a partial order. We may also see an interpretation h 1 2 i as the set of literals 1 [ : 2 . When we look at interpretations as sets of literals then  corresponds to . I

i

;

I ;I

J

I

J ;J

I

k J

Ii

I ;I

k

I

k

4

Ji

In this paper, we do not need the full power of well-behaved semantics. We only need the following transformation rules, where one rule however, the GPPE, is slightly stronger than the above described weak PPE. In fact, it has been shown that these transformation rules suce for computing the wellfounded semantics:

De nition 4 (The calculus of [BD97b]).

This calculus consists of the following 5 transformations: RED+: If an atom a is not in HEAD(P), then all ocurrences of :a are removed. RED?: If a 2 P then we delete all rules that contain :a in their bodies. SUB: Suppose a program P contains the clauses a body1; and a body2, where body1  body2. Then we delete the clause a body2 from P . GPPE: Suppose P contains a B+; B? and we x an occurrence of an atom g 2 B+. Then we can replace a B+; B? by the n clauses (i = 1; : : : ; n)

a B+ nfgg) [ Bi + ; :B? [ :Bi ? Bi + ; :Bi ? 2 P, (for i = 1; : : : ; n) are all clauses with g in their

where g heads. If no such clauses exist, we simply delete the former clause. TAUT: If the clause C contains the same atom in its head and in its body, we can remove it. We de ne the relation !wfs on ProgL as the union of all the operators of type TAUT, RED , GPPE and SUB. It has been proved in [BD97b] that hProgL ; !wfs i is an abstract reduction system that is noetherian and con uent. Therefore, every program P has a computable unique normal form, which we denote by norm wfs (P ). In addition, the well founded semantics of P is obtained as follows

WFS (P ) = SEMmin (norm wfs (P )):

3 Aggregation in Databases An aggregate operation is (loosely) a function that maps a set to some value, somehow \numerical" in that it involves order and/or arithmetic ([vG92]). We consider the approach to de ne aggregates using normal logic programs. In this way, we can consider a program involving aggregation as a macro for a normal program. Such an approach has been used in the literature [vG92,OJ97], since it has the advantage that normal programs are well accepted and relatively well-known. Also LDL1's choice construct provides an example of this nature. According to [SZ90] the choice construct can be expressed via normal rules and the stable semantics. Van Gelder showed in [vG92] that the framework of the well founded semantics is adequate to express the meaning of a large class of \monotonic" aggregate programs. In [OJ97] the authors noticed that by replacing WFS by WFS+ and a slightly dierent translation it is possible to express the intended meaning of a larger class of \monotonic" programs. Programs that are not monotonic still 5

could have a clear intended meaning. Van Gelder also showed ([vG92] ad hoc translations for some \non-monotonic" programs. We show here three examples where we believe that our semantics WFS2 , which we present in the next section, de nes the intended meaning. Example 5 (Reachability). Consider the following program. adj(1,2). adj(2,1). reach(X,). reach(X,) :- adj(X,Z), reach(Z,).

According to [Liu95], neither COL nor LDL can give a semantics to this program since the second rule makes it unstrati ed3 . If we translate this program using the approach in [OJ97] we get the following program (we denote negation : as ~). adj(1,2).

adj(2,1).

ge(X,Y) ge(V,S) ge(V,S) ge(W,Z)

::::-

ge(X,Y1), subset(Y,Y1). sing(V,S). adj(V,Vs), eq(Vs,S). ge(W,X1), ge(W,Y), union(X1,Y,Z).

eq(W,a1) eq(W,a2) eq(W,a3) eq(W,a12) eq(W,a13) eq(W,a23) eq(W,a123)

:::::::-

ge(W,a1), ~ge(W,a12), ~ge(W,a13), ~ge(W,a123). ge(W,a2), ~ge(W,a12), ~ge(W,a23), ~ge(W,a123). ge(W,a3), ~ge(W,a23), ~ge(W,a13), ~ge(W,a123). ge(W,a12), ~ge(W,a123). ge(W,a13), ~ge(W,a123). ge(W,a23), ~ge(W,a123). ge(W,a123).

sing(1,a1).

sing(2,a2).

sing(3,a3).

We assume that the nodes of the graph are f1; 2; 3g. We represent sets using constant symbols. In this case the set f1g is represented by a1, the set f1; 2g by a12 and so on. Moreover eq(X,Y) expresses that for the node X, Y is the set of its reachable nodes. So eq(X,Y) corresponds to reach(X,). Also, sing(X,Y) expresses that Y is fXg. Due to lack of space we leave out the extensional database for subset and union. But, as an example, we note that subset(a1,a12), union(a1,a3,a13) are part of this extensional database. It is important to observe that if we replace the clause: ge(V,S) :- adj(V,Vs), eq(Vs,S)

3 LDL is due to Beeri/Naqvi/Shueli/Tsur, COL is due to Abiteboul/Grumbach.

6

by

ge(V,S) :- adj(V,Vs), ge(Vs,S)

we obtain a strati ed program that de nes the intended meaning: it holds ge(1,a12), ge(2,a12). A further observation is that for the original program together with a de nition of edge with no cycles like edge(1,2), edge(2,3), the WFS semantics also de nes the intended model. But for the original program and with the given de nition for edge, we will see that WFS(P ) de nes a nontotal model. We doubt that this irregular behavior of the intensional database with respect of the extensional database is suitable for applications in databases. The relevant clauses of the normal form (respect to WFS) of this program are (according to the system BLAUBAER4 ): ge(1,a1). ge(1,a12) ge(1,a12) ge(1,a2) ge(1,a2) ge(2,a1) ge(2,a1) ge(2,a12) ge(2,a12) ge(2,a2). ge(3,a3).

::::::::-

~ge(2,a12). ~ge(1,a12). ~ge(2,a12). ~ge(1,a12). ~ge(1,a12). ~ge(2,a12). ~ge(1,a12). ~ge(2,a12).

eq(1,a1) eq(1,a12) eq(1,a12) eq(1,a2) eq(2,a1) eq(2,a12) eq(2,a12) eq(2,a2) eq(3,a3).

::::::::-

~ge(1,a12). ~ge(2,a12). ~ge(1,a12). ~ge(1,a12). ~ge(2,a12). ~ge(1,a12). ~ge(2,a12). ~ge(2,a12).

Since ge(1,a12) :- ~ ge(1,a12) derives ge(1,a12)}, and also ge(2,a12) is derived from ge(2,a12) :- ~ ge(2,a12) as a logical consequence, we can try to add ge(2,a12), ge(1,a12) to the original program and recompute the WFS. After adding these two atoms to the program (we call this extended program P 0 ) we get that WFS(P 0 ) de nes the intended meaning of the program, where eq(1,a12) and eq(2,12) are both true. This paper explores the previous ideas in detail and suggests two new semantics: WFS 1 and WFS 2 (this will be done in the next section). Example 6 (Party Invitation). Our second example is almost Example 6.3 in [vG92]. The formulation of the problem is the same one. We suppose that someone comes to a party if the sum of all compatibilities with others known to come to the party is nonnegative. As in [vG92], we use a setof operator to de ne the problem, but we use a slightly dierent program to code the problem. accept(X) :- people(X), setof(Y,comp-coming(X,Y),S), sump(X,S). comp_coming(X,Y) :- accept(Y), comp(X,Y,N). sump(X,S) :- sum(X,S,N), nonnegative(N).

4 It is obtained by ftp://ftp.informatik.uni-hannover.de/software/index.html.

This system implements D-WFS and disjunctive stable semantics using a bottom-up procedure as described in [BD95].

7

sum(X,{},0). sum(X,S,N) :- disj-union({Y},S1,S), sum(S1,N1), comp(X,Y,N2), N=N1+N2. comp(a,b,1). people(a). comp(a,c,1). people(b). comp(b,a,1). people(c). comp(b,c,1).

Following the translation suggested in [OJ97], and reducing the program by the semantics of sump we obtain: accept(X)

:- people(X), eq1(X,S).

ge1(X,Y1) ge1(W,empty) ge1(W,Z) eq1(W,empty)

:- sing(Y,Y1) , comp(X,Y,Z), accept(Y). :- people(W). :- ge1(W,X1), ge1(W,Y), union(X1,Y,Z). :- ge1(W,empty), ~ge1(W,a1), ~ge1(W,a2), ~ge1(W,a3), ~ge1(W,a12), ~ge1(W,a13), ~ge1(W,a23), ~ge1(W,a123). :- ge1(W,a1), ~ge1(W,a12), ~ge1(W,a13), ~ge1(W,a123). :- ge1(W,a2), ~ge1(W,a12), ~ge1(W,a23), ~ge1(W,a123). :- ge1(W,a3), ~ge1(W,a23), ~ge1(W,a13), ~ge1(W,a123). :- ge1(W,a12), ~ge1(W,a123). :- ge1(W,a13), ~ge1(W,a123). :- ge1(W,a23), ~ge1(W,a123). :- ge1(W,a123).

eq1(W,a1) eq1(W,a2) eq1(W,a3) eq1(W,a12) eq1(W,a13) eq1(W,a23) eq1(W,a123)

We again omit the de nition for union. The stable semantics is unde ned. The WFS semantics of this program de nes a non-total model where accept(c) is true, but accept(a), accept(b) are unde ned. This is exactly what [vG92] reports using his program de nition, a similar translation to the one that we are using here and the WFS semantics. It is expected that in the intended model accept(a), accept(b), accept(c) are all true. Then [vG92] de nes a clever translation that de nes the intended model. Here, with the given translation, and the same idea as in the previous example we can de ne the intended model. The reason is that the normal form for WFS of this program gives ge1(a,a23) :- ~ ge1(a,a23). ge1(b,a13) :- ~ ge1(b,a13).

If we add ge1(a,a23) and ge1(b,a13) to the program then the WFS semantics of the new program de nes the desired model. Example 7 (Party invitation 2). This example is another variant of [vG92, Example 6.3]. We suppose that someone comes to a party if the sum of all compatibilities with others known to come to the party is greater or equal than 1. We also suppose that someone comes to a party if the sum of all compatibilities with others known not to come to the party is less than 1. We again use a setof operator to de ne the problem as follows: 8

accept(X) :- setof(Y, comp-coming(X,Y),S), sump(X,S). accept(X) :- setof(Y, comp-not-coming(X,Y),S), sumn01(X,S). comp_coming(X,Y):- accept(Y), comp(X,Y,N). comp_coming(X,Y):- ~ accept(Y), comp(X,Y,N). sump(X,S) :- sum(X,S,N), N > 0. sumn01(X,S) :- sum(X,S,N), N < 1. sum(X,{},0). sum(X,S,N) :- union({Y},S1,S), sum(S1,N1), com(X,Y,N2), N=N1+N2.

Now, consider the following extensional database: accept(c), comp(a,b,10), and comp(b,a,-10). Following the translation suggested in [OJ97], and replacing the de nitions of sump and sumn01 by their respective semantics we obtain: accept(c). accept(X) :- eq1(X,S), sump(X,S). accept(X) :- eq2(X,S), sumn01(X,S). ge1(X,Y1) :- sing(Y,Y1) , comp(X,Y,Z), accept(Y). ge2(X,Y1) :- sing(Y,Y1) , comp(X,Y,Z),~accept(Y). sump(a,a2). sumn01(b,empty). sumn01(b,a1).

comp(a,b,10). comp(b,a,-10).

ge1(W,empty) :- people(W). ge1(W,Z) :- ge1(W,X1), ge1(W,Y), union(X1,Y,Z). eq1(W,empty) :- ge1(W,empty), ~ge1(W,a1), ~ge1(W,a2), ~ge1(W,a3), ~ge1(W,a12), ~ge1(W,a13), ~ge1(W,a23), ~ge1(W,a123). eq1(W,a1) :- ge1(W,a1), ~ge1(W,a12), ~ge1(W,a13), ~ge1(W,a123). eq1(W,a2) :- ge1(W,a2), ~ge1(W,a12), ~ge1(W,a23), ~ge1(W,a123). eq1(W,a3) :- ge1(W,a3), ~ge1(W,a23), ~ge1(W,a13), ~ge1(W,a123). eq1(W,a12) :- ge1(W,a12), ~ge1(W,a123). eq1(W,a13) :- ge1(W,a13), ~ge1(W,a123). eq1(W,a23) :- ge1(W,a23), ~ge1(W,a123). eq1(W,a123) :- ge1(W,a123). ge2(W,empty) :- people(W). ge2(W,Z) :- ge2(W,X1), ge2(W,Y), union(X1,Y,Z). eq2(W,empty) :- ge2(W,empty), ~ge2(W,a1), ~ge2(W,a2), ~ge2(W,a3), ~ge2(W,a12), ~ge2(W,a13), ~ge2(W,a23), ~ge2(W,a123). eq2(W,a1) :- ge2(W,a1), ~ge2(W,a12), ~ge2(W,a13), ~ge2(W,a123). eq2(W,a2) :- ge2(W,a2), ~ge2(W,a12), ~ge2(W,a23), ~ge2(W,a123). eq2(W,a3) :- ge2(W,a3), ~ge2(W,a23), ~ge2(W,a13), ~ge2(W,a123). eq2(W,a12) :- ge2(W,a12), ~ge2(W,a123). eq2(W,a13) :- ge2(W,a13), ~ge2(W,a123).

9

eq2(W,a23) eq2(W,a123)

:- ge2(W,a23), ~ge2(W,a123). :- ge2(W,a123).

We again omit the de nition for union. The WFS semantics of this program de nes a non-total model where accept(a) is unde ned. but the stable semantics de nes a model where all accept(a), accept(b), accept(c) are true. Again the normal form of the program contains the kind of problematic clause accept(a) :- ~ accept(a). By adding accept(a) to the program and recomputing the WFS semantics we get the intended model. An interesting observation is that if we delete the following clauses: eq1(W,empty) :- ge1(W,empty), ~ge1(W,a1), ~ge1(W,a2), ~ge1(W,a3), ~ge1(W,a12), ~ge1(W,a13), ~ge1(W,a23), ~ge1(W,a123). eq2(W,empty) :- ge2(W,empty), ~ge2(W,a1), ~ge2(W,a2), ~ge2(W,a3), ~ge2(W,a12), ~ge2(W,a13), ~ge2(W,a23), ~ge2(W,a123).

We now get that the stable semantics is unde ned and that the WFS semantics de nes accept(a) to be unde ned. But one more time accept(a) :- ~ accept(a) occurs in the reduced program, and so we try the idea of adding accept(a). Indeed, WFS now de nes a total model where still accept(a), accept(c) are true, but accept(b) is false. We think that this is the intended model if we want a semantics close to classic logic. Let us return to see Example 5 but consider that the de nition of edge is edge(1,2), edge(2,3). We noticed that the WFS semantics de nes the intended model. We think that a semantics for databases should follow certain kind of monotonic behaviour with respect to the extensional database. In this example, we think that it is not suitable to have a non total model after adding the atom edge(3,1), which is how WFS behaves in this case. Note that adding the atom edge(3,1) should be considered harmless from a declarative point of view: the meaning of the program should not change. However, from a procedural point adding this atom is by no means harmless, because it introduces a loop which was not there before. Several authors have identi ed dierent classes of monotonic programs where this property is satis ed. We introduce in this paper a de nition of this monotonic behaviour which is very general and may be used to model aggregation. We may start suggesting the following principle:

De nition 8 (Strong Partial Monotony).

We say that a semantics SEM satis es strong partial monotony , i for atoms a; b b 2 SEM (P ) implies b 2 SEM (P [ fag) where it is assumed that a does not occur in the head of any clause of P and neither occurs negatively in P . Let us consider this principle in our example with edge(1,2), edge(2,3). First of all, as most semantics do in this case, we would like to infer geq(2,a23) and 10

eq(2,23). But, by the above principle if we add edge(3,1) we still should geq(2,a23) which is good, but we infer eq(2,a23) which is undesired.

infer This principle is very strong and is not consistent with PPE and RED , which are well accepted principles for semantics of logic programs. So, we need to make this principle weaker and satisfy standard well accepted principles. In our example, we noticed that for edge(1,2), edge(2,3), not only WFS infers geq(1,a123), but this atom is a logical consequence of the program. With this kind of double support, we can expect that by adding edge(3,1) to the program, we can infer geq(1,a123). Now, if we add geq(1,a123) to the program we would like the semantics to be the same. If we experiment with WFS by adding geq(1,a123) we observe that now WFS de nes the intended model. We are now ready to suggest our principle:

De nition 9 (Partial Monotony).

We say that a semantics SEM satis es partial monotony , i for atoms a; b (P j= b and b 2 SEM (P )) implies b 2 SEM (P [ fag) where it is assumed that a does not occur in the head of any clause of P and neither occurs negatively in P . We have experimented with this principle with the translation of aggregation suggested in [OJ97] over dierent programs that the literature considered somehow monotonic and we always got the intended model. However, Theorem 25 will show that this principle already leads to a non-polynomial semantics.

4 The Semantics WFS1 and WFS2 .

We have seen in the previous section that clauses of the form a :a play an important role and lead to diculties. While WFS leaves a unde ned, the stable semantics is inconsistent for such constructs. For aggregation purposes such atoms a should be considered to be true. We call this Principle 1 :

De nition 10 (Principle 1).

A semantics SEM satis es principle 1, if SEM(fa :ag) = fag. How can we ensure this principle? Let us take a look at the following notions (studied in [Dix95a]). The rst is cautious monotony : if an atom a is contained in SEM(P ) and b is also contained in SEM(P ) then b should also belong to SEM(P [ fag). Cautious monotony together with cut (see Section 2) is called cumulativity . Rationality is obtained from cautious monotony if we weaken the assumption \a is contained in SEM(P )" to \:a is not contained in SEM(P )". The second notion is Supraclassicality : if P j= a then a 2 SEM(P ) (for atoms a). Here, P j= a means classical derivability. Obviously, supraclassicality implies principle 1. The WFS+ -semantics (introduced independently by [Dix92], [Sch92]) has this property built-in: 11

Theorem 11 (WFS as k -weakest extension of WFS, [Dix95a]). +

WFS is the weakest extension of WFS that satis es Cut and Supraclassicality. In addition, WFS + is cumulative and rational. But supraclassicality immediately introduces NP-completeness, so that the polynomial complexity of WFS is lost (if the polynomial hierarchy does not collapse). Moreover, the GPPE does not hold for WFS+ : let us consider the following programs, taken from [DM94]: P : a :b P 0 : a :b +

b x x

:a

b x x

a b

:a :a :b

By applying GPPE twice, we get P 0 . But WFS+ (P ) = fxg while WFS+ (P 0 ) = ;. So the question arises, whether we can approximate WFS+ in a nice way so that good complexity as well as most of the properties of WFS are retained? In Section 5 we show that there is no extension of WFS satisfying principle 1 and cumulativity as well as GPPE. But in this section we de ne two extensions of WFS of polynomial complexity which both satisfy principle 1. Moreover, one of them is rational and the other satis es GPPE. Both de nitions rely on our calculus presented in De nition 4. Before giving the exact de nitions, let us illustrate the problems we are faced with. A straightforward approach would be to just replace \a :a"-clauses by a . But this is not enough because further computation can result in new clauses of this form (b :b; a might reduce to b :b after a has been established). The point here is that such reductions really have to be carried out recursively. Also, \a :a"-clauses might not be explicitly given but only implicitly. Example 12 (Main Example).

Pmain : a b

P0 : a :a b

b

:a :a

WFS(Pmain ) = ;, but any well-behaved semantics will consider Pmain and P 0 equivalent. We note here, that the full power of GPPE is not needed, only the weak PPE. For semantics satisfying GPPE, P 0 is equivalent to P 00 : a :a

b

a

The last example nicely illustrates the dierent approaches we are going to present: WFS1: We introduce a new transformation rule for handling clauses of the form \a :a". If \a :a" is the de nition of a, then we have also to replace every occurrence of :a by true. Thus WFS 1 (P 0 ) = fa; bg = WFS 1 (P 00 ) 12

WFS : Here we keep the original program and add more and more atoms to it (those atoms a, where \a :a" occurs by transforming the program). Finally, WFS (P ) is de ned by taking the wellfounded semantics WFS(Pn ) of the enlarged program. Thus WFS (P 0 ) = fa; :bg, WFS (P 00 ) = fa; bg. 2

2

2

2

4.1 WFS1 We use basically the same approach as [BD97b] to introduce a calculus for WFS1 . This calculus is essentially the one from De nition 4 augmented with a new transformation that we call LLC.

De nition 13 (Local Logical Consequence).

By the application of LLC (local logical consequence ) to a program P that only contains one clause with head a, namely a LC-clause a :a 2 P , we mean the transformation of P which simply removes every occurrence of :a in P . For ease of notation, we de ne an operator, denoted as op, as a function over the set of programs that transform a program P to a program P op as follows. If C1 , C2 are clauses, g a literal and f an atom, then op can be of type TAUT, and corresponds to the elimination of C1 from P . We write hTAUT; C1i, Red+, and is the reduction of P with respect to C1 and g. We write hRED+ ; C1 ; gi. Red?, and is the reduction of P with respect to C1 and g. We write hRED? ; C1 ; gi. GPPE, and is the application of GPPE with respect to C1 and f . We write hGPPE; C1 ; f i. SUB, and is the application of subsumption of C1 to C2 . We write hSUB; C1 ; C2 i (C2 is the clause to be deleted). LLC, and is the application of local logical consequence to the clause C1. We write hLLC; C1 i. Example 14 (Operators). If P is f a a , c :dg and op1 is hTAUT , a a i then P op1 is fc :dg. If op2 is hTAUT , b b i then P op2 = P .

Recall from Section 2 that the relation !wfs on ProgL as the union of all the operators of type TAUT, RED, GPPE, SUB. We de ne the relation !wfs0 on ProgL as the union of !wfs and all the operators of type LCC. Given a program P and a list of operators ops, we de ne the application of ops to P , denoted as P ops , as follows:

P [] := P P [opjops] := (P op )ops We de ne the size of ops as the number of elements of ops. 13

Example 15 (Sequence of Operators). Let P , op1 and op2 as in Example 14. Let op3 be hRED+ ; c :di. and ops1 = [op1; op3], ops2 = [op1; op2]. Then P ops1 is fc g while P ops2 = fc :dg. Here is one of our main theorems.

Theorem 16 (Con uence of the Extended Calculus). The rewriting system hProgL ; !wfs1 i is an abstract reduction system that is

con uent and notherian. Proof. The extended calculus is noetherian, because hProgL ; !wfs i has this property and LLC (the only additional transformation) only reduces the program and does not introduce new positive body-atoms. To prove con uence it is enough to prove local con uence. Let x !wfs1 y and x !wfs1 z . We have to prove that there exists w, such that y !wfs1 w and z !wfs1 w. Let x !wfs y and x !wfs z , by local con uence of hProgL ; !wfs i the result holds. So without loss of generality, we have to check the case: { Let x !wfs1 y and z = xop1 where op1 is of type LLC. If x !wfs1 y by a TAUT, or a SUB operation op2 then it is easy to check that op1 and op2 commute. If op2 is a RED+ operation, then applying LLC to y leads to the same program as applying RED+ and then LLC again to z . If op2 is a RED? operation then applying RED? to z leads to the same program as applying LLC and then RED? again to y. If op2 is a GPPE operation then again op1 and op2 commute unless op1 is hLLC; p :pi and op2 is hGPPE; C; pi. But then x[op1;op2;op3] = x[op2;op1;op3] , where op3 = hRED; :pi will do the job. Q.E.D. Since hProgL ; !wfs1 i is an abstract reduction system that is noetherian and con uent, we conclude that every program has a unique normal form that we denote by norm wfs1 (P ). This result justi es our following main de nition.

De nition 17 (WFS ). 1

The extended well founded semantics, denoted as WFS1 (P), is de ned by setting WFS1 (P ) := SEMmin (norm wfs1 (P )):

4.2 WFS2

The program Pmain from Example 12 shows that simply computing WFS and then reducing the program is much too weak. It does not allow us to derive a. On the other hand, the transformation approach underlying WFS1 is quite weak, because the LLC-rule requires that there is only one rule with head a. In particular, for the program P2 : a :a

:a :b; :a

b a

14

this rule can not be applied. However, from the viewpoint of aggregation, it seems to be safe to derive a. Obviously, :b should then also follow. This leads us to a principle stronger than De nition 10:

De nition 18 (Principle 2).

A semantics SEM satis es principle 2, if a 2 SEM (P ), whenever P contains a clause a :a. The idea of the next de nition is to keep the original program and adding more and more atoms to it. This de nes a sequence of sets of atoms Ai . These atoms are obtained by applying our old transformations to the program from the last step. Here is the exact de nition:

De nition 19 (WFS ). 2

The extended well founded semantics, denoted as WFS2 (P), is de ned through the following increasing sequence: (A0 = ;) Ai+1 := T (P [ Ai ) T (P ) := fa : a or a :a belongs to norm wfs (P )g There is the least number n0 such that An0 = An0 +1 . We de ne WFS2 (P ) := WFS (P [ An0 ). The following lemma will be useful later. Lemma 20. In the de nition of WFS 2: S 1. 8x 2 Ai 8N  i Ai : :x 62 WFS (P [ N ). 2. WFS (P [ Ai ) k WFS (P [ Ai+1 ). Proof. The rst condition is due to rationality and to the speci c construction of the sets Ai : once a clause S of the form a :a; rest is contained in P , no addition of atoms from i Ai can result in making a false in the corresponding wellfounded model. The second condition follows immediately by rationality. Q.E.D.

5 Properties of WFS1, WFS2

Theorem 21 (WFS , WFS are polynomial). 1

2

WFS , WFS are computable in polynomial time. Proof. (Sketch) Looking at the de nitions of our two semantics, it is obvious that the only critical point is the computation of the normalform norm wfs (). Indeed, computing this normalform is in general exponential as can be easily seen (see [BZF97]: the reason is the GPPE-transformation). Fortunately, for our purposes we do not need this particular normalform. A weaker normalform, called the remainder , de ned and studied in detail in [BZF97] is sucient (we only need [BZF97, Theorem 30]). This normalform is computable in polynomial time ([BZF97]). Q.E.D. 1

2

15

Theorem 22 (GPPE and Cumulativity for WFS , WFS ). 1

2

While WFS satis es GPPE, it is not cumulative. While WFS satis es cumulativity and rationality, it does not satisfy GPPE. Proof. GPPE for WFS1 is clear by the very de nition. Cumulativity is also obvious because all derivable atoms are included by construction. It remains to prove rationality. Without loss of generality, it suces to prove \if :a 62 WFS 2 (P ) then WFS 2 (P ) k WFS 2 (P [ fag)". We denote by Ai the sets with respect to P and by Aai the sets with respect to P [ fag. We show by induction on i: Ai  Aai and 8m 2 Aai [ fag and 8N  Si Aai : :m 62 WFS (P [ Ai [ N ). Let us note that this condition implies by rationality of WFS: [ WFS (P [ Ai [ N ) k WFS (P [ fag [ Aai [ N ) for all N  Aai : 1

2

i

i=0: the statement is trivially satis ed. Here we use the fact that :a 62 WFS (P ). i+1: we have Ai = T (P [ Ai ) and Aai = T (P [ fag [ Aai). As already noted (setting N = ;): WFS (P [ Ai ) k WFS (P [ fag [ Aai ). Therefore Ai  Aai . It remains to prove the second condition. By induction hypothesis, we only need to check those m with m 2 Aai n Aai . For such a m, either m 2 normwfs (P [ fag [ Aai ) or m :m 2 normwfs (P [ fag [ Aai ). In both cases :m is not true in WFS (P [ fag[ Aai [ N ) and therefore also not true in WFS (P [ Ai [ N ) which is k WFS (P [ fag [ Aai [ N ). 2

+1

+1

+1

+1

+1

Since we have shown

WFS (P [ Ai ) k WFS (P [ fag [ Aai ) we get, using Lemma 20, WFS 2 (P ) k WFS 2 (P [ fag) as desired.

Q.E.D. Theorem 23 (Principle 1, Cumulativity, GPPE are incompatible). For well-behaved semantics satisfying Principle 1, Cumulativity and GPPE are incompatible. Proof. Let SEM be a well-behaved semantics. Let us consider P : a :a P 0 : a :a

b

:a

b

a

Using relevance (contained in well-behavedness) with respect to a, we conclude that a 2 SEM (P ) if Principle 1 holds. If GPPE holds, then also a 2 SEM (P 0 ) (because P and P 0 are GPPE-equivalent : any semantics satisfying GPPE will consider P and P 0 equivalent, because applying GPPE to P 0 just gives P ). Because of GPPE-equivalence of P and P 0 we also have b 2 SEM (P 0 ) i b 2 SEM (P ). Because of well-behavedness, SEM(P 0 ) = fa; bg (SEM must be a model of the second rule) and thus SEM(P ) = fa; bg. Now SEM(P [ fag) = fa; :bg, because well-behaved semantics extend WFS and WFS(P [ fag) = fa; :bg. Cautious monotony therefore fails. Q.E.D. 16

Theorem 24 (Characterization of WFS ). 1

WFS is the least well-behaved extension of WFS satisfying Principle 1 and GPPE. 1

Proof. This is immediate by construction. Because we only apply our transformations (including GPPE) and Principle 1. So the outcome is the least such semantics. Stronger semantics might decide some of the unde ned atoms (to true or false) but coincide on the atoms already decided.

Conjecture 1 (Characterization of WFS ). 2

WFS is the least well-behaved extension of WFS satisfying Principle 2 and Cumulativity. 2

A proof of this conjecture is not obvious. This is because during the construction of WFS2 we not only used Principle 2 and our basic transformations (i.e. without GPPE), but we also used GPPE in that we mentioned the normalform. Of course, this is quite an indirect use of GPPE (in particular, the outcome semantics does not satisfy it), but it makes a rigorous proof dicult. On the other hand, we have cumulativity available, which was not used at all in the construction. What about our partial monotony condition? In fact, we can show that partial monotony already implies Supraclassicality, so that polynomial complexity gets lost, and the underlying semantics must be an extension of WFS+ .

Theorem 25 (Partial Monotony implies Supraclassicality).

Let SEM be a semantics satisfying RED and partial monotony. Then SEM already satis es supraclassicality. Proof. Let P j= b. We de ne

P 0 := P [ f xnew2 b

xnew1 ;

:xnew g 2

Obviously, P 0 j= b and b 2 SEM (P 0 ). Therefore, by partial monotony, b 2 SEM (P 0 [ fxnew1 g). But

SEM (P 0 [ fxnew1 g) = SEM (P ) [ fxnew1 ; xnew2 g by well-behavedness (reduction RED ). Therefore b 2 SEM (P ).

Q.E.D.

Corollary 26 (Partial Monotony Semantics extend WFS ). +

Every well-behaved semantics satisfying partial monotony is an extension of WFS + .

6 Extensions Our approach can be easily used to (1) broaden the scope of STABLE, and (2) to extend it to disjunctive semantics. 17

(1) Broadening the scope of STABLE means to make it consistent and allow a goal-oriented computation on a larger class of programs. To this end, we rst compute one of our semantics WFSi (P ) and only after that apply STABLE:

De nition 27 (STABLEi ).

We de ne versions of STABLE by using our semantics as follows: STABLE i(P ) := STABLE (P WFS (P ) [ WFS i (P )true ) As WFSi are polynomial and STABLE is not, this does not increase the complexity. It is obvious that STABLEi are consistent on much more programs than STABLE is. In addition, the class of programs where STABLE is relevant is also considerably extended. (2) Both our semantics WFS1 (P ) and WFS2 (P ) mainly rely on the notion of a normalform norm wfs (P ) of a program P . But our calculus of transformations is originally de ned for disjunctive programs and therefore naturally applies. Thus we can get disjunctive versions D-WFSi (P ) whose properties still have to be determined. i

7 Conclusion We noticed that some problems involving aggregation and recursion can be expressed using normal programs without makeing any explicit use of aggregation capability, yet they are intuitive. For that we had to consider extensions of WFS, introducing two new polynomial-time computable semantics, namely WFS1 and WFS2 . We studied such extensions and determined which semantics are possible given certain abstract properties like partial evaluation, cumulativity, supraclassicality and partial monotony. We introduced this last principle since we found that it is useful for aggregation. Unfortunately partial monotony implies supraclassicality which immediately introduces NP-completeness. Therefore we had to consider weaker forms of WFS+ , which have weaker forms of supraclassicality built-in. The research about the potential use of these semantics to aggregation and/or other domains is still preliminary. When it is important to model a problem close to classical logic then we should consider WFS1 , WFS2 . That is the case, for instace, when we need a semantics that is relatively monotonic with respect to the extensional database. WFS1 is de ned extending the calculus for WFS but it still shares a nice property: it is con uent and terminating. In addition, WFS1 is well-behaved, satis es partial evaluation, but loses the cumulativity property. WFS2 is de ned based on extending WFS by principle 2, which allows as to infer a when the underlying program contains a clause a :a. WFS2 is also well-behaved, satis es cumulativity, rationality but it not longer satis es partial evaluation. We showed that for well-behaved semantics, principle 1, cumulativity and GPPE are in general incompatible. Moreover, the existence WFS2 gives a negative answer to an open conjecture which claimed that there are no well behaved 18

and rational semantics other than WFS, WFS0 and WFS+ . We use our approach to broaden the scope of STABLE and D-WFS, introducing STABLE1 , STABLE2 and D-WFSi , whose properties still have to be determined.

References [ABW88] Krzysztof R. Apt, Howard A. Blair, and Adrian Walker. Towards a theory of declarative knowledge. In Jack Minker, editor, Foundations of Deductive Databases, chapter 2, pages 89{148. Morgan Kaufmann, 1988. [BD95] Stefan Brass and Jurgen Dix. A General Approach to Bottom-Up Computation of Disjunctive Semantics. In J. Dix, L. Pereira, and T. Przymusinski, editors, Nonmonotonic Extensions of Logic Programming, LNAI 927, pages 127{155. Springer, Berlin, 1995. [BD96] Gerhard Brewka and Jurgen Dix. Knowledge representation with logic programs. Technical report, Tutorial Notes of the 12th European Conference on Arti cial Intelligence (ECAI '96), 1996. Also appeared as Technical Report 15/96, Dept. of CS of the University of Koblenz-Landau. Will appear as Chapter 6 in Handbook of Philosophical Logic , 2nd edition (1998), Volume 6, Methodologies. [BD97a] Stefan Brass and Jurgen Dix. Characterizations of the Disjunctive Stable Semantics by Partial Evaluation. Journal of Logic Programming, 32(3):207{ 228, 1997. (Extended abstract appeared in: Characterizations of the Stable Semantics by Partial Evaluation LPNMR, Proceedings of the Third International Conference, Kentucky , pages 85{98, 1995. LNCS 928, Springer.). [BD97b] Stefan Brass and Jurgen Dix. Characterizations of the Disjunctive Wellfounded Semantics: Con uent Calculi and Iterated GCWA. Journal of Automated Reasoning, to appear, 1997. (Extended abstract appeared in: Characterizing D-WFS: Con uence and Iterated GCWA. Logics in Arti cial Intelligence, JELIA '96 , pages 268{283, 1996. Springer, LNCS 1126.). [BD97c] Stefan Brass and Jurgen Dix. Semantics of Disjunctive Logic Programs Based on Partial Evaluation. Journal of Logic Programming, accepted for publication, 1997. (Extended abstract appeared in: Disjunctive Semantics Based upon Partial and Bottom-Up Evaluation, Proceedings of the 12-th International Logic Programming Conference, Tokyo , pages 199{213, 1995. MIT Press.). [BF91] Nicole Bidoit and Christine Froidevaux. General logical Databases and Programs: Default Logic Semantics and Strati cation. Information and Computation, 91:15{54, 1991. [BG94] Chitta Baral and Michael Gelfond. Logic Programming and Knowlege Representation. Journal of Logic Programming, 19-20, 1994. [BZF97] Stefan Brass, Ulrich Zukowski, and Burkhardt Freitag. Transformation Based Bottom-Up Computation of the Well-Founded Model. In J. Dix, L. Pereira, and T. Przymusinski, editors, Nonmonotonic Extensions of Logic Programming, LNAI 1216, pages 171{201. Springer, Berlin, 1997. [CB94] Peter Cholak and Howard Blair. The Complexity of Local Strati cation. Fundamenta Informaticae, XXI(4):333{344, 1994. [CKPR73] A. Colmerauer, H. Kanoui, R. Pasero, and P. Roussel. Un systeme de communication homme-machine en francais. Technical report, Groupe de Intelligence Arti cielle Universite de Aix-Marseille II, 1973.

19

[Cla78] [Dix92]

[Dix95a] [Dix95b] [DM94] [GL88] [Kow74] [Kow79] [KS91] [Liu95] [Llo87] [OJ97] [Ros90] [Sch92] [SZ90] [vG92] [vGRS91]

Keith L. Clark. Negation as Failure. In H. Gallaire and J. Minker, editors, Logic and Data-Bases, pages 293{322. Plenum, New York, 1978. Jurgen Dix. A Framework for Representing and Characterizing Semantics of Logic Programs. In B. Nebel, C. Rich, and W. Swartout, editors, Principles of Knowledge Representation and Reasoning: Proceedings of the Third International Conference (KR '92), pages 591{602. San Mateo, CA, Morgan Kaufmann, 1992. Jurgen Dix. A Classi cation-Theory of Semantics of Normal Logic Programs: I. Strong Properties. Fundamenta Informaticae, XXII(3):227{255, 1995. Jurgen Dix. A Classi cation-Theory of Semantics of Normal Logic Programs: II. Weak Properties. Fundamenta Informaticae, XXII(3):257{288, 1995. Jurgen Dix and Martin Muller. Partial Evaluation and Relevance for Approximations of the Stable Semantics. In Z.W. Ras and M. Zemankova, editors, Proceedings of the 8th Int. Symp. on Methodologies for Intelligent Systems, Charlotte, NC, 1994, LNAI 869, pages 511{520, Berlin, 1994. Springer. Michael Gelfond and Vladimir Lifschitz. The Stable Model Semantics for Logic Programming. In R. Kowalski and K. Bowen, editors, 5th Conference on Logic Programming, pages 1070{1080. MIT Press, 1988. R.A. Kowalski. Predicate logic as a programming language. In Proceeedings IFIP' 74, pages 569{574. North Holland Publishing Company, 1974. R. Kowalski. Algorithm = Logic + Control. Communications of the ACM, 22:424{436, 1979. David B. Kemp and Peter J. Stuckey. Semantics of Logic Programs with Aggregates. In Vijay Saraswat and Kazunori Ueda, editors, Proceedings of the 1991 Int. Symposium on Logic Programming, pages 387{401. MIT, June 1991. M. Liu. Relationlog: A Typed Extension to Datalog with Sets and Tuples. In John Lloyd and Evan Tick, editors, Proceedings of the 1995 Int. Symposium on Logic Programming, pages 83{97. MIT, June 1995. John W. Lloyd. Foundations of Logic Programming. Springer, Berlin, 1987. 2nd edition. Mauricio Osorio and Bharat Jayaraman. Aggregation and WFS+. In J. Dix, L. Pereira, and T. Przymusinski, editors, Nonmonotonic Extensions of Logic Programming, LNAI 1216, pages 71{90. Springer, Berlin, 1997. Kenneth A. Ross. Modular strati cation and magic sets for DATALOG programs with negation. In Proc. of the Ninth ACM SIGACT-SIGMODSIGART Symposium on Principles of Database Systems (PODS'90), pages 161{171, 1990. John S. Schlipf. Formalizing a Logic for Logic Programming. Annals of Mathematics and Arti cial Intelligence, 5:279{302, 1992. D. Sacca and C. Zaniolo. Stable models and non-determinism in logic programs with negation. In Proc. the 9th ACM PODS, pages 205{217, 1990. Allen van Gelder. The Well-Founded Semantics of aggregation. In Proc. of the 11th ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, San Diego, USA, pages 127{138. ACM Press, 1992. Allen van Gelder, Kenneth A. Ross, and John S. Schlipf. The well-founded semantics for general logic programs. Journal of the ACM, 38:620{650, 1991.

20

Available Research Reports (since 1995):

1997

23/96 Peter Baumgartner, Peter Frohlich,

Ulrich Furbach, Wolfgang Nejdl. Tableaux for Diagnosis Applications. Well-Behaved Semantics Suitable for 22/96 Jurgen Ebert, Roger Suttenbach, Ingar Aggregation. Uhe. Meta-CASE in Practice: a Case for KOGGE. 10/97 Chandrabose Aravindan, Peter Baumgartner. A Rational and Ecient 21/96 Harro Wimmel, Lutz Priese. Algebraic Algorithm for View Deletion in Databases. Characterization of Petri Net Pomset Semantics. 9/97 Wolfgang Albrecht, Dieter Zobel. Integrating Fixed Priority and Static 20/96 Wenjin Lu. Minimal Model Generation Scheduling to Maintain External Based on E-Hyper Tableaux. Consistency. 19/96 Frieder Stolzenburg. A Flexible System for 8/97 Jurgen Ebert, Alexander Fronk. Constraint Disjunctive Logic Programming. Operational Semantics of Visual Notations. 18/96 Ilkka Niemela (Ed.). Proceedings of the 7/97 Thomas Marx. APRIL - Visualisierung der ECAI'96 Workshop on Integrating Anforderungen. Nonmonotonicity into Automated Reasoning Systems. 6/97 Jurgen Ebert, Manfred Kamp, Andreas 17/96 Jurgen Dix, Luis Moniz Pereira, Teodor Winter. A Generic System to Support Przymusinski. Non-monotonic Extensions Multi-Level Understanding of of Logic Programming: Theory, Heterogeneous Software. Implementation and Applications 5/97 Roger Suttenbach, Jurgen Ebert. A Booch (Proceedings of the JICSLP '96 Metamodel. Postconference Workshop W1). 4/97 Jurgen Dix, Luis Pereira, Teodor 16/96 Chandrabose Aravindan. DisLoP: A Przymusinski. Prolegomena to Logic Disjunctive Logic Programming System Programming for Non-Monotonic Based on PROTEIN Theorem Prover. Reasoning. 15/96 Jurgen Dix, Gerhard Brewka. Knowledge 3/97 Angelika Franzke. GRAL 2.0: A Reference Representation with Logic Programs. Manual. 14/96 Harro Wimmel, Lutz Priese. An 2/97 Ulrich Furbach. A View to Automated Application of Compositional Petri Net Reasoning in Arti cial Intelligence. Semantics. 1/97 Chandrabose Aravindan, Jurgen Dix, Ilkka 13/96 Peter Baumgartner, Ulrich Furbach. Niemela . DisLoP: A Research Project on Calculi for Disjunctive Logic Programming. Disjunctive Logic Programming. 12/96 Klaus Zitzmann. Physically Based Volume Rendering of Gaseous Objects. 1996 11/96 J. Ebert, A. Winter, P. Dahm, A. Franzke, R. Suttenbach. Graph Based 28/96 Wolfgang Albrecht. Echtzeitplanung fur Modeling and Implementation with Alters- oder Reaktionszeitanforderungen. EER/GRAL. 27/96 Kurt Lautenbach. Action Logical 10/96 Angelika Franzke. Querying Graph Correctness Proving. Structures with G2 QL. 26/96 Frieder Stolzenburg, Stephan Hohne, 9/96 Chandrabose Aravindan. An abductive Ulrich Koch, Martin Volk. Constraint framework for negation in disjunctive logic Logic Programming for Computational programming. Linguistics. 8/96 Peter Baumgartner, Ulrich Furbach, Ilkka 25/96 Kurt Lautenbach, Hanno Ridder. Die Niemela . Hyper Tableaux. Lineare Algebra der Verklemmungsvermeidung | Ein 7/96 Ilkka Niemela, Patrik Simons. Ecient Petri-Netz-Ansatz. Implementation of the Well-founded and Stable Model Semantics. 24/96 Peter Baumgartner, Ulrich Furbach. Re nements for Restart Model 6/96 Ilkka Niemela . Implementing Elimination. Circumscription Using a Tableau Method.

11/97 Jurgen Dix, Mauricio Osorio. Towards

5/96 Ilkka Niemela . A Tableau Calculus for 4/96 3/96 2/96 1/96

Minimal Model Reasoning. Stefan Brass, Jurgen Dix, Teodor. C. Przymusinski. Characterizations and Implementation of Static Semantics of Disjunctive Programs. Jurgen Ebert, Manfred Kamp, Andreas Winter. Generic Support for Understanding Heterogeneous Software. Stefan Brass, Jurgen Dix, Ilkka Niemela, Teodor. C. Przymusinski. A Comparison of STATIC Semantics with D-WFS. J. Ebert (Hrsg.). Alternative Konzepte fur Sprachen und Rechner, Bad Honnef 1995.

1995 21/95 J. Dix and U. Furbach. Logisches

Programmieren mit Negation und Disjunktion. 20/95 L. Priese, H. Wimmel. On Some Compositional Petri Net Semantics. 19/95 J. Ebert, G. Engels. Speci cation of Object Life Cycle De nitions. 18/95 J. Dix, D. Gottlob, V. Marek. Reducing Disjunctive to Non-Disjunctive Semantics by Shift-Operations. 17/95 P. Baumgartner, J. Dix, U. Furbach, D. Schafer, F. Stolzenburg. Deduktion und Logisches Programmieren. 16/95 Doris Nolte, Lutz Priese. Abstract Fairness and Semantics. 15/95 Volker Rehrmann (Hrsg.). 1. Workshop Farbbildverarbeitung. 14/95 Frieder Stolzenburg, Bernd Thomas. Analysing Rule Sets for the Calculation of Banking Fees by a Theorem Prover with Constraints. 13/95 Frieder Stolzenburg. Membership-Constraints and Complexity in Logic Programming with Sets.

12/95 Stefan Brass, Jurgen Dix. D-WFS: A

Con uent Calculus and an Equivalent Characterization.. 11/95 Thomas Marx. NetCASE | A Petri Net based Method for Database Application Design and Generation. 10/95 Kurt Lautenbach, Hanno Ridder. A Completion of the S-invariance Technique by means of Fixed Point Algorithms. 9/95 Christian Fahrner, Thomas Marx, Stephan Philippi. Integration of Integrity Constraints into Object-Oriented Database Schema according to ODMG-93. 8/95 Christoph Steigner, Andreas Weihrauch. Modelling Timeouts in Protocol Design.. 7/95 Jurgen Ebert, Gottfried Vossen. I-Serializability: Generalized Correctness for Transaction-Based Environments. 6/95 P. Baumgartner, S. Bruning. A Disjunctive Positive Re nement of Model Elimination and its Application to Subsumption Deletion. 5/95 P. Baumgartner, J. Schumann. Implementing Restart Model Elimination and Theory Model Elimination on top of SETHEO. 4/95 Lutz Priese, Jens Klieber, Raimund Lakmann, Volker Rehrmann, Rainer Schian. Echtzeit-Verkehrszeichenerkennung mit dem Color Structure Code | Ein Projektbericht. 3/95 Lutz Priese. A Class of Fully Abstract Semantics for Petri-Nets. 2/95 P. Baumgartner, R. Hahnle, J. Posegga (Hrsg.). 4th Workshop on Theorem Proving with Analytic Tableaux and Related Methods | Poster Session and Short Papers. 1/95 P. Baumgartner, U. Furbach, F. Stolzenburg. Model Elimination, Logic Programming and Computing Answers.