# Event calculus

Jump to: navigation, search

The event calculus is a logical language for representing and reasoning about events and their effects first presented by Robert Kowalski and Marek Sergot in 1986. It was extended by Murray Shanahan and Rob Miller in the 1990s. Similar to other languages for reasoning about change, the event calculus represents the effects of actions on fluents. However, events can also be external to the system. In the event calculus, one can specify the value of fluents at some given time points, the events that take place at given time points, and their effects.

## Fluents and events

In the event calculus, fluents are reified. This means that they are not formalized by means of predicates but by means of functions. A separate predicate ${\displaystyle HoldsAt}$ is used to tell which fluents hold at a given time point. For example, ${\displaystyle HoldsAt(on(box,table),t)}$ means that the box is on the table at time ${\displaystyle t}$; in this formula, ${\displaystyle HoldsAt}$ is a predicate while ${\displaystyle on}$ is a function.

Events are also represented as terms. The effects of events are given using the predicates ${\displaystyle Initiates}$ and ${\displaystyle Terminates}$. In particular, ${\displaystyle Initiates(e,f,t)}$ means that, if the event represented by the term ${\displaystyle e}$ is executed at time ${\displaystyle t}$, then the fluent ${\displaystyle f}$ will be true after ${\displaystyle t}$. The ${\displaystyle Terminates}$ predicate has a similar meaning, with the only difference being that ${\displaystyle f}$ will be false and not true after ${\displaystyle t}$.

## Domain-independent axioms

Like other languages for representing actions, the event calculus formalizes the correct evolution of the fluent via formulae telling the value of each fluent after an arbitrary action has been performed. The event calculus solves the frame problem in a way that is similar to the successor state axioms of the situation calculus: a fluent is true at time ${\displaystyle t}$ if and only if it has been made true in the past and has not been made false in the meantime.

${\displaystyle HoldsAt(f,t)\leftarrow [Happens(e,t_{1})\wedge Initiates(e,f,t_{1})\wedge (t_{1}

This formula means that the fluent represented by the term ${\displaystyle f}$ is true at time ${\displaystyle t}$ if:

1. an event ${\displaystyle e}$ has taken place: ${\displaystyle Happens(e,t_{1})}$;
2. this took place in the past: ${\displaystyle t_{1};
3. this event has the fluent ${\displaystyle f}$ as an effect: ${\displaystyle Initiates(e,f,t_{1})}$;
4. the fluent has not been made false in the meantime: ${\displaystyle Clipped(t_{1},f,t)}$

A similar formula is used to formalize the opposite case in which a fluent is false at a given time. Other formulae are also needed for correctly formalizing fluents before they have been effects of an event. These formulae are similar to the above, but ${\displaystyle Happens(e,t_{1})\wedge Initiates(e,f,t_{1})}$ is replaced by ${\displaystyle HoldsAt(f,t_{1})}$.

The ${\displaystyle Clipped}$ predicate, stating that a fluent has been made false during an interval, can be axiomatized, or simply taken as a shorthand, as follows:

${\displaystyle Clipped(t_{1},f,t_{2})\equiv \exists e,t[Happens(e,t)\wedge (t_{1}\leq t

## Domain-dependent axioms

The axioms above relate the value of the predicates ${\displaystyle HoldsAt}$, ${\displaystyle Initiates}$ and ${\displaystyle Terminates}$, but do not specify which fluents are known to be true and which events actually make fluents true or false. This is done by using a set of domain-dependent axioms. The known values of fluents are stated as simple literals ${\displaystyle HoldsAt(f,t)}$. The effects of events are stated by formulae relating the effects of events with their preconditions. For example, if the event ${\displaystyle open}$ makes the fluent ${\displaystyle isopen}$ true, but only if ${\displaystyle haskey}$ is currently true, the corresponding formula in the event calculus is:

${\displaystyle Initiates(e,f,t)\equiv [e=open\wedge f=isopen\wedge HoldsAt(haskey,t)]\vee \cdots }$

The right-hand expression of this equivalence is composed of a disjunction: for each event and fluent that can be made true by the event, there is a disjunct saying that ${\displaystyle e}$ is actually that event, that ${\displaystyle f}$ is actually that fluent, and that the precondition of the event is met.

The formula above specifies the truth value of ${\displaystyle Initiates(e,f,t)}$ for every possible event and fluent. As a result, all effects of all events have to be combined in a single formulae. This is a problem, because the addition of a new event requires modifying an existing formula rather than adding new ones. This problem can be solved by the application of circumscription to a set of formulae each specifying one effect of one event:

${\displaystyle Initiates(open,isopen,t)\leftarrow HoldsAt(haskey,t)}$
${\displaystyle Initiates(break,isopen,t)\leftarrow HoldsAt(hashammer,t)}$
${\displaystyle Initiates(break,broken,t)\leftarrow HoldsAt(hashammer,t)}$

These formulae are simpler than the formula above, because each effect of each event can be specified separately. The single formula telling which events ${\displaystyle e}$ and fluents ${\displaystyle f}$ make ${\displaystyle Initiates(e,f,t)}$ true has been replaced by a set of smaller formulae, each one telling the effect of an event on a fluent.

However, these formulae are not equivalent to the formula above. Indeed, they only specify sufficient conditions for ${\displaystyle Initiates(e,f,t)}$ to be true, which should be completed by the fact that ${\displaystyle Initiates}$ is false in all other cases. This fact can be formalized by simply circumscribing the predicate ${\displaystyle Initiates}$ in the formula above. It is important to note that this circumscription is done only on the formulae specifying ${\displaystyle Initiates}$ and not on the domain-independent axioms. The predicate ${\displaystyle Terminates}$ can be specified in the same way ${\displaystyle Initiates}$ is.

A similar approach can be taken for the ${\displaystyle Happens}$ predicate. The evaluation of this predicate can be enforced by formulae specifying not only when it is true and when it is false:

${\displaystyle Happens(e,t)\equiv (e=open\wedge t=0)\vee (e=exit\wedge t=1)\vee \cdots }$

Circumscription can simplify this specification, as only necessary conditions can be specified:

${\displaystyle Happens(open,0)}$
${\displaystyle Happens(exit,1)}$

Circumscribing the predicate ${\displaystyle Happens}$, this predicate will be false at all points in which it is not explicitly specified to be true. This circumscription has to be done separately from the circumscription of the other formulae. In other words, if ${\displaystyle F}$ is the set of formulae of the kind ${\displaystyle Initiates(e,f,t)\leftarrow \cdots }$, ${\displaystyle G}$ is the set of formulae ${\displaystyle Happens(e,t)}$, and ${\displaystyle H}$ are the domain independent axioms, the correct formulation of the domain is:

${\displaystyle Circ(F;Initiates,Terminates)\wedge Circ(G;Happens)\wedge H}$

## The event calculus as a logic program

The event calculus was originally formulated as a set of Horn clauses augmented with negation as failure and could be run as a Prolog program. In fact, circumscription is one of the several semantics that can be given to negation as failure, and is closely related to the completion semantics (in which "if" is interpreted as "if and only if" — see logic programming).

## Extensions and applications

The original event calculus paper of Kowalski and Sergot focused on applications to database updates and narratives. Extensions of the event calculus can also formalize non-deterministic actions, concurrent actions, actions with delayed effects, gradual changes, actions with duration, continuous change, and non-inertial fluents.

Kave Eshghi showed how the event calculus can be used for planning, using abduction to generate hypothetical events in abductive logic programming. Van Lambalgen and Hamm showed how the event calculus can also be used to give an algorithmic semantics to tense and aspect in natural language using constraint logic programming.

## Reasoning tools

In addition to Prolog and its variants, several other tools for reasoning using the event calculus are also available: