Event Calculus with Explicit Quantifiers∗ Iliano Cervesato† , Massimo Franceschet‡ , and Angelo Montanari‡ †
Department of Computer Science Stanford University Stanford, CA 94305-9045
[email protected]
Dipartimento di Matematica e Informatica Universit`a di Udine Via delle Scienze, 206 – 33100 Udine, Italy
[email protected];
[email protected]
Abstract Kowalski and Sergot’s Event Calculus (EC ) is a simple temporal formalism that, given a set of event occurrences, derives the maximal validity intervals (MVIs) over which properties initiated or terminated by these events hold. We extend the range of queries accepted by EC, so far limited to boolean combinations of MVI verification or computation requests, to admit arbitrary quantification over events and properties. We demonstrate the added expressive power by encoding a medical diagnosis problem as a case study. Moreover, we give an implementation of this formalism and analyze the computational complexity of the extended calculus.
1
‡
Introduction
The Event Calculus, abbreviated EC [5], is a simple temporal formalism designed to model and reason about scenarios characterized by a set of events, whose occurrences have the effect of starting or terminating the validity of determined properties. Given a (possibly incomplete) description of when these events take place and of the properties they affect, EC is able to determine the maximal validity intervals, or MVIs, over which a property holds uninterruptedly. In practice, since this formalism is usually implemented as a logic program, EC can also be used to check the truth of MVIs and process boolean combinations of MVI verification or computation requests. The range of queries that can be expressed in this way is however too limited for modeling realistic situations. ∗ The first author was supported by ONR grant N00014-97-10505, Multidisciplinary University Research Initiative Semantic Consistency in Information Exchange. The work of the third author was partially supported by the CNR project Programmazione logica: strumenti per analisi e trasformazione di programmi; tecniche di ingegneria del software; estensioni con vincoli, concorrenza ed oggetti (STE).
A systematic analysis of EC has recently been undertaken in order to gain a better understanding of this calculus and determine ways of augmenting its expressive power. The keystone of this endeavor has been the definition of an extendible formal specification of the functionalities of this formalism [2]. This has had the effects of establishing a semantic reference against which to verify the correctness of implementations [2], of casting EC as a model checking problem [3], and of setting the ground for studying the complexity of this problem, which was proved polynomial [1]. Extensions of this model have been designed to accommodate constructs intended to enhance the expressiveness of EC . In particular, modal versions of EC [2], the interaction between modalities and connectives [3], and preconditions [4] have all been investigated in this context. In this paper, we continue the endeavor to enhance the expressive power of EC by considering the possibility of quantifying over events and properties in queries. We also admit boolean connectives and requests to verify the relative order of two events. We show that the resulting language, that we call QCEC, can effectively be used to encode interesting problems in medical diagnosis. Moreover, we provide an elegant implementation in the higher-order logic programming language λProlog [6] and prove its soundness and completeness. Finally, we analyze the complexity of the model checking problem involving this language. The main contributions of this work are: (1) the extension of the event calculus with quantifiers; (2) permitting queries to mention ordering information; and (3) the use of the higher-order features of modern logic programming languages in temporal reasoning. This paper is organized as follows. In Section 2, we formalize QCEC . Section 3 is devoted to exemplifying how this calculus can adequately model certain medical diagnosis problems. In Section 4, we briefly introduce the logic programming language λProlog, give an implementation of QCEC in it and prove the sound-
Appeared in the Proceedings of the Fifth International Workshop on Temporal Representation and Reasoning — TIME’98 (R. Morris, L. Khatib editors), pp. 81–88, IEEE Computer Society Press, Sanibel Island, FL, 16–17 May 1998.
ness and completeness of the resulting program. In Section 5, we analyze the complexity of QCEC . We outline directions of future work in Section 6.
2
precedes e2 in the ordering w. For reasons of efficiency, implementations usually represent the temporal information of an EC problem as a binary acyclic relation o from which w can be recovered by taking its transitive closure, written o+ . Given a structure H = (E, P, [·i, h·], ]·,·[) and an event ordering w, we call the pair (H, w) an ECproblem. EC permits inferring the maximal validity intervals, or MVIs, over which a property p holds uninterruptedly. We represent an MVI for p as p(ei , et ), where ei and et are the events that respectively initiate and terminate the interval over which p holds maximally. Consequently, we adopt as the query language of an EC problem (H, w) the set
Event Calculus with Quantifiers
In this section, we first recall the syntax and semantics of the Event Calculus, EC for short (2.1). We then extend this basic definition to give a semantic foundation to the Event Calculus with Connectives and Quantifiers, abbreviated QCEC (2.2).
2.1 EC The Event Calculus (EC ) [5] and the extension we propose aim at modeling scenarios that consist of a set of events, whose occurrences over time have the effect of initiating or terminating the validity of properties, some of which may be mutually exclusive. We formalize the time-independent aspects of a situation by means of an EC-structure [2], defined as follows:
LH (EC) = {p(e1 , e2 ) : p ∈ P and e1 , e2 ∈ E} of all such property-labeled intervals over H. We interpret the elements of LH (EC) as propositional letters and the task performed by EC reduces to deciding which of these formulas are MVIs in w and which are not. This is a model checking problem. In order for p(e1 , e2 ) to be an MVI relative to the event ordering w, it must be the case that e1 type implies mvi -> infixr or 5. infixr and 5. infixl implies 4.
% ------- Quantifiers type forAllEvent (event -> type forSomeEvent (event -> type forAllProp (property type forSomeProp (property
B
% 7 %
mvi. mvi. -> mvi. -> mvi. % 8 %
% 9 % % 10 %
% 11 %
module malaria. accumulate qcec.
kind event type. kind property type. kind mvi type.
prop fever. prop chills. malaria :- holds (forAllEvent E1 \ forAllEvent E2 \ ((period E1 chills E2) implies (forSomeEvent E1’ \ forSomeEvent E2’ \ ((E1 precedes E1’) and (E1’ precedes E2) and (period E1’ fever E2’))))).
property -> o. property -> o. -> property -> o. o. -> o.
% ------- MVIs type period event -> property -> event -> mvi. type holds mvi -> o. type broken event -> property -> event -> o. holds (period Ei P Et) :happens Ei, initiates Ei P, happens Et, terminates Et P, before Ei Et, not (broken Ei P Et). broken Ei P Et :happens E,
% 6 %
Diagnosing Malaria
type fever property. type chills property. type malaria o.
event -> event -> property event -> property
mvi) -> mvi) -> -> mvi) -> mvi)
% 4 % % 5 %
holds (forAllEvent X) :not (sigma E \ (happens E, not (holds (X E)))). holds (forSomeEvent X) :sigma E \ holds (X E). holds (forAllProp X) :not (sigma P \ (prop P, not (holds (X P)))). holds (forSomeProp X) :sigma P \ holds (X P).
Implementation of QCEC
initiates terminates exclusive happens prop
mvi. mvi -> mvi. mvi -> mvi. mvi -> mvi.
holds (neg X) :- not (holds X). holds (X and Y) :holds X, holds Y. holds (X or Y) :holds X; holds Y. holds (X implies Y) :holds ((neg X) or Y).
module qcec. accumulate transClo.
type type type type type
% 3 %
C
% 1 %
Mr. Jones’s Medical Record
module jones. accumulate malaria. type type
% 2 %
8
e1 event. e2 event.
type e3 event. type e4 event. type e5 event. type e6 event. type e7 event. type e8 event. type e9 event. type e10 event. type e11 event. type e12 event. happens e1. happens e2. happens e3. happens e4. happens e5. happens e6. happens e7. happens e8. happens e9. happens e10. happens e11. happens e12. initiates e1 chills. initiates e2 fever. terminates e3 chills. terminates e4 fever. initiates e5 chills. initiates e6 fever. terminates e7 chills. terminates e8 fever. initiates e9 chills. initiates e10 fever. terminates e11 chills. terminates e12 fever. beforefact e1 e2. beforefact e2 e3. beforefact e3 e4. beforefact e4 e5. beforefact e5 e6. beforefact e6 e7. beforefact e7 e8. beforefact e8 e9. beforefact e9 e10. beforefact e10 e11. beforefact e11 e12.
9
