A System for Computing Constrained Default Logic Extensions G. Antoniou, A. P. Courtneyy, J. Ernstzand M.A. Williamsx Abstract
The aim of this paper is to describe the algorithmic foundations of the part of the program Exten responsible for the computation of extensions in Constrained Default Logic. Exten is a system that computes extensions for various default logics. The eciency of the system is increased by pruning techniques for the search tree. We motivate and present these techniques, and demonstrate that they can cut down the size of the search tree signi cantly. Quite importantly, they complement well the recently developed strati cation method. This technique has to be modi ed to work properly with Constrained Default Logic, and we show how this can be done. Exten supports experimentation with default logic, allowing the user to set various parameters. Also it has been designed to be open to future enhancements, which are supported by its object{oriented design. Exten is part of our long{term e ort to develop an integrated toolkit for intelligent information management based on nonmonotonic reasoning and belief revision methods.
1 Introduction Nonmonotonic reasoning provides mechanisms enabling knowledge systems to work with incomplete information. One of the main approaches is default logic [14] which allows one to draw plausible conclusions based on default rules. Several variants have been proposed [3, 7, 11, 12], and Schaub's Constrained Default Logic (CDL) [16] is a notable one. It adopts a view di erent from the classical approach in that default justi cations are meant to establish a belief set which supports the conclusions drawn. The e ect of this design decision is that joint consistency of justi cations is required when building an extension. CDL has School of Computing and Information Technology, Grith University, QLD 4111, Australia,
[email protected] y Department of Computer Science, University of Sydney, NSW 2006, Australia,
[email protected] z Department of Management, University of Newcastle, NSW 2308, Australia,
[email protected] x Department of Management, Unversity of Newcastle, NSW 2308, Australia
a series of representational advantages such as semi{monotonicity and the safe use of lemmas [16]. Work in nonmonotonic reasoning has neglected the development of operational systems for far too long (Theorist [13] being a notable exception), so the potential of default logic for applications has not been demonstrated yet. Only recently did the focus switch to implementations and applications. Work in this direction includes [2, 5, 8, 15, 17]. Implementations of Constrained Default Logic have focused on query evaluation [10, 17]. This paper describes Exten, a system that computes extensions of default theories. Even though query evaluation is often desirable, we note that it is associated with the credulous interpretation (the union of extensions). On the other hand, it has been shown [18] that for the sceptical approach (which focuses on the intersection of all extensions of the theory) it can be necessary to compute all extensions. Moreover, often it is interesting to determine which alternative \world views" are supported by the given knowledge. Our system in its current form computes extensions, and work is being undertaken to implement goal{driven query evaluation. Exten is implemented in an object{oriented manner, therefore it is easily expandable. It computes extensions not only for Constrained Default Logic, but also for Reiter's original logic [14] and Justi ed Default Logic [11]. The implementation is based on a forward{chaining approach, that means, we start with the set of facts and apply defaults as long as no more are applicable; this is in contrast with the work of Risch and Schwind [15] who propose a backward{chaining approach. One basic eciency{increasing technique used is strati cation which was adapted from [4] and used in the system DeReS [5]. Essentially, strati cation is used to decompose the set of defaults into sets (strata) in such a way that extensions can be computed in a modular way. The de nition of a strati cation function has to be modi ed to work properly with Constrained Default Logic. We do so in section 3 and show the correctness of the modi ed strati cation. The eciency of Exten is signi cantly improved by using tree{pruning techniques which will be motivated and described in section 4. Section 5 gives information about the user interface and the underlying classical theorem prover. Finally, section 6 collects some aspects of current and future work.
2 Forward{chaining default reasoning We assume that the reader is familiar with the basics of classical logic. A n with closed rst{order formulae '; 1 ; : : :, n; default has the form ': 1 ;:::; (n > 0). ' is the prerequisite pre(), 1; : : :; n the justi cations just(), and the consequent cons() of . A default theory T is a pair (W; D) consisting of a set of formulae W (the set of facts) and a nite set of defaults D. A default of the form ' : is called normal. A preconstrained default theory has the form (W; D; PC), where (W; D) is a constrained default theory and PC a set of formulae, the constraints of this theory.
n be a default, and E and C deductively closed sets of forLet = ': 1 ;:::; mulae. is applicable to (E; C) i ' 2 E, and f 1; : : :; n; g [ C is consistent. In case T is preconstrained, f 1; : : :; n; g [ C [ PC must be consistent. Now we come to the formal foundation of a forward{chaining approach to Constrained Default Logic. Let T = (W; D) be a default theory and = (0 ; : : :; m ) a sequence of defaults from D without multiple occurrences. We denote by [k] the initial segment of of length k, for k m + 1. In() = Th(W [ fcons() j occurs in g). Con() = Th(f 1 ^ : : : ^ n ^ j f 1 ; : : :; n g = just() and = cons(), for a default occurring in g). If T is preconstrained, then additionally PC Con(). is a process i k is applicable to (In([k]); Con([k])), for all k m. is closed i every 2 D which is is applicable to the pair (In(); Con()) already occurs in . [1] shows that the original de nition of extensions in CDL is equivalent to the following one: A set of formulae (E; C) is an extension of a default theory T i there is a closed process of T such that E = In() and C = Con(). Slightly abusing the notation we often call E an extension of T, if we are not interested in the set of supporting beliefs; actually it is E that will be computed in the following. The processes of a default theory T form a process tree [1]. The traversal of this tree gives us all extensions of T. A maximal path in the process tree corresponds to a closed process of T. In the following sections we restrict attention to propositional default theories. Firstly, strati cation requires this restriction, and secondly, the examples given below are propositional. Exten does work with rst{order default theories, too, but allows only closed defaults; therefore aspects of open defaults, Skolemization etc. are disregarded.
3 Strati ed Constrained Default Logic Strati cation is a powerful method for cutting down the computational e ort in default reasoning [4]. Here we present a variation that is suitable for Constrained Default Logic, meaning that Theorem 1 below is true: if a strati cation function exists, then we may restrict the search space without modifying the set of extensions. Let D be a set of defaults. A function assigning an ordinal number to every default from D is a constrained strati cation function, i for any , 0 2 D with = varphi: 1 ;:::; n and 0 = ' : 1 ;:::; n the following conditions hold: 1. If V ar(') \ V ar( 0 ) 6= ; then () ( 0 )1. 0
0
0
0
1
where V ar( ) is the set of propositional variables occurring in the formula .
2. If (V ar(just()) [ V ar( )) \ (V ar(just( 0 )) [ V ar( 0 )) 6= ; then () = ( 0 )2 . decomposes D into layers D1 ; : : :; Dl of subsets (called strata) of ascending value under . A default theory T = (W; D) is strati ed if W is consistent, V ar(W) \ V ar(cons(D) [ just(D)) = ;, and there exists a constrained strati cation function for D. Here is the main result which shows that extensions in CDL can be computed bottom{up from stratum to stratum. Theorem 1 Let be a strati cation function for a nite set of defaults D, D1 [ : : : [ Dl the decomposition of D according to . Let W be a consistent set of formulae such that V ar(W) \ V ar(cons(D) [ just(D)) = ;. Then (E; C) is an extension of T = (W; D), i for all 0 i l there exists (Ei ; Ci) such that (El ; Cl ) = (E; C), (E0; C0) = (Th(W); Th(W)), and for all 1 i l, (Ei; Ci) is an extension of the preconstrained default theory Ti = (Ei?1; Di ; Ci?1). In working in a bottom{up fashion, we pass the extension computed in one stratum to the next higher stratum; this idea is also used by Cholewinski in his correctness proof for Reiter's default logic. In Constrained Default Logic we must additionally pass the computed constraint set Ci?1 to the next layer; this is the reason why we are using preconstrained default theories (Ei?1; Di; Ci?1). The proof of the following lemma goes by induction over the length of a linear resolution refutation of Clauses(W [ cons(M) [ f:'g). Lemma 2 Let T = (W; D) be a strati ed default theory with constrained strati cation function . Let 2 D and ' = pre(). If M D is a minimal set of defaults with ' 2 Th(W [ cons(M)), then for every default 0 2 M , ( 0 ) (). Lemma 3 Let T and be as in Theorem 1, and = (0 ; : : :; n) a closed process of T . De ne 0 = (00 ; : : :; n0 ) as follows: For all i ; j in and i0 ; j0 in 0 with i < j , i = i0 and j = j0 , we have that i0 > j 0 i (i ) > (j ). Then 0 is a closed process of T with In(0 ) = In() and Con(0 ) = Con(). Proof: Since 0 is a permutation of , the claim regarding the In and the Con{sets is trivial. Similarly, 0 is closed because is closed. We conclude by showing that the defaults in 0 are applicable in this order. m , In() [ Con() [ f 1 ; : : :; m ; g For any i0 n and i0 = ': 1 ;:::; 0 0 0 0 is consistent. So In( [i ]) [ Con( [i ]) [ f 1; : : :; m ; g is consistent, since In(0 [i0]) In(0 ) = In() and Con(0 [i0]) Con(0) = Con(). is a process, so ' 2 In([i]), where i = i0 . De ne = fk j k < i; (k ) (i )g: Let M be a minimal set of defaults in [i] such that W [ cons(M) j= '. By Lemma 2, ( 0 ) (i ) for all 0 2 M. Therefore, by the de nition of 0 , all defaults in M occur before i0 in 0 , thus W [ cons(M) In(0 [i0 ]) and ' 2 In(0 [i0]). 0
0
0
0
0
0
0
2
The de nition can be relaxed easily to include normal default theories, as discussed in [4].
Proof of Theorem 1: (: For every 1 i l let i be a closed process of length i such that (In(i ); Con(i)) = (Ei ; Ci). Let = 1 : : : l with length 3 . We will show that = (0 ; : : :; s ) is a process. For all 0 k let lk = k ? 1 ? : : : ? (k)?1 and jk = (k), where (k) is the stratum of k , that is, k 2 D(k) . The following proof steps appear to be technically dicult, but essentially they require simple \information transfer" from positions in a \local" process i (of Ti ) to the \global" process (of T), and vice versa. Our main claim is that In([k]) = In(jk [lk ]) and Con([k]) = Con(jk [lk ]), for all 0 k . We will show this by induction on k. The claim is clear for k = 0. So let the claim be true for [k], and consider [k + 1]. Case 1: jk 6= jk+1 . Then we have the following sequence of equalities: In(jk+1 [lk+1]) = Ejk+1 ?1 = Ejk = In(jk ) = Th(In(jk [jk ? 1]) [ cons( jk )) = Th(In(jk [lk ]) [ fcons(k )g) = Th(In([k]) [ fcons(k )g) = In([k + 1]):
(Eq 1) (Eq 2) (Eq 3) (Eq 4) (Eq 5) (Eq 6) (Eq 7)
Because jk 6= jk+1 we have k+1 62 jk and therefore k+1 is the rst occuring default in jk+1 by the de nition of . This means lk+1 = 0. With the de nition of In(:) we have (Eq 1). (Eq 2) follows directly from the de nition of this case: k+1 is the rst default in the new stratum jk+1 , therefore the previous default = k in was included in the next lower stratum jk . From jk being a process we get (Eq 3) and (Eq 4). Again with jk 6= jk+1 we have k 2 jk and with k+1 62 jk and the de nition of we have k is the last occuring default in jk which leads to (Eq 5). By induction hypothesis we get (Eq 6), and nally (Eq 7) by the de nition of the In{set. Case 2: jk = jk+1 . Here we have the following sequence of equalities: In(jk+1 [lk+1]) = In(jk [lk + 1]) = Th(In(jk [lk ]) [ fcons(k )g) = In([k + 1]):
(Eq 1) (Eq 2) (Eq 3)
Because jk = jk+1 and due to the de nition of we conclude lk+1 = lk + 1. So we have (Eq 1). The De nition of In(:) leads directly to (Eq 2), and (Eq 3) is clear by induction hypothesis. A similar result can be established for the Con{set. Then we are able to conclude that is a process of T, using the fact that the i are processes of Ti . 3
where denotes concatenation of sequences.
To show that is closed, consider a default 2 D which is applicable to (In(); Con()). Let 2 Di for some i l. By Lemma 2 we know that defaults from j for j > i do not contribute anything to the derivation of pre() by the construction of . Therefore is already applicable to (In(i ); Con(i )). Since i is a closed process of Ti , occurs in i and thus in . ): Consider a closed process 0 of T such that (In(0 ); Con(0)) = (E; C). By Lemma 3 there is a closed process = (0 ; : : :; s) of T which respects 4 , and for which In() = In(0 ) and Con() = Con(0 ). Since respects it can be written in the form 1 : : : l , where i includes defaults only from Di . For 0 < i l de ne Ei = In(1 : : : i ) and Ci = Con(1 : : : i). Let E0 = Th(W) and C0 = Th(W). Now we will show that every i is a closed process of the default theory Ti by induction on i. For i = 0 we have that the empty process 0 is a closed process and leads to the extension (Th(W); Th(W)) of T0 = (W; ;). So assume that j is a closed process of the preconstrained default theory Tj = (Ej ?1; Dj ; Cj ?1) which de nes the extension (Ej ; Cj ), for all j i. We have to prove this claim for i + 1. First we show that Ti+1 is a strati ed default theory. W is consistent, therefore Ei is consistent. Because T is a constrained default theory we have V ar(W) \ (V ar(cons(D)) [ V ar(just(D))) = ;. Also (V ar(cons(Di+1 )) [ V ar(just(Di+1 ))) \ (V ar(cons(Di )) [ V ar(just(Di ))) = ;, by the de nition of a strati cation function. Because Ei Th(W [ cons(Di )) we have V ar(Ei) \ (V ar(cons(Di+1 )) [ V ar(just(Di+1 ))) = ;. So Ti+1 is a strati ed default theory (take the trivial strati cation function assigning the same value to all defaults). Next we show that i+1 is a constrained process. For all 0 j and all 0 i l let kj;i = j + 1 + : : : + i . We shall show In([kj;i]) = In(i [j]) and Con([kj;i]) = Con(i [j]) (in the following we assume that just(m ) = f 1 ; : : :; ng and cons(m ) = ): Con(i+1[j]) =
(Eq 1)
Th(W [ f 1; : : :; n; j m 2 i+1 ; m < j g) =
(Eq 2)
Th(W [ f 1; : : :; n; j m 2 1 _ : : : _ m 2 i _ (m 2 i+1 ^ m < j)g) =
(Eq 3)
Th(W [ f 1; : : :; n; jm 2 ^ m < kj;i+1g) =
(Eq 4)
Con([kj;i+1]: (Eq 1) is true by the de nition of i+1 and Con(:). The sequently de nition of Ci together with the induction hypothesis leads to (Eq 2). The de nition of all i from gives us (Eq 3), and (Eq 4) follows from the de nition of 4
That means, i < j implies (i) (j ).
Con(:). Because the sequence of equalities of the In(:) set is similar to the sequence of equalities of the Con(:) set it will not be shown here. Together we have j is applicable to (In(i+1 [j]); Con(i+1[j])) because it is applicable to (In([j]); Con([j])) due to being a process. Now we show that i+1 is also closed. Assume i+1 is not closed. Then choose 2 Di+1 such that is applicable to (In(i+1 ); Con(i+1 )) and 62 i+1 . Due to the de nition of all Ti and i this means is applicable to (In([j]); Con([j])) with j = 1 +: : :i+1 . Recalling the special form of and the fact that is closed, we conclude that is not applicable to (In(); Con()). This means there must be some defaults in D>i+1 which makes the set Con() inconsistent to the conjunction of justi cations and the consequent of . But this is impossible by the conditions on strati cation. So the assumption was wrong and we have i+1 is a closed process. Thus i+1 is a closed process i+1 and constructs the extension (Ei+1 ; Ci+1) = (In(i+1 ); Con(i+1)).
4 Tree{pruning techniques In this section we discuss brie y the tree{pruning techniques used in Exten. We do not claim that all of them are entirely novel, but the most interesting point is the integration with a forward{chaining approach. It should be noted that forward{chaining in its own right is signi cantly superior to backward{ chaining approaches for many default theories (essentially for theories where most defaults are not applicable because their prerequisite hasn't been proven). The pruning techniques discussed below are particularly good for other cases of default theories, and therefore they complement the advantages of forward{ chaining. For example, Theorem 4 below shows that we can \restrict" the search space to 2n instead of having n! as in naive forward{chaining. Of course this result is not novel, since we could work backward starting with the 2n potential extensions, as done in [15] and [17]; but it shows that even in cases that are not suitable for forward{chaining, we are not worse o . The pruning methods based on Theorems 5 and 6 bring signi cant search space reductions, and are novel to our knowledge, despite their simplicity.
4.1 Exponential pruning
The de nition of processes shows that there are potentially n! possible processes, where n is the number of defaults in D. On the other hand, there are maximally 2n possible extensions, so there is a huge discrepancy. Fortunately it is easy to prune the process tree in such a way that at most 2n paths are constructed. The pruning is based on the following observation (for a proof see [6]). Theorem 4 Let = 1 2 3 be a closed process of T , and suppose that pre() 2 In(1 ). Then 0 = 1 2 3 is a closed process of T , too.
Based on this result, the procedure for computing all extensions using a so{called exponentially pruned process tree can be described as follows:
PROCEDURE Compute-Ext( , Drest, Dout) BEGIN NotClosed := false; M := Drest | pre( ) In( ) = 1 n ; IF M = THEN IF IsClosed( , Dout) THEN ext := ext In( ) FI ELSE FOR i := 1 TO n DO Drest := Drest i ; IF i i is consistent THEN Compute-Ext( i , Drest, Dout); NotClosed := true; FI; Dout := Dout i END; IF NotClosed = false AND IsClosed( , Dout) THEN ext := ext In( ) FI FI END
f 2 ;
2
[f
g
f ; : : :; g
g
f g Con() [ just( ) [ fcons( )g [ f g
[f
g
The initial call of Compute{Ext uses the empty process for , the set of all available defaults D for Drest, and the empty set for Dout. The variable ext collects all extensions of T. The following remarks are in order. First, if a default i is applicable at the current node of the process tree, then it is deleted from the set of available defaults Drest. Theorem 4 shows that by applying i rst, we obtain all extensions underneath the current node that include i . The same applies in case pre(i ) 2 In(), but i is blocked in . Obviously, i will remain blocked even if further defaults are applied since In() grows monotonically with , therefore we do not lose any extension by removing it from the set of available defaults. The only catch is that when we are testing for the closure of a process, we must test the applicability of the `dropped' defaults from Dout. Consider the default theory5 T = (W; D), where W = ; and D = f0 = true:a ; 1 = true:b ; 2 = true:c ; 3 = true:d g. The process tree with exponential a b c d pruning is found in Figure 1. To illustrate how the procedure works, let us discuss part of the generation of this tree. 5 All examples in this paper are normal theories for the sake of simplicity, but the pruning methods described apply to arbitrary default theories.
Figure 1: First the leftmost path is generated, leading to an extension. Then we look for an alternative, so we have to backtrack by two stages; then we can apply 3 instead of 2 . Note that, by de nition of Compute{Ext, 2 62 Drest (which currently is empty), yet we have to check it for not being blocked (which is true in our case). If we had omitted this test then we would have concluded wrongly that Th(fa; b; dg) is an extension. This example shows that we have a long way to go in order to avoid unsuccessful traversal of branches that cannot lead to new extensions. The next subsections will bring signi cant improvements.
4.2 Final segment pruning
In this and the following subsection we describe methods which ensure that every extension has a default di erentiating it from every previous extension. The following theorem delivers us such a distinguishing method for some cases (for a formal proof see [6]). Theorem 5 Let = 1 2 be a successful path of the exponentially pruned process tree, closed under the defaults currently available (that is, Drest). Further suppose that no new default was added to Dout during the construction of 2 . Then no new extensions can be found by expanding the process tree under 1 following the procedure in subsection 4.1. Let us look at some examples. First consider the process tree from Figure 1. The process tree using the pruning method just described is tree 1) in Figure 2. Simply, the leftmost path has all defaults applied, therefore, using Theorem 5, we conclude that no other path underneath the root or any of the other nodes along this path can lead to a new extension. Let T = (W; D), where W = f:ag and D = f0 = true:a ; 1 = cb:b ; 2 = true:c ; 3 = true:d g). T has the single extension Th(f:a; b;ac; dg). Tree 2) in c d Figure 2 shows the pruned tree for this example. 0 is blocked at the root. Defaults 2, 1 and 3 are applied leading to a closed and successful process. Of course, the path of the pruned process tree does block a default, namely 0 . But
Figure 2: note that it is not a new default that is blocked, ie it is not due to the path that 0 is blocked. Therefore we may terminate the search.
4.3 Goal pruning
Theorem 6 Let be a closed path in the exponentially pruned process tree of
the default theory T = (W; D). Let M be the set of defaults in D (including those that have been removed) that are blocked at the leaf of this path. Then every new extension computed after must contain at least one default from M . M is called a goal.
Its proof can be found in [6]). Note that while Theorem 5 a ects only the part of the process tree underneath the initial segment, Theorem 6 a ects all paths constructed after , including those traversed after backtracking. Thus it has a global e ect on the remaining process tree to be traversed, whilst Theorem 5 had a local e ect underneath the initial segment. The way we take advantage of Theorem 6 is straightforward. When we backtrack and try to determine further extensions, the usual method is to try all defaults that are applicable at that node and have not yet been tried. If a closed path has been determined, and M = f1 ; : : :; ng, then it is sucient to consider all subtrees starting with one of the defaults 1 ; : : :; n (making combined use of theorems 4 and 6, and provided that all these defaults are applicable at that node). Once several maximally successful paths have been determined, we have several goals, which are maintained in a set of goals fG1; : : :; Gk g. Theorem 3 tells us that every further extension will contain at least one element from every Gi . The way to achieve this is to use G1 at the rst stage, then subsequently G2 etc, thus taking advantage of the information available. To keep the tree small, Exten uses a heuristic which prefers shorter goals over longer ones. Consider the default theory T = (W; D), where W = ; and D = f2 = true:b ; 3 = true:c ; 0 = true:a ; 1 = true::a g). b c a :a Its pruned process tree according to Theorem 5 is shown in Figure 3, the pruned tree according to Theorem 6 is found in Figure 4. We note the di erence
Figure 3:
Figure 4: in the tree size, and concentrate on Figure 4. The rst maximally successful path found is 2-3-0, leading to a goal f1g. With simple backtracking we nd the second maximally successful path 2-3-1, and have thus a second goal f0 g. Note that 0 was not available (that means not in Drest), but still we can say that any further extension must include 0 . If we backtrack, we have two goals, G1 = f1g and G2 = f0 g. We use the rst goal arbitrarily (both goals have the same length), and then try to apply 0 . It is the only default in G2 and blocked, therefore this path cannot lead to a new extension. We backtrack once again and repeat the same.
5 Some information on Exten
5.1 The user interface
Exten has a command line interface based around a small language, allowing the
user to de ne or modify a default theory, and to set various parameters (such as compute rst n extensions). As for the system output, there are four levels of granularity. At the simplest level, only the extension is delivered. The second level describes the path (process) leading to the extension, to provide a means of explanation. On the third level, the entire (partial) process tree is displayed; this is done using the external program Dot [9]. Finally, the fourth mode o ers a verbose trace of the
calculation process by displaying additionally the defaults that were tested but were not applicable (of course, this information tends to be an overkill since the tree becomes excessively large).
5.2 The underlying theorem prover
Exten makes use of the recently developed state{of{the{art theorem prover Bluegum [19], which is tableau{based. Bluegum was programmed in an object{
oriented way in C + +, therefore the integration was simple. [15] presents a way of eciently using tableau{based theorem provers in computing extensions. Smaller tableaux can be built and combined together as appropriate to deliver the nal result. This way we can avoid rebuilding parts of the tableau over and over again. For example, the set of facts W is involved in all attempted proofs, so it is reasonable to compute the (open) tableau associated with W once, and attempt to close it later on by adding default consequents and justi cations or negations of prerequisites as appropriate. Currently we are working on the realization of this idea.
6 Current and future work In this paper we described the algorithmic foundations and some other aspects of Exten, a system for computing default logic extensions. Exten is exible and reasonably ecient, and is open to future enhancements. Our ultimate goal is to develop a domain{independent toolkit for intelligent information management based on methods of nonmonotonic reasoning and belief revision. This paper did not provide an experimental evaluation. We intend to compare Exten with other available systems, both using test cases and theoretical computational complexity considerations. Other points of current and future work include the following. We are currently working on goal{driven query evaluation. Furthermore we intend to allow for the introduction of priorities among defaults. Priorities may invalidate some pruning techniques (because pruning relies on the possibility of changing the order of default application), but on the other hand, priorities provide a natural way of signi cantly reducing the process tree (in the case of a strict total order to a single path). Further aspects we are currently working on include the addition of structuring and modularity methods on the representational level, and the study of the dynamics of default reasoning: The current state of the art of default logics is that extensions have to be recomputed from scratch once a modi cation, however slight, has been made. The application of belief revision techniques can help us maintain a large portion of conclusions that we have already drawn.
References [1] G. Antoniou. Nonmonotonic Reasoning with Incomplete and Changing Information. MIT Press 1996 (forthcoming) [2] R. Ben{Eliyahu and I. Niemela (eds.). Applications and Implementations of Nonmonotonic Reasoning Systems. Proceedings of the IJCAI-95 Workshop. [3] G. Brewka. Cumulative default logic: in defense of nonmonotonic inference rules. Arti cial Intelligence 50,2 (1991): 183{205 [4] P. Cholewinski. Strati ed Default Logic. In Proc. Computer Science Logic 1994, Springer LNCS 933, 456-470 [5] P. Cholewinski, W. Marek, A. Mikitiuk and M. Truszczynski. Experimenting with default logic. In Proc. ICLP{95, MIT Press 1995 [6] A. P. Courtney. Towards a Default Logic Workbench: Computing Extensions. Honours Thesis, Basser Department of Computer Science, University of Sydney 1995 [7] J.P. Delgrande, T. Schaub and W.K. Jackson. Alternative Approaches to default logic. Arti cial Intelligence 70 (1994): 167{237 [8] M. Hopkins. Orderings and Extensions. In Proc. ESQUARU'93, Springer 1993, LNAI 747 [9] E. Koutso nos and S.C. North. Dot. Bell Laboratories, http://www.research.att.com/orgs/ssr/book/reuse
[10] T. Linke and T. Schaub. Lemma Handling in Default Logic Theorem Proving. In Proc. Symbolic and Quantitative Approaches to Reasoning and Uncertainty, Springer 1995, LNAI 946, 285{292 [11] W. Lukaszewicz. Considerations of default logic: an alternative approach. Computational Intelligence 4,1(1988): 1{16 [12] A. Mikitiuk and M. Truszczynski. Constrained and rational default logics. In Proc. International Joint Conference on Arti cial Intelligence 1995 [13] D. Poole. A Logical Framework for Default Reasoning. Arti cial Intelligence 36 (1988): 27{47 [14] R. Reiter. A logic for default reasoning. Arti cial Intelligence 13(1980): 81{132 [15] V. Risch and C. Schwind. Tableau{Based Characterization and Theorem Proving for Default Logic. Journal of Automated Reasoning 13 (1994): 223{ 242 [16] T. Schaub. On Constrained Default Theories. In Proc. ECAI-92, Wiley 1992, 304{308
[17] T. Schaub. A new methodology for query{answering in default logics via structure{oriented theorem proving. Journal of Automated Reasoning 15,1 (1995): 95{165 [18] K. Schlechta. Directly Sceptical Inheritance cannot Capture the Intersection of Extensions. In Proc. GMD Workshop on Nonmonotonic Reasoning, GMD 1989 [19] K. Wallace. Proof Truncation Techniques in Model Elimination Tableau{ Based Theorem Proving. Ph.D. Thesis, Department of Computer Science, University of Newcastle 1994
