Putting ABox Updates into Action

. When trying to apply recently developed approaches for up-dating Description Logic ABoxes in the context of an action programming language, one encounters two problems. First, updates generate so-called Boolean ABoxes, which cannot be handled by traditional Description Logic reasoners. Second, iterated update operations result in very large Boolean ABoxes, which, however, contain a huge amount of redundant information. In this paper, we address both issues from a practical point of view.


Introduction
Agent programming languages such as Golog [1] and Flux [2] employ actions whose effects are defined in a logic-based calculus to describe and implement the behaviour of intelligent agents.In the so-called progression approach, the agent starts with a (possibly incomplete) description of the initial state of the world.When an action is performed, it updates this description to take into account the effects of this action.Reasoning about the description of the current state of the world is then, for example, used in the control structures of the agent program to decide which action to apply.The calculi underlying Golog and Flux (situation calculus and fluent calculus, respectively) employ full firstorder predicate logic, which makes the computation of exact updates as well as the use of decision procedures for reasoning about descriptions of the state of the world impossible.To overcome this problem, recent papers [3,4] have proposed to employ a decidable Description Logic (DL) [5] in place of full firstorder predicate logic.In particular, states of the world are then described using a DL ABox.In [4], a method for updating DL ABoxes has been developed, and in [6] it was shown that this notion of an update conforms with the semantics employed by Golog and Flux.
In practice, however, there are two obstacles towards employing the update approach from [4] in the context of agent programs.First, using the update procedures in the form described in [4] quickly leads to unmanageably large ABoxes.However, there is quite some room for optimizations since the updated ABoxes contain a lot of redundant information.The second problem is that the updated ABoxes are so-called Boolean ABoxes, which cannot be directly handled by traditional DL reasoners.The main contributions of this paper are, on the one hand, that we propose and evaluate different optimization approaches for computing more concise updated ABoxes.On the other hand, we compare different approaches for reasoning with Boolean ABoxes, among them one based on the DPLL(T) approach.
The rest of this paper is organized as follows.In Section 2, we recall the basic notions for DLs and ABox updates.In Sections 3 we present optimizations that enable the construction of more concise updated ABoxes, and in Section 4 we discuss reasoning with Boolean ABoxes.In Section 5, the approaches introduced in the previous two sections are empirically evaluated.This paper is also available as a longer technical report [7].

Preliminaries
In DLs, knowledge is represented with the help of concepts (unary predicates) and roles (binary predicates).Complex concepts and roles are inductively defined starting with a set N C of concept names, a set N R of role names, and a set N I of individual names.The expressiveness of a DL is determined by the set of available constructors to build concepts and roles.The concept and role constructors of the DLs ALCO @ and ALCO + that form the base of our work on ABox update are shown in Table 1, where C, D are concepts, q, r are roles, and a, b are individual names.The DL that allows only for negation, conjunction, disjunction, and universal and existential restrictions is called ALC.By adding nominals O, we obtain ALCO, which is extended to ALCO @ by the @constructor from hybrid logic [8], and to ALCO + by the Boolean constructors on roles and the nominal role [4].We will use ⊤ (⊥) to denote arbitrary tautological (unsatisfiable) concepts and roles.By sub(φ) we denote the set of all subconcepts and subroles of a concept or role φ, respectively.

Name
Syntax Semantics 1. Syntax and semantics of ALCO @ and ALCO + .
The semantics of concepts and roles is given via interpretations I = (∆ I , • I ).The domain ∆ I is a non-empty set and the interpretation function • I maps each concept name A ∈ N C to a subset A I of ∆ I , each role name r ∈ N R to a binary relation r I on ∆ I , and each individual name a ∈ N I to an individual a I ∈ ∆ I .The interpretation function • I is inductively extended to complex concepts and roles as shown in Table 1.
An ABox assertion is of the form C(a), r(a, b), or ¬r(a, b) with r a role, C a concept and a, b individual names.A classical ABox, or an ABox for short, is a finite conjunction of ABox assertions.A Boolean ABox is a Boolean combination of ABox assertions.For convenience we will also sometimes represent classical and Boolean ABoxes as finite sets of assertions by breaking the toplevel conjunctions.An interpretation I is a model of an assertion A model of a (Boolean) ABox is defined in the obvious way.We use M (A) to denote the set of models of a Boolean ABox A.
).An assertion α is entailed by a Boolean ABox A, written as A |= α, if M (A) ⊆ M ({α}).Classical ALCO @ -ABoxes can equivalently be compiled to Boolean ALCO-ABoxes (and vice versa) -the translation in the first direction is exponential, in the other direction it is linear [4].Consistency checking and entailment for classical ABoxes are standard inference problems and supported by all DL reasoners1 , while, to the best of our knowledge, no state of the art reasoner directly supports these inferences for Boolean ABoxes.Reasoning in ALCO + is NExpTime complete [9]; for ALCO @ it is PSpace complete [10].
ABox Update An ABox can be used to represent knowledge about the state of some world.An update contains information on changes that have taken place in that world.
Definition 1 (Update).An update U = {δ( t)} contains a single literal, i.e. δ( t) is of the form A(a), ¬A(a), r(a, b), or ¬r(a, b) with A a concept name, r a role name, and a, b individual names. 2ntuitively, an update literal δ( t) says that this literal holds after the change of the world state.The formal semantics of updates given in [4] defines, for every interpretation I, a successor interpretation I U obtained by changing this model according to the update.Given an ABox A, all its models are considered to be possible current states of the world.The goals is then to find an updated ABox A * U that has exactly the successor of the models of A as its models, i.e., A * U must be such that M (A * U) = {I U | I ∈ M (A)}.In general, such an updated ABox need not exists.
The minimal DLs that contain both the basic DL ALC and are closed under ABox updates are ALCO @ and Boolean ALCO.For ALCO @ , updated ABoxes are exponential in the size of the original ABox and the update.The DL ALCO + admits updated ABoxes that are exponential in the size of the update, but polynomial in the size of the original ABox.This is the reason why, in this work, we focus on ALCO + and ALCO @ .The following two propositions, which are simplified and streamlined versions of the ones given in [4], tell us how updated ABoxes can be computed for these two DLs: Let the ABox A ′ be defined as where the ABox A U is defined as Intuitively, there is one disjunct (A ∪ U) for the case that the update already held before the update, and one disjunct (A U ∪ U) for the case that its negation did.
The DL ALCO @ lacks role operators, and, hence, the construction of the updated quantifier concepts is complicated -it is depicted in Figure 1.Here Obj(U) denotes all the individuals that occur in the update U.For concept names the construction is as in ALCO + .Proposition 2 (Updated ABox for ALCO @ ).For ALCO @ the ABox A U is defined as Let A ′ be as defined in (1).Then A * U ≡ A ′ .
In the following, we want to illustrate the usefulness of ABox updates by a simple example.In this example, it is convenient to use also a TBox.TBoxes are a very useful feature of DLs that allow us to introduce abbreviations for complex concepts.A TBox T is a finite set of concept definitions of the form A ≡ C, where A is a concept name (called a defined concept) and C is a complex concept.This TBox is acyclic if it does not contains multiple or cyclic definitions.Acyclic TBoxes introduce abbreviations for complex concepts, but these abbreviations can be expanded out [5].This makes it possible to work with ABox updates also in the presence of acyclic TBoxes as long as defined concept names do not occur in the update.This restriction avoids semantic problems [3] such as the ramification problem.
Example 1 (Medical Record -Acetylsalicylic Acid).The following concept definitions could be part of a bigger medical ontology for pain treatment.It states under what conditions a treatment with acetylsalicylic acid (ASA) is indicated for a patient, in terms of both anamnesis and diagnosis results, under the additional safety condition that there must not be a contraindication for "similar" patients: Assume that the ABox describing the medical record of the patient Mary, who has come to the hospital because she suffers from migraine, includes the ABox assertions in the first line below.In addition, assume that this ABox contains the information that the patient Jane is similar to Mary: ASA-Diagnosis ⊓ ASA-tolerant(Mary), ∀similar patient.ASA-tolerant(Mary), similar patient(Mary, Jane), similar patient(Jane, Mary).
The DL reasoner can infer from this information that Mary belongs to the concept ASA-indicated, and that Jane belongs to the concept ASA-tolerant.But assume that, at her next visits, Mary tells the doctor that she is now pregnant.
If her medical record is updated with {Pregnant(Mary)}, then we can conclude that an ASA treatment is no longer possible for Mary since the updated ABox implies ¬ASA-indicated(Mary).However, it also implies ¬ASA-indicated(Jane) since there is now a patient similar to Jane (i.e., Mary) that is not ASA tolerant.
To avoid this (obviously unintended) consequence, we must additionally update the ABox with ¬similar patient(Mary, Jane) and ¬similar patient(Jane, Mary) (unless we have learnt that Jane is now also pregnant).

Optimizations for ABox Updates
It turns out that a naive implementation of the update algorithms based on Proposition 1 or 2 is not practical.Even for very simple update problemswhere simple means e.g.small initial ABoxes containing only literals -after only a few updates we obtain ABoxes so huge and redundant that the reasoners cannot handle them anymore.In this section we propose a range of techniques for obtaining less redundant updated ABoxes.
In particular we are looking for ABoxes that are smaller than, but equivalent to, the updated ABoxes.In principle this could be done by enumerating ever bigger ABoxes, and checking for equivalence to the updated ABox.This is not likely to be practical, though.Instead we focus on logical transformations for obtaining smaller updated ABoxes.Since these transformations can be computationally expensive themselves, we also identify fragments of the transformations that we expect to be relatively cheap.The proposed techniques are each motivated by avoidable redundancy that we observed in practical examples.We present the various techniques for obtaining smaller updated ABoxes individually; they can be combined in a modular fashion.
Updating Boolean ABoxes Updating an ABox according to Proposition 1 or 2 results in a Boolean ABox.In [4] this updated ABox is transformed to a non-Boolean ABox using the @-constructor, before it is updated again.The following observation shows that Boolean ABoxes can directly be updated again by updating the individual assertions, avoiding the transformation.
Observation 1 (Distributivity of Update) Update distributes over the connectives conjunction and disjunction in Boolean ABoxes; i.e.
where ⊠ denotes either ∧ or ∨ (negation can be pushed inside the assertions).
By updating a Boolean ABox directly we also obtain a slightly more compact representation than the original one -the update U is no longer contained in two disjuncts: Observation 2 (Updating Boolean ABoxes) For a Boolean ABox A (we assume negation has been pushed inside the assertions), let the updated ABox A ′ be defined as Here A ⊛ U is defined recursively as where ⊠ denotes ∧ or ∨, α is an assertion, and {α} D is defined as in Proposition 1 (or 2) for ALCO + (or for ALCO @ , respectively).Then A * U ≡ A ′ .
Determinate Updates Looking at the construction of updated ABoxes, we see that from an ABox A by an update we get a disjunction A ∨ A U .This causes a rapid growth of the updated ABox.If, however, either the update or its negation is entailed by the ABox A, then one of the disjuncts is inconsistent and can be removed: Observation 3 (Determinate Updates) For Boolean ABox A, update U = {δ}, and updated ABox A ′ we have that Detecting this type of situation requires up to two reasoning steps: A |= δ and A |= ¬δ, resulting in a tradeoff between time and space efficiency.
Exploiting the Unique Name Assumption The common unique name assumption (UNA) means that no two individual names may denote the same object.The constructions from Proposition 1 and 2 do not take the UNA into account; but we can construct simpler updated ABoxes by keeping track of the individuals s and t that an assertion γ(s) refers to when updating it with δ( t): Example 2 (Exploiting UNA).If we update the ABox A = {A(i)} with U = {¬A(j)}, we can easily obtain A(i), instead of A ⊔ {j}(i) using the standard construction.But next consider the ABox A = {∀r.({j}⊓ A)(i)}, updated by U = {A(k)}.As part of the update construction we obtain ∀r.({j}⊓(A⊓¬{k}))(i) which can be simplified using UNA to ∀r.({j} ⊓ A)(i).Our implemented method for exploiting UNA cannot detect this latter case.This UNA-based construction is not costly at all.It cannot identify all cases where the UNA admits a more concise updated ABox, though.
Omitting Subsuming Disjuncts and Entailed Assertions Intuitively, in a disjunction we can omit the "stronger" of two disjuncts: Let the disjunction (A∨ A U ) be part of an updated ABox.
Detecting subsuming disjuncts in general requires reasoning.But by a simple, syntactic check we can detect beforehand some cases where one of the disjuncts A U and A will subsume the other.Then the computation of subsuming disjuncts can be avoided.We say that an occurrence of a concept or role name δ in an assertion is positive, if it is in the scope of an even number of negation signs, and negative otherwise; δ occurs only positively (negatively) in an assertion if every occurrence of δ is positive (negative).
Observation 4 (Detecting Subsuming Disjuncts) If for an ABox A, updated with update U = {(¬)δ( t)}, we have that: (1) if the update is positive (i.e.δ( t)) then • if δ occurs only positively in A then A U A; and • if δ occurs only negatively in A then A A U .(2) if the update is negative (i.e.¬δ( t)) then • if δ occurs only positively in A then A A U ; and Conversely, we can also avoid updating entailed assertions: Let A be an ABox and U an update.If U |= α or A \ {α} |= α for some assertion α ∈ A, then A * U ≡ (A \ {α}) * U. Removing all entailed assertions might be too expensive in practice; one might try doing this periodically.
Propositional ABoxes Sometimes we do not need the full power of DL reasoning, but propositional reasoning is enough: We call a Boolean ABox propositional if it does not contain quantifiers.For propositional ABoxes we could in principle use progression algorithms for propositional logic [12] and efficient SAT-technology, since an updated propositional ABox is propositional, too.
Independent Assertions Next we address the question under which conditions an assertion in an ABox is not affected by an update.We say that assertion α in an ABox A is independent from update U = {δ} iff A * U ≡ α ∧ (B * U) where B = A \ {α}.The more independent assertions we can identify, the more compact our ABox representation becomes.
Detecting this in all cases requires reasoning steps and thus is costly.It is easy, though, to syntactically detect some of the independent assertions: Observation 5 (Independent Assertion) For an ABox A in negation normal form and update U = {(¬)δ( t1 )}, the assertion α( t2 ) ∈ A is independent if δ / ∈ sub(α).It is also independent if A t1 = t2 , δ occurs in α only outside the scope of a quantifier, and for all subconcepts @ i C of α the assertion C(i) is independent of U.

Reasoning with Boolean ABoxes
As we have seen in the previous sections, updated ABoxes are Boolean ALCO @or ALCO + -ABoxes, so that an intelligent agent built on top of ABox update needs Boolean ABox reasoning.Reasoning with ALC-LTL formulas [13] requires Boolean ABox reasoning, too.However, Boolean ABox reasoning is not directly supported by DL reasoners.In this section, we present four different reasoning methods that can handle Boolean ABoxes: -one where a DL reasoner operates on single disjuncts of an ABox in DNF; -one which uses Otter, a first-order theorem prover; -one which uses a consistency preserving reduction from a Boolean ABox to a non-Boolean ABox; and -one which is based on propositional satisfiability testing modulo theoriesthe DPLL(T) approach.
Replacing every assertion in a Boolean ABox A with a propositional letter results in a propositional formula F A .The ABox A is a Boolean ABox in CNF (resp.DNF) if F A is in CNF (resp.DNF).The first approach works on Boolean ABoxes in DNF while the other approaches are based on CNF.We do not use the equivalence-preserving, exponential transformation from [4] for compiling the @ constructor away.Instead we simulate the @-operator by a universal role [14]; this consistency-preserving transformation is linear.
We use Pellet as a DL reasoner because it supports nominals, query-answering and pinpointing [15].
The DNF Approach A Boolean ABox in DNF is consistent iff it contains a consistent disjunct.We can employ a DL reasoner to decide the consistency of each disjunct.We refer to this approach as Pellet-DNF.A drawback of this approach is that we will see that the less redundant updated ABoxes are in CNF, and thus require a costly translation to DNF (using de Morgan's laws).
The Theorem Prover Approach The DL ALCO + admits smaller updated ABoxes than ALCO @ [4]; however, its role operators are not supported by current mature DL reasoners.By translating ALCO + to first order logic [16] we can use theorem provers that can cope with Boolean role constructors.We chose to use Otter [17] because it supports query-answering via answer literals [18]; this is useful e.g. for parametric actions, which are to be instantiated to concrete actions.After a few experiments we chose to configure Otter to use hyperresolution combined with Knuth-Bendix-rewriting, plus the set-of-support strategy.
The Reduction Approach We can linearly compile Boolean ALCO @ -ABoxes to classical ALCO @ -ABoxes [4].Then, simulating the @-operator by a universal role, we can directly use a standard DL reasoner; this approach is henceforth called Pellet-UR.
The DPLL(T) Approach Most modern SAT-solvers [19,20] are variants of the Davis-Putnam-Logemann-Loveland (DPLL) procedure [21,22].Such a SATsolver exhaustively applies transition rules 5 to generate and extend a partial interpretation and thus decides satisfiability of a propositional formula in CNF.One of the strengths of the DPLL procedures is that they can efficiently prune the search space by building and learning backjump clauses [24].
The DPLL(T) approach combines a DPLL procedure with a theory solver that can handle conjunctions of literals in the theory to solve the satisfiability problem modulo theories (SMT) [23].In DPLL(T) a DPLL procedure works on the propositional formula obtained by replacing the theory atoms with propositional letters.Whenever the DPLL procedure extends the current partial interpretation by a new element the theory solver is invoked to check consistency of the conjunction of the theory atoms corresponding to the partial, propositional interpretation.If the theory solver reports an inconsistency, the DPLL procedure will backjump and thus the search space is pruned.
The consistency problem of Boolean ABoxes can be viewed as an instance of SMT where ABox assertions are the theory atoms and a DL reasoner serves as theory solver.
The non-standard DL inference of pinpointing [25,26] is highly relevant to this approach.Explaining why an ABox is inconsistent is an instance of the pinpointing problem, where an explanation is a minimal sub-conjunction of the input ABox, containing only those assertions that are responsible for the inconsistency.Based on these explanations in the DPLL(T) approach we can build better backjump clauses [23].
We implemented an algorithm based on the DPLL(T) approach with the strategy of MiniSat [19].Pellet was chosen as the theory solver because it supports pinpointing.Henceforth we call this approach Pellet-DPLL.
Propositional Reasoning For the case where we can identify propositional ABoxes we have developed and implemented a simple, specialized method.Reasoning there is reduced to efficient list operations.This reasoner is used to supplement the other reasoning approaches (if possible).

Experimental Results
In this section, we evaluate the efficiency of the different update and reasoning mechanisms.The relevant measures are the time needed for computing the updated ABox together with its size, and the efficiency of reasoning with it.
An update algorithm based on Proposition 1 or 2 generates Boolean ABoxes in DNF, while an algorithm based on Proposition 2 outputs ABoxes in CNF.Of course, every Boolean ABox can equivalently be represented in CNF or in DNF; however, this transformation (using De Morgan's laws) is rather expensive.The performance of reasoning with updated ABoxes strongly depends on the choice of underlying representation.We use several types of testing data: -we use a set of randomly generated Boolean ABoxes in CNF; -we use a set of random ABoxes, Updates, and Queries; and -we use the Wumpus world [27].
We distinguish two main types of update algorithms that we implemented: -In one we compute updated ABoxes in DNF; we call this the DNF approach.
-Or we compute updated ABoxes in CNF; we call this the CNF approach.
Both approaches are further parametrized by using different reasoners, and a different combination of optimization techniques.We have implemented the different ABox update algorithms in ECLiPSe-Prolog.
The reasoning methods have already been described in Section 4. We call a reasoning method hybrid if it resorts to our propositional reasoner whenever possible; for example, we then speak of hybrid Pellet-UR.

Representation: DNF or CNF?
We have used both the Wumpus world and the random update examples to compare DNF and CNF based update algorithms (with and without optimizations).CNF representation consistently proved to be superior: The DNF approach quickly drowns in redundant information.This is because to compute an updated ABox in DNF is to include both the update and all the non-affected information in both disjuncts.Detecting subsuming disjuncts and determinate updates alleviates this problem, but does not eliminate it.By avoiding this redundancy we immediately obtain an updated ABox in CNF.On DNF-based updated ABoxes Pellet-DNF performs best -the other methods suffer from the expensive conversion to CNF.In the following we only consider the CNFbased representation of updated ABoxes.

Consistency Checking for Boolean ABoxes in CNF
We implemented a random generator of Boolean ALC-ABoxes, which randomly generates a propositional formula in CNF and then assigns a randomly generated assertion to each propositional letter.Several parameters are used to control the shape of the generated Boolean ABoxes (the numbers in parentheses indicate the upper bound on the parameters we used): the number n 1 of literals in a clause (53), the number n 2 of propositional letters (36), the number n 3 of clauses (83), the number d of nested roles in a concept assertion (23), the number ncs of the constructors in a concept assertion (106), the numbers nc, nr, and ni of concept names, role names, and individual names in an assertion (12 each), and the probability pr of generating a role assertion (0.2).
In Figure 2, we plot the runtimes of Pellet-DPLL and Pellet-UR on these testing data against the number of symbols in the Boolean ABox.The points plotted as + indicate the runtime of Pellet-DPLL while those plotted as × indicate the runtime of Pellet-UR.We depict the performance on consistent and inconsistent Boolean ABoxes separately -the testing data contained more consistent than inconsistent Boolean ABoxes.
We can see that the runtime of Pellet-UR linearly increases with the size of the input (the bar from the lower left to the upper right corner).On inconsistent ABoxes Pellet-DPLL also exhibits a linear increase in runtime, while on consistent ABoxes the runtime is less predictable.Pellet-DPLL performs better on all of the inconsistent Boolean ABoxes.On most of the consistent ABoxes, the Pellet-UR approach does better.This is due to the fact that in Pellet-DPLL the frequent invocations of the theory solver Pellet are more likely to pay off if inconsistency of the current, partial model can be detected often: We then can build a back-jump clause that helps to prune the search space.The runtimes of Pellet-UR are about the same on both consistent and inconsistent input data.
For Otter the conversion from ABoxes in CNF to full first order CNF proved to be a big obstacle, as did the conversion to DNF for Pellet-DNF.

Random Updates
We have extensively experimented with a set of randomly generated ABoxes and updates.Initial ABoxes were between two and thirty assertions in size.We were mostly interested in runtime and space consumption for iterated updates.We could make a number of interesting observations: -The cheap UNA-based concept update construction always paid.
-The reasoning needed to identify determinate updates pays in the long run.
-Syntactically detecting subsuming disjuncts worked, too.Doing so using a reasoner proved to be too expensive.-Identifying all entailed assertions to shrink the ABoxes proved to be too expensive, too.-Resorting to our dedicated propositional reasoner whenever possible resulted in significantly better performance.-We can keep updated ABoxes much smaller at a low cost by syntactically identifying independent assertions.
Updating an ABox according to [4] is a purely syntactic procedure.But if we iteratively update ABoxes, then in the long run we get both a lower space and time consumption by calling a reasoner to identify determinate updates.Using our propositional reasoner whenever possible for this resulted in better performance.If identifying determinate updates required DL reasoning then Pellet-UR performed slightly better than Pellet-DPLL.This is due to the fact that less updates were determinate than not, and thus inconsistency was not detected often.On a subset of the random examples where there were more determinate updates Pellet-DPLL performed better than Pellet-UR.The runtimes for Otter widely varied: converting CNF-ABoxes to full first order CNF proved the bottleneck.Pellet-DNF was not competitive because of the expensive conversion to DNF.
We could also identify characteristics of initial ABoxes that allow to predict performance: If the initial ABox does not contain nested quantifiers then performance is acceptable; e.g.we can iteratively apply 300 singleton updates to a fifteen assertion ABox in 90 seconds, without a significant increase in size.If the initial ABox contains nested quantifiers space consumption quickly grows out of bounds.This is because we then cannot cheaply identify independent assertions and use the UNA-based concept update construction.For nested quantifiers using ALCO + instead of ALCO @ helps to reduce space consumption; but this still does not result in satisfactory overall performance.

The Wumpus World
The Wumpus World [27] is a well-known challenge problem in the reasoning about action community.It consists of a grid-like world: cells may contain pits, one cell contains gold, and one the fearsome Wumpus.The agent dies if she enters a cell containing a pit or the Wumpus.But she carries one arrow so that she can shoot the Wumpus from an adjacent cell.If the agent is next to a cell containing a pit (Wumpus), she can detect that one of the surrounding cells contains a pit (the Wumpus), but doesn't know which one.She knows the contents of the already visited cells.Getting the gold without getting killed is the agent's goal.
At each step, the agent performs sensing to learn whether one of the adjacent cells contains a pit or the Wumpus.Since the sensing results are disjunctive, we cannot treat them via ABox updates.But the properties sensed are static (i.e., cannot change once we know them): We can simply adjoin the sensing results to the ABox serving as the agent's current world model.The effects of the agent's (non-sensing) actions (like moving to another cell) are modelled as ABox update.
The Wumpus World can be modelled in different ways.In the simplest model, the initial ABox contains the connections between the cells, the agent's location, and the facts that the agent carries an arrow, and that the Wumpus is alive (Model PL1).For this, Boolean combinations of concept/role literals are enough.In Model PL2, we include the fact that the Wumpus is at exactly one location by enumerating all possible cases in a big disjunction.We turn PL1 into a DL problem by including the information ∃at.⊤(wumpus) (Model DL1).Model DL2 is obtained from PL2 by adding this same assertion, which here is redundant.Table 2 shows the runtimes, where n/a stands for unavailable expressivity and * for non-termination in 15 minutes.For the propositional models we also used the action programming language Flux [2].
Pellet-DNF, and to a lesser extent also Otter, again had difficulties with the necessary input conversion.Pellet-UR proved to be the best DL reasoner in this setting.This is due to the fact that this domain requires query-answering: The agent e.g.needs to know for which values of x and y we have that at(agent, x) ∧ connected(x, y).Pellet-DPLL is the only reasoner that lacks direct support for query-answering.Thus, for query C(x), we check for every individual name i ∈ N I whether C(i) holds -this results in bad performance for Pellet-DPLL.
The propositional reasoner performs quite well on the propositional models.Including more information wrt. the Wumpus' location results in worse performance.We used Model DL2 to see if it pays to identify all entailed assertions: after omitting the entailed ∃at.⊤(wumpus) the model is propositional again.In practice this proved too costly.The other observations from Section 5.3 also hold in this domain.Removing assertions entailed by the update sometimes did help, though: Once the Wumpus is found, the assertion ∃at.⊤(wumpus) is entailed by the respective update and we can then resort to efficient propositional reasoning.

Summary and Future Work
In this work, we have investigated implementation techniques for ABox update, and for reasoning with (updated) Boolean ABoxes.We have introduced and evaluated several optimizations of the ABox update algorithms in [4].The lessons learnt were: Using CNF-representation of updated ABoxes is strongly recommended.The (incomplete) syntactic techniques for exploiting the unique name assumption, and detecting subsuming disjuncts and independent assertions have also resulted in an improved performance.The benefit of identifying determinate updates made up for the associated reasoning costs.Other techniques requiring DL reasoning in general proved to be too expensive; but removing some entailed assertions helped in the Wumpus world.
Regarding the investigated reasoning methods for Boolean ABoxes, we have come to the following conclusions.Pellet-DNF is the best reasoner for Boolean ABoxes in DNF.For consistency checking of ABoxes in CNF, Pellet-DPLL and Pellet-UR worked best.Pellet-DPLL did better for detecting an actual inconsistency, while it performed worse than Pellet-UR on most of the consistent Boolean ABoxes.On the randomly generated update examples, Pellet-UR also performed slightly better than Pellet-DPLL because inconsistency was not detected often.On a subset where the updates were mostly determinate, Pellet-DPLL outperformed Pellet-UR.If query-answering is among the reasoning tasks, then Pellet-UR is to be preferred over Pellet-DPLL because of Pellet's direct support for this inference.
It would be interesting to develop heuristics for finding suitable individual names as well as other optimizations for query-answering in the DPLL(T) approach.The performance of the DPLL(T) approach also depends on the performance of the SAT solver and the pinpointing service.Thus Pellet-DPLL can benefit from more efficient implementation of these tasks as well.
The tests on the Wumpus world confirmed that resorting to our dedicated propositional reasoner whenever possible is useful.In the Wumpus world, removing entailed assertions helped a lot.In contrast, for the randomly generated update examples, finding entailed assertions did not pay off.
Using Otter as a theorem prover might be considered somewhat unfair (to the theorem proving approach), since it is no longer actively maintained and optimized.The conversion to full first order CNF proved to be the biggest obstacle for Otter.We chose to use Otter because it supports query-answering, which is not supported by most current provers [28], but vital in some domains.If this is to change, 6 we can try to resort to state-of-the art theorem provers for reasoning in ALCO + .This may allow us to really exploit the fact that ALCO + admits smaller updated ABoxes than ALCO @ .Alternatively, one could also try to use a more dedicated reasoning system for ALCO + [29].

Table 2 .
Runtimes for the Wumpus World.