Reasoning about actions with EL ontologies with temporal answer sets

07/18/2021 ∙ by Laura Giordano, et al. ∙ Università del Piemonte Orientale Università di Torino Università degli Studi del Piemonte Orientale 0

We propose an approach based on Answer Set Programming for reasoning about actions with domain descriptions including ontological knowledge, expressed in the lightweight description logic EL^. We consider a temporal action theory, which allows for non-deterministic actions and causal rules to deal with ramifications, and whose extensions are defined by temporal answer sets. We provide conditions under which action consistency can be guaranteed with respect to an ontology, by a polynomial encoding of an action theory extended with an EL^knowledge base (in normal form) into a temporal action theory.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The integration of description logics and action formalisms has gained a lot of interest in the past years [5, 4, 12, 1]. In this paper we explore the combination of a temporal action logic [23] and an knowledge bases, with the aim of allowing reasoning about action execution in the presence of the constraints given by an ontology.

As usual in many formalisms integrating description logics and action languages [5, 6, 12, 1], we regard inclusions in the as state constraints of the action theory, which we expect to be satisfied in the state resulting after action execution. In the literature of reasoning about actions it is well known that causal laws and their interplay with domain constraints are crucial for solving the ramification problem [34, 32, 35, 13, 18, 26]. In case knowledge about the domain is expressed in a description logic, the issue has been considered, e.g., in [4] where causal laws are used to ensure the consistency with the TBox of the resulting state, after action execution. For instance, given a TBox containing , and an ABox (i.e., a set of assertions on individuals) containing the assertion , an action which adds the assertion , without also adding , will not give rise to a consistent next state with respect to the knowledge base. The addition of the causal law caused if would enforce, for instance, the above TBox inclusion to be satisfied in the resulting state.

The approach proposed by Baader et al. [4] uses causal relationships to deal with the ramification problem in an action formalism based on description logics, and it exploits a semantics of actions and causal laws in the style of Winslett’s [36] and McCain and Turner’s [34] fixpoint semantics. In this paper, we aim at extending this approach to reason about actions with an ontology with temporal answer sets. Reasoning about actions with temporal answer sets has been proposed in [21, 23]

by defining a temporal logic programming language for reasoning about

complex actions and infinite computations. This action language, besides the usual LTL operators, allows for general Dynamic Linear Time Temporal Logic (DLTL) formulas to be included in domain descriptions to constrain the space of possible extensions. In [23] a notion of Temporal Answer Set for domain descriptions is introduced, as a generalization of the usual notion of Answer Set, and a translation of domain descriptions into standard Answer Set Programming (ASP) is provided, by exploiting bounded model checking techniques for the verification of DLTL constraints, extending the approach developed by Helianko and Niemela [28] for bounded LTL model checking with Stable Models. An alternative ASP translation of this temporal action language has been investigated in [22, 24], by proposing an approach to bounded model checking which exploits the Büchi automaton construction while searching for a counterexample, with the aim of achieving completeness. Our temporal action logic has been shown to be strongly related to extensions of the language [17, 9, 14, 7, 26]. The temporal formalism is also related to the recent temporal extension of Clingo, telingo dealing with finite computations [10].

The paper studies extended temporal action theories, combining the temporal action logic mentioned above with an knowledge base. It is shown that, for knowledge bases in normal form, the consistency of the action theory extensions with the ontology can be verified by adding to the action theory a set of causal laws and state constraints, by exploiting a fragment of the materialization calculus by Krötzsch [30]. Furthermore, sufficient conditions on the action theory can be defined to repair the states resulting from action execution and guarantee consistency with TBox. To this purpose, for each inclusion axiom in TBox, a suitable set of causal laws can be added to the action theory. Our approach provides a polynomial encoding of an extended action theory, with an knowledge base in normal form, into the language of the (DLTL) temporal action logic studied in [23]. The proof methods for this temporal action logic, based on bounded model checking, can then be exploited for reasoning about actions in the extended action theory.

A preliminary version of this work, which does not exploit a temporal action language, has been presented in CILC 2016 [20].

2 The description logic

We consider a fragment of the logic [2] that, for simplicity of presentation, does not include role inclusions and concrete domains. The fragment, let us call it , includes the concept as well as nominals.

We let be a set of concept names, a set of role names and a set of individual names. A concept in is defined as follows:

where and . Observe that complement, disjunction and universal restriction are not allowed in .

A knowledge base is a pair , where is a TBox containing a finite set of concept inclusions and is an ABox containing assertions of the form and , with concepts, and .

We will assume that the TBox is in normal form [3]. Let be the smallest set of concepts containing , all the concept names occurring in and all nominals , for any individual name occurring in . An inclusion is in normal form if it has one of the following forms: ,   ,   ,   , where , and . In [3] it is shown that any TBox can be normalized in linear time, by introducing new concept and role names.

In the following we will denote with , and the (finite) sets of concept names, role names and individual names occurring in .

Definition 1 (Interpretations and models)

An interpretation in is any structure where: is a domain; is an interpretation function that maps each concept name to set , each role name to a binary relation , and each individual name to an element . Furthermore: , ; ; = ; = . An interpretation satisfies an inclusion if ; it satisfies an assertion if ; it satisfies an assertion if .

Given a knowledge base , an interpretation is a model of if satisfies all inclusions in ; is a model of if satisfies all inclusions in and all assertions in . is consistent with if there is a model of satisfying all the assertions in .

3 Temporal Action Theories

In this paper we refer to the notion of the temporal action theory in [19], a rule based fragment of which has been studied in [23, 24], which exploits the dynamic extension of LTL introduced by Henriksen and Thiagarajan, called Dynamic Linear Time Temporal Logic (DLTL) [29]. In DLTL the next state modality is indexed by actions and the until operator is indexed by a program which, as in PDL, can be any regular expression built from atomic actions using sequence (), nondeterministic choice () and finite iteration (). The derived modalities and can be defined as: and . Similarly, (next), and operators of LTL can be defined. We let be a finite non-empty set of (atomic) actions and we refer to [19, 23] for the details concerning complex actions.

A domain description is a set of laws describing the effects of actions and their executability preconditions. Atomic propositions describing the state of the domain are called fluents. Actions may have direct effects, described by action laws, and indirect effects, described by causal laws capturing the causal dependencies among fluents.

Let be a first order language which includes a finite number of constants and variables, but no function symbol. Let be the set of predicate symbols, the set of variables and the set of constant symbols. We call fluents atomic literals of the form , where, for each , . A simple fluent literal (or s-literal) is an atomic literals or its negation . We denote by the set of all simple fluent literals. is the set of temporal fluent literals: if , then , where is an action name (an atomic proposition, possibly containing variables), and and are the temporal operators introduced in the previous section. Let , where represents the inconsistency and truth. Given a (simple or temporal) fluent literal , represents the default negation of . A (simple or temporal) fluent literal possibly preceded by a default negation, will be called an extended fluent literal.

The laws are formulated as rules of a temporally extended logic programming language. Rules have the form

(1)

where the ’s are either simple fluent literals or temporal fluent literals, with the following constraints: (i) If is a simple literal, then the body cannot contain temporal literals; (ii) If , then the temporal literals in the body must have the form ; (iii) If , then the temporal literals in the body must have the form . As usual in ASP, the rules with variables will be used as a shorthand for the set of their ground instances.

In the following we use of a notion of state: a set of ground fluent literals. A state is said to be consistent if it is not the case that both and belong to the state, or that belongs to the state. A state is said to be complete if, for each fluent , either or belong to the state. The execution of an action in a state may possibly change the values of fluents in the state through its direct and indirect effects, thus giving rise to a new state.

While a law as (1) can be applied in all states, a law

(2)

which is not prefixed by , only applies to the initial state.

A domain description can be defined as a pair , consisting of a set of laws and a set of temporal constraints . the following action laws describe the deterministic effect of the actions shoot and load for the Russian Turkey problem, as well as the nondeterministic effect of action spin, after which the gun may be loaded or not:
                          
       The following precondition laws: specifies that, if the gun is loaded, is not executable. The program describes the behavior of the hunter who waits for a turkey until it appears and, when it is in sight, loads the gun and shoots. Actions and are test actions (we refer to [23]). If the constraint is included in then all the runs of the domain description which do not start with an execution of the given program will be filtered out. For instance, an extension in which in the initial state the turkey is not in sight and the hunter loads the gun and shoots is not allowed.

As we will see later, this temporal language is also well suited to describe causal dependencies among fluents as static and dynamic causal laws similar to the ones in the action languages [14] and [26].

The semantics of a domain description has been defined based on temporal answer sets[23], which extend the notion of answer set [15] to capture the linear structure of temporal models. Let us shortly recall the main notions. In the following, we consider the ground instantiations of the domain description , and we denote by the set of all the ground instances of the action names in .

3.1 Temporal answer sets

A temporal interpretation is defined as a pair , where is a sequence of actions and is a consistent set of ground literals of the form , where is a prefix of and is a ground simple fluent literal, meaning that holds in the state obtained by executing . is consistent iff it is not the case that both and , for some , or . A temporal interpretation is said to be total if either or , for each prefix of and for each fluent name .

We define the satisfiability of a simple, temporal or extended literal in a partial temporal interpretation in the state , (written ) as:

,      

 iff  , for s-literal

 iff  or

is not a prefix of

 iff ,

where is a prefix of

 iff  

The satisfiability of rule bodies in a temporal interpretation is defined as usual. A rule is satisfied in a temporal interpretation if, for all action sequences (including the empty action sequence ), implies . A rule is satisfied in a partial temporal interpretation if, implies .

Let be a set of rules over an action alphabet , not containing default negation, and let .

Definition 2

A temporal interpretation is a temporal answer set of if is minimal (with respect to set inclusion) among the such that is a partial interpretation satisfying the rules in .

To define answer sets of a program containing negation, given a temporal interpretation over , the reduct, , of relative to is defined, by extending Gelfond and Lifschitz’ transform [16], roughly speaking, to compute a different reduct of for each prefix of .

Definition 3

The reduct, , of relative to and to the prefix of , is the set of all the rules such that , is in and , for all .

The reduct of relative to is the union of all reducts for all prefixes of .

In definition above, we say that rule is satisfied in a temporal interpretation if implies .

Definition 4 ([23])

A temporal interpretation is an answer set of if is an answer set of the reduct .

Observe that a partial interpretation provides, for each prefix , a partial evaluation of fluents in the state corresponding to that prefix. The (partial) state obtained by the execution of the actions in the sequence can be defined as: .

Although the answer sets of a domain description are partial interpretations, in some cases, e.g., when the initial state is complete and all fluents are inertial, it is possible to guarantee that the temporal answer sets of are total. The case of total temporal answer sets is of special interest as a total temporal answer set can be regarded as a temporal model.

4 Combining Temporal Action Theories with KBs

In this section we define a notion of extended temporal action theory, consisting of a temporal action theory plus an knowledge base. Our approach, following most of the proposals for reasoning about actions in DLs [5, 6, 12, 4, 1] is to regard the TBox as a set of state constraints, i.e. conditions that must be satisfied by any state of the world (in all possible extensions of the action theory), and the ABox as a set of constraints on all possible initial states.

We want to regard DL assertions as fluents that may occur in our action laws as well as in the states of the action theory. Given a (normalized) knowledge base , we require that: (a) for each (possibly complex) concept occurring in there is a unary predicate ; (b) for each role name there is a binary predicate ; (c) the set of constants includes all the individual names occurring in the , i.e. .

Observe that if a complex concept such as occurs in , there exists a predicate name and, for each , the fluent literals and belong to the set (we will still call such literals assertions). Although classical negation is not allowed in , we use explicit negation [15] to allow negative literals of the form in the action language (to allow for deleting an assertion from a state).

A simple literal in is said to be a simple assertion if it has the form or or or , where is a base concept in , and . Observe that and are simple assertions, while and are non-simple assertions.

In order to deal with existential restrictions, in addition to the individual names occurring in the we introduce a finite set of auxiliary individual names, as proposed in [30] to encode inference in Datalog, where contains a new individual name , for each inclusion occurring in the . We further require that .

Definition 5 (Extended action theory)

An extended action theory is a tuple , where: is an knowledge base; is a set of laws: action, causal, executability and initial state laws (see below); is a set of temporal constraints.

Action laws describe the immediate effects of actions. They have the form:

(3)

where is a simple fluent literal and the ’s are either simple fluent literals or temporal fluent literals of the form . Its meaning is that executing action in a state in which the conditions hold and conditions do not hold causes the effect to hold. As an example, means that executing the action of assigning a course to has the effect that teaches . Non-deterministic effects of actions can be defined using default negation in the body of action laws, as for the action spin in Section 3.

Causal laws describe indirect effects of actions. They have the form: In we allow two kinds of causal laws. Static causal laws have the form:

(4)

where the ’s are simple fluent literals. Their meaning is: if hold in a state and do not hold in that state, than is caused to hold in that state. Dynamic causal laws have the form:

(5)

where is a simple fluent literal and the ’s are either simple fluent literals or temporal fluent literals of the form . For instance, . Observe that, differently from [5, 4], we do not restrict direct and indirect effects of actions to be simple assertions. State constraints that apply to the initial state or to all states can be obtained when occurs in the head of initial state laws (6) or static causal laws (4).

Precondition laws describe the executability conditions of actions. They have the form: where and the ’s are simple fluent literals. The meaning is that the execution of an action is not possible in a state in which hold and do not hold

Initial state laws are needed to introduce conditions that have to hold in the initial state. They have the form:

(6)

where the ’s are simple fluent literals. Observe that initial state laws, unlike static causal laws, only apply to the initial state as they are not prefixed by the modality. As a special case, the initial state can be defined as a set of simple fluent literals. For instance, the initial state is defined by the initial state laws: .

Following Lifschitz [31] we call frame fluents the fluents to which the law of inertia applies. Persistency of frame fluents from a state to the next one can be captured by introducing in a set of causal laws, said persistency laws for all frame fluents .

             

meaning that, if holds in a state, then will hold in the next state, unless its negation is caused to hold (and similarly for ). Persistency of a fluent is blocked by the execution of an action which causes the value of the fluent to change, or by a nondeterministic action which may cause it to change. The persistency laws above play the role of inertia rules in [27], [26] and [14].

If is non-frame with respect to an action , is not expected to persist and may change its value when an action is executed, either non-deterministically:

             

or by taking some default value (see [23] for some examples).

In the following we assume that persistency laws and non-frame laws can be applied to simple assertions but not to non-simple ones (such as ), whose value in a state (as we will see) is determined from the value of simple assertions. For simple assertions in a domain description, one has to choose whether the concept is frame or non-frame (so that either persistency laws or non-frame laws can be introduced). In particular, we assume that all the nominals always correspond to frame fluents: if (respectively ) belongs to a state, it will persist to the next state unless it is cancelled by the direct or indirect effects of an action.

ABox assertions may incompletely specify the initial state. As we want to reason about states corresponding to interpretations, we assume that the laws: and for completing the initial state are introduced in for all simple literals (including assertions with nominals). As shown in [23], the assumption of complete initial states, together with suitable conditions on the laws in , gives rise to semantic interpretations (extensions) of the domain description in which all states are complete. In particular, to guarantee that each reachable state in each extension of a domain description is complete for simple fluents, we assume that, either the fluent is frame, and persistency laws are introduced for it, or it is non-frame, and non-frame laws are introduced. Other literals, such as existential assertions, are not subject to this requirement but, as we will see below, the value of existential assertions in a state will be determined from the value of simple assertions. Under the condition above, starting from an initial state which is complete for simple fluents, all the reachable states are also complete for simple fluents. We call well-defined the domain descriptions satisfying this condition (and sometimes we will simply say that is well-defined).

The third component of a domain description is the set of temporal constraints in DLTL, which allow general temporal conditions to be imposed on the executions of the domain description. Their effect is that of restricting the space of the possible executions (or extensions). For a domain description , as introduced in [23], extensions are defined as follows.

Definition 6

An extension of a well-defined domain domain description over is a (total) answer set of which satisfies the constraints in .

In the next section we extend the notion of extension to a domain description with an ontology.

5 Ontology axioms as state constraints

Given an action theory , where , we define an extension of as an extension of the action theory satisfying all axioms of the ontology . Informally, each state in the extension is required to correspond to an interpretation and to satisfy all inclusion axioms in TBox . Additionally, the initial state must satisfy all assertions in the ABox .

To define the extensions of an action theory , we restrict to well-defined domain descriptions , so that all states in an extension are complete for simple fluents (and for simple assertions). We prove that such states represent interpretations on the language of , provided an additional set of laws is included in the action theory. Next, we add to another set of constraints, to guarantee that each state satisfies the inclusion axioms in . Finally, we add to the set of laws , to guarantee that all assertions in are satisfied in the initial state.

Overall, this provides a transformation of the action theory into a new action theory , by eliminating the ontology while introducing the set of static causal laws and consrtraints , intended to exclude those extensions which do not satisfy the axioms in .

The set of domain constraints and causal laws in is intended to guarantee that any state of an extension respects the semantics of DL concepts occurring in . The definition of is based on a fragment of the materialization calculus for , which provides a Datalog encoding of an ontology. Here, the idea is that of regarding an assertion in a state as the evidence that in the corresponding interpretation. Let be the following set of causal laws:

(1)                (2)                (3)

(4)
(5)
(6)







(7) ,   for
(8) ,   for
(9) ,   for



for all , , (the base concepts occurring in ) and (the roles occurring in ). Observe that the first constraint has the effect that a state , in which the concept has an instance, is made inconsistent. Law (4) makes hold in any state in which there is a domain element such that and hold (where is an additional auxiliary predicate for and ). Laws (5) and (6) guarantee that, for all , either or is contained in the state. State constraints (7-9) are needed for the treatment of nominals and are related to materialization calculus rules (27-29) [30].

Let be an extension of the action theory . It can be proven that any state of represents an interpretation. Given a state , let be the set of assertions (), such that (resp., ). Let be the set of assertions (), such that (resp., ).

Proposition 1

Let be an extension of the action theory and let be a state of . Then there is an interpretation that satisfies all the assertions in and falsifies all assertions in (and we say that agrees with state ).

As mentioned, we are interested in the states satisfying the TBox of . Provided is well-defined, for each extension of the action theory , any state is consistent and complete for all simple literals (and hence, by (5) and (6), for all assertions). We say that satisfies the TBox if for all interpretations such that agrees with state , is a model of .

The requirement that each should satisfy the TBox can be incorporated in the action theory through a set of constraints, that we call , by exploiting the fact that the TBox is in normal form. contains the following state constraints:


,  for each in ;

,  for each in ;

,  for each in ;

,  for each in ;

where , and . For , the condition is omitted. The following proposition can be proved for a well-defined .

Proposition 2

Let be an extension of the action theory and let be a state of . satisfies iff satisfies all constraints in .

We can then add the constraints in to an action theory to single out the extensions whose states all satisfy the TBox . In a similar way, we can restrict to answer sets whose initial state satisfies all assertions in , by defining a set of initial state constraints as:

We define the extensions of the extended action theory as the extensions of the action theory , where .

Given this notion of extension of an action theory , we can verify, in the temporal action logic, if a sequence of actions is executable from the initial state (executability problem) or whether any execution of an action sequence makes some property (e.g., some assertion) hold in all reachable states (temporal projection problem).

Let us consider the example from the introduction.

Example 1

Let be a knowledge base such that = and = { . We assume that all simple assertions, i.e., , , , are frame for all . Let us consider a state where John does not teach any course and is not a teacher. If an action were executed in , given a containing the action law , the resulting state would contain Teaches(john,cs1) and Teaches. Course)(john), but would not contain not Teacher(john), thus violating the state constraint

,

in . In this case, there is no extension of the action theory in which action can be executed in the initial state.

As observed in [4], when this happens, the action specification can be regarded as being underspecified, as it is not able to capture the dependencies among fluents which occur in the TBox. To guarantee that TBox is satisfied in the new state, causal laws are needed which allow the state to be repaired. In the specific case, adding causal law to would suffice to cause in the resulting state, as an indirect effect of action .

6 Causal laws for repairing inconsistencies: sufficient conditions

Can we identify which and how many conditions are needed to guarantee that an action theory is able to repair the state, after executing an action, so to satisfy all inclusions of a (normalized) TBox, when possible? Let us continue Example 1.

Example 2

Consider the case when action retire(john) is executed in a state where Person(john), Course(cs1), Teaches(john,cs1) and Teacher(john) hold. Suppose that the action law: is in . Then, will belong to the new state (let us call it ), but will still contain the literals: Course(cs1), Teaches(john,cs1), which persist from the previous state (as Course and Teaches are frame fluents). Hence, would violate the TBox . To avoid this, should contain some causal law to repair the inconsistency, for instance, . By this causal law, when John retires he stops teaching all the courses he was teaching before. In particular, he stops teaching . On the contrary, would be unintended.

As we can see, the causal laws needed to restore consistency when an action is executed can in essence be obtained from the inclusions in the TBox and from their contrapositives, even though not all contrapositives are always wanted.

In general, while defining a domain description, one has to choose which causal relationships are intended and which are not. The choice depends on the domain and should not be done automatically, but some sufficient conditions to restore the consistency of the resulting state (if any) with a TBox (in normal form) can be defined.

The case of a (normalized) inclusion , with , is relatively simple; the execution of an action with effect (but not ), in a state in which none of and holds, would lead to a state which violates the constraints in the . Similarly for an action with effect . Deleting should cause to be deleted as well, if we want the inclusion to be satisfied. Hence, to guarantee that the TBox is satisfied in the new state, for each inclusion , two causal laws are needed: and .

For an axiom , consider the concrete case , representing mutually exclusive states of a claim in a process of dealing with an insurance claim, we expect the following causal laws to be included:

         

even though the second one is only useful if a claim can become pending again after having become (temporarily) approved. For the general case, we have the following.

Let us define a set of causal laws associated with as follows:

  • For in :    and   ;

  • For :    and at least one among
     and   ;

  • For :  ,    and
    ;

  • For in :  ,   and at least one of: and .

Proposition 3

Given a well-defined action theory and a TBox , any state of an extension of satisfies .

Observe that, for the case for , from and is caused by laws (4-5) in . While the causal laws in are sufficient to guarantee the consistency of a resulting state with TBox , one cannot exclude that some action effects are inconsistent with TBox and cannot be repaired (e.g., an action with direct effects and , conflicting with an axiom in ). In such a case, the action would not be executable.

Notice that the encoding above of TBox into a set of temporal laws only requires a polynomial number of laws to be added to the action theory (in the size of ). Based on this mapping, the proof methods for our temporal action logic, which are based on the ASP encodings of bounded model checking [22, 23, 24], can be exploited for reasoning about actions in an action theory extended with an knowledge base.

7 Conclusions and Related Work

In this paper we have proposed an approach for reasoning about actions by combining a temporal action logic in [23], whose semantics is based on a notion of temporal answer sets, and an ontology. It is shown that, for knowledge bases in normal form, the consistency of the action theory extensions with the ontology can be verified by adding to the action theory a set of causal laws and state constraints, by exploiting a fragment of the materialization calculus by Krötzsch [30]. Starting from the idea by Baader et al. [4] that causal rules can be used to ensure the consistency of states with the TBox, we have defined sufficient conditions on the action theory to repair the states resulting from action execution and guarantee consistency with TBox. For each inclusion axiom, a suitable set of causal laws has to be added. Our approach provides a polynomial encoding of an extended action theory, including an knowledge base in normal form, into the language of the (DLTL based) temporal action logic studied in [23]. The proof methods for this temporal action logic, based on ASP encodings of bounded model checking [22, 23, 24], can then be exploited for reasoning about actions in an extended action theory. It would also be interesting, for action domains with finite executions, to investigate whether the action theories in [23] can be encoded in in telingo [10], and whether the optimized implementation of telingo can be exploited for reasoning about action in our extended action theories.

Many of the proposals in the literature for combining DLs with action theories focus on expressive DLs. In their seminal work [5], Baader et al. study the integration of action formalisms with expressive DLs, from to , under Winslett’s possible models approach (PMA) [36], based on the assumption that TBox is acyclic and on the distinction between defined and primitive concepts (i.e., concept names that are not defined in the TBox), where only primitive concepts are allowed in action effects. They determine the complexity of the executability and projection problems and show that they get decidable fragments of the situation calculus. Our semantics departs from PMA as causal laws are considered. As [33] and [4] we do not require the restriction to acyclic TBoxes and primitive concepts in postconditions.

The requirement of acyclic TBoxes is lifted in the work by Liu et al. [33], where an approach to the ramification problem is proposed which does not use causal relationships, but exploits occlusion to provide a specification of the predicates that can change through the execution of actions. The idea is to leave to the designer of an action domain the control of the ramification of the actions.

Similar considerations are at the basis of the approach by Baader et al. [4] that, instead, exploits causal relationships for modeling ramifications in an action language for , and defines its semantics in the style of McCain and Turner fixpoint semantics [34] (the action theory does not deal with non-deterministic effects of actions). It is shown that temporal projection is decidable and ExpTime-complete. In this paper, following [4], we exploit causal laws for modeling ramifications in the context of a temporal action language for . It allows for non-deterministic effects of actions and for the distinction between frame and non-frame fluents [31] (which is strongly related to occlusion used in [33]) based on the temporal logic. We have also provided sufficient conditions for an action specification to be consistent with a normalized .

Ahmetai et al. [1] study the evolution of Graph Structured Data as a result of updates expressed in an action language. They provide decidability and complexity results for expressive DLs such as (under finite satisfiability) as well as for variants of DL-lite. Complex actions including action sequence and conditional actions are considered. Complex actions are considered as well in [12], where an action formalism is introduced for a family DLs, from to , exploiting PDL program constructors to define complex actions. As in [5], the TBox is assumed to be acyclic.

In [8] Description Logic and Action Bases are introduced, where an initial Abox evolves over time due to actions which have conditional effects. In [11] the approach is extended to allow for different notions of repairing of the resulting state, such as a maximal subset consistent with the Tbox, or the intersection of all such subsets. In this paper, we rely on causal laws for repairing states; selecting the appropriate causal laws means acquiring more knowledge, and allows for a finer control on the resulting state.

Our semantics for actions, as many of the proposals in the literature, requires that a state provides a complete description of the world and is intended to represent an interpretation of the knowledge base. An alternative approach has been adopted in [8], where a state can provide an incomplete specification of the world. In our approach, an incomplete state could be represented as an epistemic state, which distinguish between what is known to be true (or to be false) and what is unknown. An epistemic extension of our action logic, based on temporal answer sets, has been developed in [24], and it can potentially be exploited for reasoning about actions with incomplete states also in presence of ontological knowledge. We leave the study of this case for future work.

A mixed temporal and conditional approach to deal with causality in action theories, provides a natural formalization of concurrent actions and of the dependency (and independency) relations between actions, has been studied in [25]. Whether this approach can be extended to domain descriptions also including knowledge from a DL ontology is also an interesting issue, which we leave for future work.

References

  • [1]

    Ahmetaj, S., Calvanese, D., Ortiz, M., Simkus, M.: Managing change in graph-structured data using description logics. In: Proceedings of the Twenty-Eighth AAAI Conference on Artificial Intelligence. pp. 966–973 (2014)

  • [2] Baader, F., Brandt, S., Lutz, C.: Pushing the envelope. In: Kaelbling, L., Saffiotti, A. (eds.) Proc. IJCAI 2005. pp. 364–369. Edinburgh, Scotland, UK (August 2005)
  • [3] Baader, F., Brandt, S., Lutz, C.: Pushing the envelope. In: LTCS-Report LTCS-05-01. Inst. for Theoretical Computer Science, TU Dresden (2005)
  • [4] Baader, F., Lippmann, M., Liu, H.: Using causal relationships to deal with the ramification problem in action formalisms based on description logics. In: LPAR-17. pp. 82–96 (2010)
  • [5] Baader, F., Lutz, C., Milicic, M., Sattler, U., Wolter, F.: Integrating description logics and action formalisms: First results. In: Proc. AAAI 2005. pp. 572–577 (2005)
  • [6] Baader, F., Liu, H., ul Mehdi, A.: Verifying properties of infinite sequences of description logic actions. In: ECAI. pp. 53–58 (2010)
  • [7] Babb, J., Lee, J.: Cplus2asp: Computing action language + in Answer Set Programming. In: Proc. Logic Programming and Nonmonotonic Reasoning, LPNMR 2013. pp. 122–134 (2013)
  • [8] Bagheri Hariri, B., Calvanese, D., Montali, M., De Giacomo, G., De Masellis, R., Felli, P.: Description logic knowledge and action bases. J. Artif. Intell. Res. 46, 651–686 (2013)
  • [9] Baral, C., Gelfond, M.: Reasoning agents in dynamic domains. In: Logic-Based Artificial Intelligence, pp. 257–279 (2000)
  • [10] Cabalar, P., Kaminski, R., Morkisch, P., Schaub, T.: telingo = ASP + time. In: Logic Programming and Nonmonotonic Reasoning - 15th International Conference, LPNMR 2019, Philadelphia, PA, USA, June 3-7, 2019, Proceedings. Lecture Notes in Computer Science, vol. 11481, pp. 256–269. Springer (2019)
  • [11] Calvanese, D., Kharlamov, E., Montali, M., Santoso, A., Zheleznyakov, D.: Verification of inconsistency-aware knowledge and action bases. In: Proc. IJCAI 2013 (2013)
  • [12]

    Chang, L., Shi, Z., Gu, T., Zhao, L.: A family of dynamic description logics for representing and reasoning about actions. J. Autom. Reasoning 49(1), 1–52 (2012)

  • [13] Denecker, M., Theseider Dupré, D., Van Belleghem, K.: An inductive definitions approach to ramifications. Electronic Transactions on Artificial Intelligence 2, 25–97 (1998)
  • [14] Eiter, T., Faber, W., Leone, N., Pfeifer, G., Polleres, A.: A logic programming approach to knowledge-state planning: Semantics and complexity. ACM Transactions on Computational Logic 5(2), 206–263 (2004)
  • [15] Gelfond, M.: Handbook of Knowledge Representation, chapter 7, Answer Sets. Elsevier (2007)
  • [16] Gelfond, M., Lifschitz, V.: The stable model semantics for logic programming. In: Logic Programming, Proc. of the 5th Int. Conf. and Symposium. pp. 1070–1080 (1988)
  • [17] Gelfond, M., Lifschitz, V.: Action languages. Electron. Trans. Artif. Intell. 2, 193–210 (1998)
  • [18] Giordano, L., Martelli, A., Schwind, C.: Ramification and causality in a modal action logic. J. Log. Comput. 10(5), 625–662 (2000)
  • [19] Giordano, L., Martelli, A., Schwind, C.: Reasoning about actions in dynamic linear time temporal logic. The Logic Journal of the IGPL 9(2), 289–303 (2001)
  • [20] Giordano, L., Martelli, A., Spiotta, M., Theseider Dupré, D.: ASP for reasoning about actions with an EL knowledge base. In: Fiorentini, C., Momigliano, A. (eds.) Proceedings of the 31st Italian Conference on Computational Logic, Milano, Italy, June 20-22, 2016. CEUR Workshop Proceedings, vol. 1645, pp. 214–229. CEUR-WS.org (2016), http://ceur-ws.org/Vol-1645/paper_15.pdf
  • [21] Giordano, L., Martelli, A., Theseider Dupré, D.: Reasoning about actions with temporal answer sets. In: Faber, W., Leone, N. (eds.) Proceedings of the 25th Italian Conference on Computational Logic, Rende, Italy, July 7-9, 2010. CEUR Workshop Proceedings, vol. 598. CEUR-WS.org (2010)
  • [22] Giordano, L., Martelli, A., Theseider Dupré, D.: Achieving completeness in bounded model checking of action theories in ASP. In: Brewka, G., Eiter, T., McIlraith, S.A. (eds.) Principles of Knowledge Representation and Reasoning: Proceedings of the Thirteenth International Conference, KR 2012, Rome, Italy, June 10-14, 2012. AAAI Press (2012), http://www.aaai.org/ocs/index.php/KR/KR12/paper/view/4532
  • [23] Giordano, L., Martelli, A., Theseider Dupré, D.: Reasoning about actions with temporal answer sets. Theory and Practice of Logic Programming 13, 201–225 (2013)
  • [24] Giordano, L., Martelli, A., Theseider Dupré, D.: Achieving completeness in the verification of action theories by bounded model checking in ASP. J. Log. Comput. 25(6), 1307–1330 (2015), https://doi.org/10.1093/logcom/ext067
  • [25] Giordano, L., Schwind, C.: Conditional logic of actions and causation. Artif. Intell. 157(1-2), 239–279 (2004)
  • [26] Giunchiglia, E., Lee, J., Lifschitz, V., McCain, N., , Turner, H.: Nonmonotonic causal theories. Artificial Intelligence 153(1-2), 49–104 (2004)
  • [27] Giunchiglia, E., Lifschitz, V.: An action language based on causal explanation: Preliminary report. In: Proc. AAAI/IAAI 1998. pp. 623–630 (1998)
  • [28] Heljanko, K., Niemelä, I.: Bounded LTL model checking with stable models. Theory and Practice of Logic Programming 3(4-5), 519–550 (2003)
  • [29] Henriksen, J., Thiagarajan, P.: Dynamic linear time temporal logic. Annals of Pure and Applied logic 96(1-3), 187–207 (1999)
  • [30] Krötzsch, M.: Efficient inferencing for OWL EL. In: Proc. JELIA 2010. pp. 234–246 (2010)
  • [31] Lifschitz, V.: Frames in the space of situations. Artificial Intelligence 46, 365–376 (1990)
  • [32] Lin, F.: Embracing causality in specifying the indirect effects of actions. In: IJCAI 95, Montréal Québec, Canada, August 20-25 1995, 2 Volumes. pp. 1985–1993 (1995)
  • [33] Liu, H., Lutz, C., Milicic, M., Wolter, F.: Reasoning about actions using description logics with general tboxes. In: Proc. JELIA 2006, Liverpool, UK. pp. 266–279 (2006)
  • [34] McCain, N., Turner, H.: A causal theory of ramifications and qualifications. In: Proc. IJCAI 95. pp. 1978–1984 (1995)
  • [35] Thielscher, M.: Ramification and causality. Artif. Intell. 89(1-2), 317–364 (1997)
  • [36] Winslett, M.: Reasoning about action using a possible models approach. In: Proc. AAAI, St. Paul, MN, August 21-26, 1988. pp. 89–93 (1988)