=Paper=
{{Paper
|id=None
|storemode=property
|title=The temporal representation and reasoning of complex events
|pdfUrl=https://ceur-ws.org/Vol-810/paper-s07.pdf
|volume=Vol-810
|dblpUrl=https://dblp.org/rec/conf/cilc/MeleS11
}}
==The temporal representation and reasoning of complex events==
https://ceur-ws.org/Vol-810/paper-s07.pdf
The temporal representation and reasoning
of complex events
Francesco Mele1, Antonio Sorgente1,
1
Istituto di Cibernetica, Consiglio Nazionale delle Ricerche,
Via Campi Flegrei, 34 Pozzuoli(Naples) Italy
{f.mele, a.sorgente}@cib.na.cnr.it
Abstract. This paper introduces a formalization of complex events. In
particular, a formalism is presented to represent intentional and causal events in
narrative contexts, and in their mechanisms of composition. Complex events
have been defined through classes of a formal ontology that has been called the
Ontology of Complex Events (OntoCE). This approach has allowed for the
applications (reuse) of existing axiomatizations belonging to a large repertoire
of temporal reasoning techniques and, the definition of new axiomatizations
presented and discussed in this work. The focus in this work has been placed on
three particular temporal aspects: the analysis of consistency, the discovery of
new temporal relations in a knowledge base of events, and the causal reasoning
in narrative contexts.
1 Introduction
The concept of event has been highly examined and much debated in philosophy
[CAS, DAV] and Artificial Intelligence. In this area, some well-founded formalisms,
like the Event Calculus [MIL], the Situation Calculus [LEV, LIN], and ALAN [BAR,
Gon] have been proposed. Recently, a new point of attention, that regards the concept
of the "complex event" [WIN], has been born (although this name is not explicitly
mentioned by all the research projects that deal with these issues).
This concept emerges, particularly in the context of the Internet, where the broad
set of information in unstructured form, hides a multitude of events that are connected
by relationships extremely difficult to detect, but where one feels that these events are
components of an implicit totality (suggested without being directly expressed).
The particular aim of this research was to build a model and a formalism to
represent three main types of complex events (intentional events, causal events, and
narrative events) and their mechanisms of composition.
The paper introduces a representation of complex events, in which an event is not
only an aggregation of simple events (how it would be in the case of a narrative of
events, consisting of a set of simple events and a set of relationships between those
events). The modeling of narratives that have as components other complex events
has been addressed. For example, casual events are considered such as: (the church of
Santa Chiara was built (e1) for desire (e2) of Roberto D'Angiò) (e0), where e0 is
composed by the events e1 and e2 and could also represent the component of a
narrative. A mechanism for determining the interval in which a complex event
(intensional, narrative or causal) occurs has also been proposed. Such intervals have
been calculated considering the intervals of happening of its component events (e0):
in the example the event e0 has an occurrence interval that is calculated as union of
occurrence intervals of events e1 and e2.
By inserting intentional events, in representation of a narrative, one can not only
annotate or discover causal connections between events, but with appropriate axioms
(eg (e1 cause e2) implies (e1 precedes e2)) one can convert the causal relations into
temporal order relations, thus eliminating the existing deficiencies of connectivity
among the events of a narrative.
A formalism has been constructed to represent the complex events in explicit form,
with the main motivation that such a representation can be used as an ontological
reference for various types of semantic annotations, in particular:
− to aggregate, as complex events, multimedia elements (photos, video or texts
whose contents represent events (historical events, news, cultural events, etc.) in
the same way as proposed in the Event-Centric in [GIU] and [MEL]; and,
− to annotate and aggregate complex events in natural language, starting from
annotations represented by TimeML [PUS03, PUS08] formalism.
An annotation process of natural language texts or media, especially if this is done
through a process of multiple annotation (by more than one operator), can easily
generate some inconsistencies or lack of connections between events in the bases of
annotations. For these reasons, it is necessary to identify inconsistencies and non-
connected events in order to remove such anomalies among the annotated events (see
Fig. 1).
Fig. 1. Phases to control the consistency and connectivity of a narrative
The formalism (OntoCE) that has been defined in this paper is represented by a
formal ontologies, where each entity has been defined as a class of an ontology. This
methodological approach was chosen to facilitate the building of modules
(algorithms) for the discovery of temporal relations, with the objective also, to reuse
existing axiomatizations and facilitate the creation of new ones (some of these
proposals are in this paper).
In this paper the logic programs have been used to represent the events (simple and
complex) and their relations, to analyse the temporal consistency of a complex event,
to discover new temporal relations between events, to apply causal reasoning to
events, and to integrate the latter with axioms of temporal reasoning.
Related work
In recent research [WIN] there are several proposals for representing events. The
basic motivation of this research stands from the claim that events can constitute an
excellent framework for aggregating knowledge. The large quantity of data and
(fragmented and unstructured) knowledge on the Internet, makes this research very
attractive. An emerging methodology for representing through events knowledge
distributed on the Internet has been named Event-Centric [WIN]. In this methodology,
an event is a structure of reference that is independent from the metadata of media
that one intends to annotate. An example of the Event-Centric approach, which uses
high-level ontology DOLCE, is the F model [SHE]. In the F model the
methodological choices are motivated by a number of functional and non-functional
requirements.
With respect to the functional requirements, the representation of an event must
have the attribute for the participants. It is also necessary to be able to define
relationships between parts and wholes of an event. It must be possible to define
cause-effect relationships between two events (no matter of the degree of difficulty of
the automatic process discovery), and, finally, it must be possible to represent
correlation relationships between events (two events that have a common cause).
The non-functional requirements of F, instead, include extensibility, formal
precision (axiomatization), modularity, and reusability.
Among the proposed Event-Centric is the one proposed in [GIU]. This
methodology adopts the slogan "Aggregation via Media Events". In this proposal, the
events are the reference structures for aggregating the media. In [GIU] an implicit
model of complex events (without explicit constructs of representation) and a simple
mechanism to determine the "where" a complex event happens, starting from the
"where" of the components’ events, are introduced.
To represent the events, some formalisms were inspired from a model that has its
roots in journalism. This model called "W's and one H" adopts six attributes for the
representation of events: Who, When, Where, What, Why, and How. The project
Eventory [WAN] adopts a model "W's and one H". Eventory has a particular structure
of the "When" attribute, having two references for time: the first referring to the
chronological time of "real events", the second, to the temporal attributes of some
metadata (such as the length of a movie or the time during which a picture must be
shown).
The decision to include the knowledge of the media in the attributes of the events,
violates the constraint that characterizes the Event-Centric models, whereby the
independency between the event representation and that of media is fixed. In fact, in
the case of Eventory, the description contains information about the execution time of
the media.
In this work, in relation to the representation of temporal intervals, the
classification given in [MAJ], where all the possible combinations that exist between
instants or time intervals are shown, when they represent a temporal relationship
between two events, has been taken into consideration.
2 The representation of the events
In this work, an ontology for complex events has been defined: OntoCE. OntoCE has
an abstract superclass (AnythingInTime) common to all entities that happen over
time. Two subclasses are specializations of AnythingInTime: Event, that
represents the class of simple events, and ComplexEvent, that represents the class
of complex events. In Fig. 2 a sketch representation is given.
Fig. 2. The taxonomy of simple and complex events
In Fig.2, in brackets, the attributes that are inherited from their respective
superclasses are reported. Formally, they are represented in Flora21[FLO](this
formalism combines the advantages of conceptual modeling with object-oriented,
owns a declarative syntax, allowing to build complex inferential apparatus in simple
manner):
Event::AnyThingInTime.
ComplexEvent::AnyThingInTime.
AnyThingInTime[
hasWhen*=>When, hasWhere*=>Where,
hasParticipants*=>Participant].
Event[hasWhat*=> Action_Property].
ComplexEvent[ hasComplexWhat*=> AnyThingInTime,
hasEventRelations*=>EventRelation].
AnyThingInTime is an abstract class (without instances) which is the superclass
of the concrete classes: Event and ComplexEvent. The latter classes are the key
concepts of the formalism OntoCE. The Event class has the descriptor hasWhat,
which is associated to the class What. Generally, this class describes the action (which
happens over time) that characterizes the event or describes a property that is true in a
specific time interval. The attribute hasComplexWhat is a specific descriptor of
ComplexEvent. The latter also has the attribute hasWhy that describes the causal
relations between events. hasWhy is a relation between two events, so it can only be
the attribute of a complex event. Attributes hasWhen, hasWhere,
hasParticipants, hasWhat (or hasComplexWhat), and hasWhy
correspond to the descriptors with which journalists describe their articles.
1
To make reading simpler, some key constructs of Flora2 language are here reported. X:: Y
(class X is a subclass of class Y), X: Y (X is an instance of class Y), X => Y (X is an
attribute of type Y), X-> Y (Y is the value of X), X *=> Y (as X => Y, but the attribute is
inherited by subclasses). In Flora2, chain of alphanumeric literal, starting with a capital letter
are variables. The symbols ":-", the comma (",") and semicolon (";") have the same
interpretation as the homologue constructs of Prolog language.
2.1 Instant and interval representations
The representation of time that has been adopted is mixed and based on points and
time intervals. In OntoCE all temporal entities are represented as classes. Time is the
main class and has several specializations: date or partial dates (DateValue), time
instants or combinations of them with date (TimeValue), symbolic times
(Symbolic), and time intervals (Interval). The definition is as follows:
DateCalendar[
day*=>Integer, month*=>Integer, year*=>Integer].
DateWeek[week*=>Integer, year*=>Integer].
DateQualitative[value*=>String].
Clock[
hour*=>Integer,minute*=>Integer,date*=>DateCalendar].
TimeQualitative[value*=>String].
Interval[
hasBeginTime*=>(DateValue;TimeValue;SymbolicTime),
hasEndTime*=>(DateValue; TimeValue; SymbolicTime)].
SymbolicHappenInterval[
sti*=>SymbolicTime,stf*=> SymbolicTime].
2.2 The When class
In OntoCE there is a particular structure, the class When (see Fig. 2), which
describes when an event happens using the effective symbolic interval (ESI) in which
the event happens, and a temporal modality of happening, described by one (or more)
temporal order relations (before, after, during, etc.) between ESI and some temporal
interval of reference (or also another event). These relations have the objective of
anchoring an event on the chronological axis or with another event, through a
temporal order relation. The approach requires, therefore, that when an event (simple
or complex) is created, it automatically generates a type identifier ESI, represented by
two attributes: sti, the (effective) symbolic time in which the event starts (or in
which the property is true), and stf, the time in which the event ends. The choice of
having an effective time when an event happens and a temporal modality of
happening, for it is motivated by the fact that often the effective time in which an
event happens is not known, but one can easily know one or more relations (modality
of happening) for it (after a time tx, dtx before a certain range, etc.). Thus, even if one
does not exactly know the exact value of the start and end/or of an event, one can
annotate (or, automatically discover) relationships with other time intervals, as soon
as they become available. The class When has the following definition:
When[
hasSymbolicHappenInterval*=>SymbolicHappenInterval,
hasTemporalMode*=>TemporalRelation].
SymbolicHappenInterval[sti*=> SymbolicTime,
stf*=> SymbolicTime].
2.3 Simple Events
In OntoCE, the class Event represents simple events. This class inherits the
attributes of the superclass AnyThingInTime and has the attribute hasWhat,
which describes an action that happens or a property that is true in a temporal interval.
Event[hasWhat*=>Action-Property].
The attribute hasWhat has values in the Property_Action domain and
describes exactly what happens (action) or what is true (property) in a temporal
interval.
2.4 Complex events
ComplexEvent is a class defined as a set of events (simple or complex) described
by ComplexWhat slot, and a set of relationships between events described by
hasEventRelations slot. Also, the class is described by the method
hasWhy(AnyThingInThing), a function that given an input event belonging to a
complex event, returns a set of causal relations that are the justification of why the
event occurred.
ComplexEvent[ hasComplexWhat{2:*}*=>AnythingInTime,
hasWhy(AnyThingInThing)*=> CausalRelation,
hasEventRelations*=>EventRelation].
Complex events are defined by a temporal mode, described by the descriptor
hasWhen, the same attribute used for the description of simple events. Fig. 3 shows
the taxonomy of the complex events of the OntoCE ontology, where the narrative
events, the causal events, the intentional events, and the perceptual events have been
labeled and represented as complex events.
Narrative Events
The complex narrative events (NarrativeEvent) are represented as a set of events
and temporal relations between events. The components of NarrativeEvent are
simple events that describe actions that occur over time, or properties that are true in a
temporal interval, or other complex events such as causal events (CausalEvent) or
intentional events (MentalEvent).
NarrativeEvent, like all subclasses of AnyThingInTime inherits the
attributes When, Where, and Who, and like all the subclasses of ComplexEvent,
inherits the method hasWhy(AnyThingInThing). The characterization of
NarrativeEvent is given by the restriction of the slot hasEventRelations,
which can only have instances of temporal relations as a value.
Fig. 3 The taxonomy (subclasses) of complex events.
Mental events
The class MentalEvent represents mental events of an agent (participant at the
event), i.e., beliefs, desires, and intentions that occur over time. These entities allow
for the representation as a causal events such as "The church and monastery of Santa
Chiara was built between 1310 and 1340 for desire of Roberto d'Angiò and Queen
Sancha of Aragon". Mental events are defined, through to the attributes When, What,
Where, and Participants (inherited by AnyThingInTime) by a slot that describes a
relation (MentalRelation) between a mental event and a physical event.
Causal events
The complex event CausalEvent describes events that relate to a cause-effect
relation: the occurrence of an event (event cause) caused the occurrence of another
event (event effect). In OntoCE a classification of causal events has been defined in
accordance with the nature of the events involved, or that is, if the cause-effect
relationship is defined by physical and/or mental events. We report some examples of
the categories:
− “I think it's a good book, I’ll buy it”, and “I would like something hot, I'll take a
cup of tea”, are examples of causal relations of a mental event that causes a
physical event (classified in OntoCE as a causal PhysicalByMentalEvent);
− “He laughed and I thought he was joking” is an example of causal event where a
physical event (perception) caused a mental event (in OntoCE labeled as
MentalEventByPhysical);
− “He bumped the glass with his elbow and broke it”, “It’s raining and the road is
wet” (causal events labeled in OntoCE as PhysicalEventByPhysical); and,
− “I think it's the best team and I think it will win the championship” (causal events
labeled in OntoCE as MentalEventByMental).
Causal events are defined by a causal relationship between events and like all
events subclasses of AnyThingInTime inherit the attributes When, What, Where,
and Participant.
For causal events, a widely shared relation (axiom), that brings together the causal
relations with temporal relations, has been defined:
BeforeEE[Ex, Ey]:- CausalRelation[Ex, Ey]. (1)
If Ex is the cause of Ey, then the event Ex precedes temporally the event Ey.
2.5 The When Attribute of a complex event
For the simple event, the time of happening (hasSymbolicHappenInterval)
defines the temporal interval in which the action occurs, while the time interval of
occurrence of the complex event defines the minimum time interval in which all
events belong to the complex event occurring. Therefore, the occurrence interval of
complex events is not continuous, or that is, not in all temporal subintervals is there
an event that happens. In addition, the temporal mode of a complex event is
represented as the union of the temporal mode of event’s components. It is obvious
that, starting from the all temporal mode, one can define various algorithms that can
determine, for example, the entire period of a complex event or the frequency of a
particular action or category of action, etc.
The descriptor When can be calculated according to the descriptors of the
component events, or it is instantiated interactively. In the latter case the compatibility
checks (defined by constraints), with respect to the attributes When of the components
events, must be run .
Informally, the interval of occurrence of a complex event is made up of the
intervals of occurrence of the events’ components and a set of temporal relations
between these intervals. The rule for determining the minimum time of occurrence of
a complex event, in accordance with the event components is reported. Let Ec be a
complex event (a narrative), then its time of occurrence (defined as an instance of the
class When) is calculated using the following rule:
01. Ec:NarrativeEvent[ hasComplexWhat->{E1, E2},
hasWhen->Wx]:-
02. newId(Ec,E1,E2,Wx),
03. genSymbolicInterval(I,T1,T2),
04. insert{I:SymbolicHappenInterval[sti->T1,stf->T2]},
05. E1:AnythingInTime[hasWhen->W1],
06. E2:AnythingInTime[hasWhen->W2],
07. minimun(W1, W2,Tmin), maximum(W1, W2,Tmax),
08. tm_union(W1,W2,
[EqualTT[T1,Tmin],EqualTT[T2,Tmax]], Tmx),
09. insert{Wx:When[ hasSymbolicHappenInterval->I,
hasTemporalMode->Tmx]}.
To establish the time of occurrence of the narrative event Ec (01), the rule
generates the structure Wx of the When attribute (02) and defines the symbolic
interval of occurrence of the complex event (03-04). Then, it identifies the time of
occurrence of the component events (05-06), and calculates the minimum and
maximum time of occurrence of these events (07). The minimum and maximum
calculated are correlated with the symbols’ times with relations
EqualTT[T1,Tmin] and EqualTT[T2,Tmax], which together with the
temporal mode of the components (08) define the temporal mode of the complex
event (09).
Others rules (not reported here) have been defined that consider the cases where
the minimum and/or maximum of events cannot be determined, for example, because
the annotation of the temporal mode is not complete.
In these cases, to overcome the inability to calculate the minimum and/or
maximum, the rule defines temporal relations between the component events, E1 and
E2, and the occurrence interval I of complex event. The relations are
DuringEI[E1,I] and DuringEI[E2,I], which, together with the temporal
mode pattern of the components, define the temporal mode of the complex event.
Similar rules relating to the When for all types of complex events have been
implemented.
3 Temporal reasoning for complex events
The classes of events that have been defined are appropriate for applying
axiomatizations (expressed in the form of Horn clauses) to temporal reasoning.
However, to apply these algorithms, one must follow a specific methodological
statute that is associated with the ontological approach implemented.
Let Ei be a knowledge base of events, the algorithms (to check consistency and
connectivity, and to discover new temporal relations) are applicable to all events that
are not related to mental events: beliefs, desires and goals. This is because a mental
event can be a component of a narrative, but the events that are among its arguments
should not be involved in the analysis of the consistency and connectivity of a
narrative.
Consider the following example: [during the summer of 2010 a fan (Px) wants
Inter to win the next season (2010-11)]. The mental event of Px belongs to a narrative
like this: 1.[ in summer 2010, a fan Px wants Inter to win the league], 2.[in summer
2011, Milan won the championship]. Of course, there is no contradiction between the
two events, because the event "Inter won the league” is something that belongs to the
mind of a person, and does belong to events of real history. However, it is necessary
to ensure a consistency in the set of events believed by a person. It is clear that the
events to which we apply the algorithms to check consistency must belong to
appropriate categories, and it’s believed that this approach (to define events as
classes) is appropriate for this purpose.
3.1 How to check the consistency of events
For consistency checks of temporal relations, axioms of Russell and Kramp [LAM]
(RK) have been adopted, which allows for performance of reasoning about the events
through the relations between the events precev(E1,E2) and overev(E1,E2),
where precev(E1,E2) means that the event E1 precedes the event E2, and
overev(E1,E2) means that the event E1 overlaps event E2.
The RK language, with the primitive precev(E1,E2) and overev(E1,E2), is
not expressive enough to represent the temporal relations in our ontological
representation (DuringEE[E1,E2], StartEE[E1,E2], etc.). In fact, the
relations like DuringEE[E1, E2] cannot be defined only through the primitive
precev and overev, because they also require the conditions between time instants.
For this reason, a core with relations between time instants using the primitive
prect(T1,T2) (the time instant T1 precedes the time instant T2) and
eqt(T1,T2) (the time instant T1 is equal to the time instant T2) has been defined.
Through such primitives all temporal relations of OntoCE (between events, between
events and time instant, etc.) have beeen defined and applied to the consistency
analysis redefining the relations RK. Therefore, a set of axioms have been defined,
that allow one to discover inconsistencies, not in order relations between events, but
in order relations between time instants: prect(T1,T2) and eqt(T1,T2). The
following axioms for the verification of the inconsistencies is provided2:
Fig. 4: Axiom schema and relative implementation for inconsistency checking
Axioms 1-4 define the properties of order relations: the transitivity of relation
prect(T1,T2) and eqt(T1,T2), the reflexivity and symmetry of the relation
eqt(T1,T2). As one can see, axioms 1-7 at the heads of the clauses are negated, so
it is not possbile to implement them through monotonic logic programs and then
through the traditional Horn clauses. For this reason a logic program for the axioms 1-
7, through stable model semantics [GEL] by using the SModels system [SYR], has
been implemented (in section 4 we report a running example of Stable Model
Program of Fig. 4). In addition, there is the axiom:
prect(T1,T2) ∨ prect(T2,T1) ∨ eqt(T1,T2)
which translates the timeline by forcing every time point to have a relation of
precedence or equality with another time. This axiom has not been implemented
because it is not a useful consistency check. The axiom, however, would be useful to
ensure the full connection of the time points of a narrative. For this purpose, an
algorithm (shown in [MEL]) for controlling the connection has been defined. The
definition of temporal relations between events in terms of primitive prect(T1,T2)
and eqt(T1,T2) is shown:
2
In this paper we will use the symbols "!" and "<-" to denote the conjunction and implication
in generic expressions of Horn Clauses, we will use instead the symbols "," and ":-" in the
corresponding expressions Prolog and Flora2.
BeforeEE3[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
prect(T2,T3).
AfterEE[E1,E2] <-> BeforeEE[E2,E1].
MeetsEE[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
eqt(T2,T3).
Meet_byEE[E1,E2] <-> MeetsEE[E2,E1].
EqualsEE[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
eqt(T1,T3), eqt(T2,T4).
OverlapsEE[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
prect(T1,T3), prect(T3,T2),
prect(T2,T4).
Overlapped_byEE[E1,E2] <-> OverlapsEE[E2,E1].
DuringEE[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
prect(T2,T4), prect(T3,T1).
ContainsEE[E1,E2] <-> DuringEE[E2,E1].
StartsEE[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
eqt(T1,T3), prect(T2,T4).
Started_byEE[E1,E2] <-> StartsEE[E2,E1].
FinishesEE[E1,E2] <-> dt(E1,T1,T2), dt(E2,T3,T4),
eqt(T2,T4), prect(T3,T1).
Finished_byEE[E1,E2] <-> FinishesEE[E2,E1].
dt(E,T1,T2) provides the value of the start time T1 and end time T2 of the
event E. In addition, for each occurrence interval of event E there is the following
relation:
prect(T1, T2) <- dt(E,T1,T2).
Similary, all temporal relations have been defined.
Once the temporal relations through the primitive prect(T1,T2) and
eqt(T1,T2) have been redefined, one can check the inconsistencies of a set of
temporal relations expressed by the relationship between time points, by using the
axioms 1-7.
The program, given a knowledge base defined through the relations between time
points (the input of the program), calculates the stable models, or rather, groups of
consistent sets of relations (satisfying the axioms 1-7). If the program returns more
than one stable model, then the relations are inconsistent.
In addition, among the events causal relation can be annotated and this produces
new temporal relation between events.
Thus, to have a consistency check for all the relations annotated in a narrative, the
temporal relation derived/obtained from the causal relations must be definend through
the relations prect(T1,T2) and eqt(T1,T2). In this way, it is possible to check
3
In order to ease reading (so there is no ambiguity), simplified Flora2 notation, omitting the
names of attributes, i.e., instead of the notation of instances id:ClassName[attr1-
>val1,attr2->val2, ..,attrn->valn], the following notation
id:ClassName[val1,val2,..,valn] has been adopted.
the consistency of a narrative, according to the methodological approach represented
in Fig. 5.
Fig. 5: Transformation of temporal relations in the primitive prect, eqt.
3.2 How to discover new temporal relations between events
Through the formalism defined for the representation of annotations, a new technique
to discover new temporal relations between events has been developed. The
methodology uses the results of the process of the consistency check. The
axiomatization checks the consistency of the annotations and for the same model,
provides all consistent derivations of set relations. Then, once the consistency of
temporal relationships has been evaluated and (under the assumption of consistency)
the only possible stable model (SM) has been identified, the SM can be used to identify
temporal relations between events, using the equivalence relation between the
temporal relations and order relations defined on time points showed in section 3. For
this purpose, a rule for each temporal relation among events (all subclasses of
TemporalRelationEE) has been defined. Each rule tries to find a particular
temporal relationship (before, after, meets, etc.). Each rule has in input two events
(E1 and E2) and the totality of relations between time points (stable model SM). The
rule for finding BeforeEE relations between two events is shown:
1 findRel(E1,E2,SM) :-
2 not BeforeEE[E1,E2],
3 dt(E1,T1,T2), dt(E2,T3,T4),
4 subset({prect(T1,T2),prect(T3,T4),prect(T2,T4)},SM),
5 insert{BeforeEE[E1,E2]}.
In this case, the rule checks if there already exists a BeforeEE relation between
two events E1 and E2 (2), then it reads the end points of occurrence intervals of
events E1 and E2 (3), and verify the existence of conditions to discover a BeforeEE
relation, or rather, if the relations on time points, which describe the condition, are a
subset of the stable SM (4). Finally, the rule asserts the relation discovered in the
knowledge base (5).
The above rules have been defined for all temporal relations between events:
AfterEE[E1,E2], MeetsEE [E1,E2], etc.
3.3 Causal reasoning
For causal reasoning, an axiomatization (a variant of axiomatization defined in
[BOC]) has been defined. The axioms that have been expressed (in a simplification of
Flora2, see note 2) are reported as follows:
Id1:CausalRelation[A, B]:- Strengthening
Id2:BeforeEE[A, B], demo(A,B),
Id3:CausalRelation[B,C], newId(Id1, Id2, Id3).
Id1:CausalRelation[A, C]:- Weakening
Id2:CausalRelation[A,B], Id3:BeforeEE[B, C],
demo(B,C), newId(Id1,Id2,Id3).
Id1:CausalRelation[A,B∧C]:- And
Id2:CausalRelation[A,B], Id3:CausalRelation[A,C],
newId(Id1,Id2,Id3).
Id1:CausalRelation[A∨B,C]:- Or
Id2:CausalRelation[A,C], Id3:CausalRelation[B,C],
newId(Id1,Id2,Id3).
Id1:CausalRelation[A, C]:- Cut
Id2:CausalRelation[A,B], Id3:CausalRelation[A∧B,C],
newId(Id1,Id2,Id3).
Id1:CausalRelation[A∧C,B]:- Left Monotonicity
Id2:CausalRelation[A, B], C:Event,
Id3:BeforeEE[C,B], newId(Id1, Id2, Id3).
Id1:CausalRelation[A,B∨C]:- Right Monotonicity
Id2:CausalRelation[A,B], C:Event,
Id3:BeforeEE[A,C], newId(Id1, Id2, Id3).
The predicate newId(Id1, Id2, Id3) generates a new id Id1 depending on
Id2 and Id32.
In the axiom Left Monotonicity the condition BeforeEE[C,B] has been included,
because C is an event that cause B, and for this reason, C must precede B; otherwise it
generates a contradiction.
For the axioms of Weakening and Strengthening, the meta-predicate demo(A,B)
(implements the relation "B is deducible from A" [BOC]) have been defined, which
was implemented as a variant of the meta-interpreter [BAT].
The axioms for causal relationships shown above have been defined for the class of
causal events and are applied to all subclasses of that class.
4 An example of the application of the axiomatization for
checking the temporal consistency
In this section, an example of the application of reasoning provided above is
presented. In particular, as an example, a generic consistent narrative (without
specifying in detail the actions of the events) has been defined.
Let e1, e2, e3 and e4 be four events and r1:DuringEI[e1,i1],
r2:AfterET[e3,t2], r3:MeetEE [e1,e2], r4:OverlapsEE[e4,e3],
and r5:BeforeET[e2,t2] be the temporal relations annotated.
t1 and t2 are the endpoints of interval i1; [st1, st2] is the symbolic interval
of occurrence of e1, [st3, st4] is the symbolic interval of occurrence of e2,
[st5, st6] is the symbolic interval of occurrence of e3, [st7, st8] is
symbolic interval of e4.
Before performing the consistency check, the temporal relations were translated
into temporal relations between time points as described in paragraph 3, obtaining the
following: e prect(t1,t2), prect(st1,st2), prect(st3,st4),
prect(st5,st6), prect(st7,st8), prect(st7,st5), prect(st5,st8),
prect(st8,st6), prect(st2,t2), prect(t1,st1), prect(st4,t2),
prect(t2,st5), prect(st2,st3).
In this set of relations the algorithm for checking consistency(paragraph 3) has
been applied. Because the relations are consistent, the program returns to output only
one stable model: stableModelSet([prect(st3,st4), prect(t2,st5),
…, eqt(st3,st2), eqt(st2,st2), eqt(st1,st1), eqt(t2,t2)]).
From this result, new temporal relations through the axioms for discovering new
temporal relations (paragraph 3.2) have been identified, in particular, the rules
identified the temporal relations beforeEE[e1,e3], and beforeEE[e2,e3].
If we add the relation beforeEI[e2,i1], intentionally making the knowledge
base inconsistent, applying the algorithm for the consistency check obtains a more
stable model. This response highlights the presence of inconsistencies.
Conclusions
In this paper a formalism for the representation of complex events has been proposed.
The formalism for the representation of events is based both on time points and
temporal intervals. Associated with this representation, temporal reasoning for
checking the consistency and discovering new temporal relations has been
constructed.
In this approach, unlike [MAN], the phase for checking the consistency is
processed separately from the process for discovering the temporal relations. For this
purpose, the axioms of Russell-Kamp [LAM] have been used to discover
inconsistencies, and then evaluate the possible extensions of temporal relations.
Furthermore, the algorithms must be applied separately, because they relate to
different stages of the process of annotation and its use. Consistency checking is
related to the content resulting from a process of semantic annotation, in which
temporal inconsistencies could arise, while the discovery of temporal relations is a
process that can be activated only after the consistency check.
In this approach, then, the process for checking the consistency of the annotation
and discovering temporal relations have been separated. The motivation for this
choice is so that one can apply different axiomatizations separately and divide
complex problems into simple problems.
References
[ALL] J. Allen, Maintaining knowledge about temporal intervals, Communications of the
ACM vol. 26 (11), p. 832-843, 1983.
[BAR] C. Baral, M. Gelfond, A. Provetti, Representing Actions: Laws, Observations and
Hypotheses. J. Log. Program. 31(1-3): 201-243. 1997
[BAT] R. Barták, P. Stepánek, Extendible Meta-Interpreters, in: Journal KYBERNETIKA,
Volume 33, Number 3, pages 291-310. 1977
[CAS] R. Casati, A. Varzi, "Events", The Stanford Encyclopedia of Philosophy (Spring 2010
Edition), E. N. Zalta (ed.),http://plato.stanford.edu/archives/spr2010/entries/events
[DAV] Davidson D., Essay on Actions and Events, New York, Oxford university Pers, 1980
[FLO] FLORA-2: An Object-Oriented Knowledge Base Language http://flora.sourceforge.net/
[GEL] M. Gelfond, Vladimir Lifschitz, The Stable Model Semantics For Logic Programming.
In Proceedings of the Fifth International Conference on Logic Programming, pages
1070-1080, Seattle USA, August 1988.
[GIU] F. Giunchiglia, P. Andrews, G. Trecarichi, and R. Chenu-Abente, Media Aggregation
via Events, Proceedings of the Workshop on Recognising and Tracking Events on the
Web and in Real Life, Athens, Greece. 2010.
[GON] G. Gonzalez, C. Baral, M. Gelfond, Alan: An Action Language For Modelling Non-
Markovian Domains. Studia Logica 79(1): 115-134 (2005)
[LAM] M.V. Lambalgen, F. Hamm. The Proper Treatment of Events. Blackwell, Oxford and
Boston, 2004.
[LEV] Levesque H. J. , Pirri F., Reiter R., Foundations for the Situation Calculus. Electron.
Trans. Artif. Intell. 2: 159-178 (1998)
[LIN] Lin F., Reiter R, Rules as Actions: A Situation Calculus Semantics for Logic Programs.
J. Log. Program. 31(1-3): 299-330 (1997)
[MAJ] J. Ma, Ontological considerations of time, meta-predicates and temporal propositions.
Applied Ontology, vol. 2, pp. 37-66, 2007.
[MAN] I. Mani, B. Wellner, M. Verhagen, and J. Pustejovsky, Three approaches to learning
Tlinks in timeml, Technical Report, 2007.
[MEL] Francesco Mele, Antonio Sorgente, Giuseppe Vettigli, Designing and Building
Multimedia Cultural Stories Using Concepts of Film Theories and Logic Programming.
In Proceedings of Cognitive and Metacognitive Educational Systems (MCES)
symposium. pag 57-63. ISSN 1613-0073 Vol-598. 2010.
[MIL] R., Miller, M. Shanahan, The event-calculus in classical logic – alternative
axiomatizations. In Electronic Transactions on AI 3(1): 77-105. 1999
[PUS03] Pustejovsky, J.; Castaño, J.; Ingria, R.; Saurí, R.; Gaizauskas, R.; Setzer, A; G. Katz,
TimeML: A Specification Language for Temporal and Event Expressions. Netherlands,
Kluwer Academic Publishers. 2003.
[PUS08] J. Pustejovsky, K. Lee, H.B. Harry, B. Boguraev, and N. Ide, Language Resource
Management—Semantic Annotation Framework (SemAF)—Part 1: Time and events,
International Organization, 2008.
[SHO] Shoham, Y. Artificial Intelligence Techniques in Prolog. Morgan Kaufmann Publishers.
[SHE] Scherp, A. Franz, T.Saathoff, C., Staab, S., F--a model of events based on the
foundational ontology dolce+DnS ultralight, Proceedings of the fifth international
conference on Knowledge capture - K-CAP '09
[SYR] T. Syrjänen, Lparse 1.0 User’s Manual, http://www.tcs.hut.fi/Software/smodels/
[WAN] H.S. X. Wang, S. Mamadgi, A.Thekdi, A. Kelliher, Eventory - An Event Based Media
Repository, International Conference on Semantic Computing, 2007, pp. 95-102.
[WIN] T. Winkler, A. Artikis, Y. Kompatsiaris, and P. Milonas, eds., Workshop Recognising
and Tracking Events on the Web and in Real Life, Athens, Greece: 2010.