Representing time-dependent information has become increasingly important for reasoning and querying services defined on top of RDF and OWL. In particular, addressing this task properly is vital for practical applications such as modern biographical information systems, but also for the Semantic Web/Web 2.0/Social Web in general. Extending binary relation instances with temporal information often translates into a massive proliferation of useless container objects when trying to keep the underlying RDF model. In this paper, we argue for directly extending RDF triples with further arguments in order to easily represent time-dependent factual knowledge and to allow for practical forms of reasoning. We also report on a freely available lightweight OWL ontology for representing biographical knowledge that models entities of interest via a tri-partite structure of the pairwise disjoint classes Abstract, Object, and Happening. Even though the ontology was manually developed utilizing the Prote´ge´ ontology editor, and thus sticking to the triple model of RDF, the meta-modelling facilities allowed us to cross-classify all properties as being either synchronic or diachronic. When viewing the temporal arguments as “extra” arguments that only apply to relation instances, universal biographical knowledge from the ontology can still be described as if there is no time. Linguistics and philosophy make a distinction between synchronic and diachronic relations in order to characterize statements whose truth values do or do not change over time. Synchronic relations, such as dateOfBirth, are relations whose instances stay constant over time, thus there is no direct need to attach a temporal extent to them. Consider, e.g., the natural language sentence: Assuming a RDF-based N-triple representation (Carothers and Seaborne, 2014), an information extraction system might yield the following set of triples: tb rdf:type Person tb hasName ”Tony Blair” tb dateOfBirth ”1953-05-06”^^xsd:date Since there is only one unique date of birth, this works perfectly well and properly capture the intended meaning.
Diachronic relationships, however, vary with time, i.e., their truth value do change over time. Representation frameworks such as OWL that are geared towards unary and binary relations can not be extended directly by further (temporal) arguments. Consider the following biographical information:
Christopher Gent was Vodafone’s chairman until July 2003. Later, Chris became the chairman of GlaxoSmithKline with effect from January 1st, 2005. From these two sentences, the information extraction system might discover the following underspecified timedependent facts: Applying the synchronic representation schema for dateOfBirth from above would give us: However, the association between the original statements and their temporal extents get lost in the resulting RDF graph: as the second and third association are not supported by the above natural language quotation.
2
Several well-known proposals have been presented in the
literature in order to equip (binary) relation instances with
time or other kinds of information. The individual
rewriting schemas are depicted in Figure 1; see Welty and Fikes
(2006) and Krieger (2014) for a closer overview:
1. directly equip the relation instance
tional/temporal arguments
calculus
erty into a class
to quads
relation encoding by W3C
Fikes, 2006); approach 1 2 3 4 5 6 7 8 9 rewriting schema
marriedTo(p; p0; s; e) marriedTo(p; p0) 7 ! holds(marriedTo(p; p0); t) 7 ! 9f : holds(f; t) ^
type(f; Fluent) ^ subject(f; p) ^ predicate(f; marriedTo) ^ object(f; p0) marriedTo(p; p0; s; e) 7 ! 9e : type(e; MarriedToEvent) ^
person1(e; p) ^ person2(e; p0) ^ starts(e; s) ^ ends(e; e) marriedTo(p; p0; s; e) 7 ! 9i : i := marriedTo(p; p0) ^ starts(i; s) ^ ends(i; e) marriedTo(p; p0; s; e) 7 ! 9o : marriedTo(p; o) ^
type(o; PersonTime) ^ person(o; p0) ^ starts(o; s) ^ ends(o; e) marriedTo(p; p0; s; e) 7 ! 9t; t0 : marriedTo(t; t0) ^ type(t; TimeSlice) ^ hasTimeSlice(p; t) ^ type(t0; TimeSlice) ^ hasTimeSlice(p0; t0) ^ starts(t; s) ^ ends(t; e) ^ starts(t0; s) ^ ends(t0; e) marriedTo(p; p0; s; e) 7 ! 9t; t0 : marriedTo(t; t0) ^ type(t; Person) ^ hasTimeSlice(p; t) ^ type(t0; Person) ^ hasTimeSlice(p0; t0) ^ starts(p; s) ^ ends(p; e) ^ starts(p0; s) ^ ends(p0; e) marriedTo(p; p0; s; e) 7 ! marriedTo s e(p; p0) ^
marriedTo s e v marriedTo ^ starts(marriedTo s e; s) ^ ends(marriedTo s e; e) marriedTo(p; p0; s; e) 7 ! marriedTo(p; p0) ^ starts(p0; s) ^ ends(p0; e) 7. interpret the original entities as time slices (Krieger,
2008); 8. encode the temporal extent through new synthetic
properties
The above approaches are in a certain sense semantically
equivalent in that we can rewrite one approach to another
one without losing any information. It is worth noting that
all approaches invalidate standard OWL reasoning, even
though they can be implemented within the RDF
framework, and thus at least explicitly stated information can
be queried by, e.g., SPARQL engines. Nevertheless, the
non-temporal entailment rules for RDFS
Most of the above approaches require to rewrite the original ontology, sometimes by turning relations into classes. With the exception of approach 1, all approaches require to introduce one or even two brand-new individuals per time-dependent fact (see Figure 1). As a consequence, reasoning and querying with such representations is extremely complex, expensive, and error-prone. Furthermore, the representation schemas 2–7 bear the potential of a non-terminating closure computation in case the newly introduced individuals are viewed as existentially quantified, i.e., anonymous logic variables (RDF: blank nodes). Luckily, this last danger can often be avoided by generating unique URI names that are deterministically generated from their “parts” (i.e., from information that is accessible through properties from the new individual)—this “trick” reminds us of constructing perfect hash functions over complex objects, as known from computer science.
Approach 1 is pursued in the temporal database
community under the heading valid time
We would like to make our preference towards a direct representation of additional (temporal) arguments more clear by looking at concrete examples. Consider the Wikipedia entry for Tony Blair which says he married Cherie Booth on 29th March 1980 (today = 2015-05-08), leading to the quintuple representation: tony blair marriedTo cherie booth
”1980-03-29”^^xsd:date ”2015-05-08”^^xsd:date A meaning-preserving triple representation which adheres to a W3C best practice recommendation, called N-ary relation encoding (see rewrite schema 5 in Figure 1) would instead result in five triples, a new individual :ppt, a new type ValuePlusTime, and the three “accessor” properties hasValue, starts, and ends: tony blair marriedTo :ppt :ppt rdf:type nary:ValuePlusTime :ppt nary:hasValue cherie booth :ppt nary:starts ”1980-03-29”^^xsd:date :ppt nary:ends ”2015-05-08”^^xsd:date Such a representation has a three times larger memory footprint, a slightly more complex structure, and is a bit harder to read. However, as indicated above, the new individual (in our example blank node :ppt) might turn out to be problematic during entailment reasoning (no longer guaranteed to terminate).
Now let us focus not only on the representation of (static)
knowledge, but on the (dynamic) derivation of new
knowledge through entailment rules in order to see how much
worse a (recommended) triple representation becomes.
Consider the following entailment schema for functional
diachronic datatype properties (in Section 3.3, we will look
at the corresponding entailment schema for functional
diachronic object properties). The original non-temporal
schema looks like this (we use the rule syntax of HFC
Adding time to this rule schema makes it applicable to other functional relations such as hasSalary which do change over time, as indicated by the property characteristics time:DiachronicProperty in the rule below. Extending the rule schema is quite easy by equipping the fourth and fifth left hand side clauses with a temporal extent (things that have been added are underlined): ?p rdf:type owl:FunctionalProperty ?p rdf:type time:DiachronicProperty ?p rdf:type owl:DatatypeProperty ?x ?p ?y ?s1 ?e1 ?x ?p ?z ?s2 ?e2 ! ?x rdf:type owl:Nothing ?s ?e @test ?y != ?z IntersectionNotEmpty ?s1 ?e1 ?s2 ?e2 The additional left hand side four-place relation IntersectionNotEmpty from the @test section of the rule simply checks whether the two temporal intervals [s1; e1] and [s2; e2] have a non-empty intersection, indicated by xxx below:
p(x;y) jxxx————j p(x;z) j——xxxj ———s1—s2–e1———e2————. t If this is the case, we mark the subject bound to ?x being of type owl:Nothing (same as for the original rule), but this type assignment now only holds for the overlapping observation time, given by the maximum of the starting times (= ?s) and the minimum of the ending times (= ?e), as computed in the @action section of the rule.
The above natural extension of the non-temporal rule, however, turns into an awfully looking and terribly inefficient rule when being couched in a triple-based setting: ?p rdf:type owl:FunctionalProperty ?p rdf:type time:DiachronicProperty ?p rdf:type owl:DatatypeProperty ?x ?p ?blank1 ?blank1 rdf:type nary:ValuePlusTime ?blank1 nary:hasValue ?y ?blank1 nary:starts ?start1 ?blank1 nary:ends ?end1 ?x ?p ?blank2 ?blank2 rdf:type nary:ValuePlusTime ?blank2 nary:hasValue ?z ?blank2 nary:starts ?start2 ?blank2 nary:ends ?end2 ! ?x rdf:type ?new ?new rdf:type nary:ValuePlusTime ?new nary:hasValue owl:Nothing ?new nary:starts ?start ?new nary:ends ?end @test ?y != ?z IntersectionNotEmpty ?start1 ?end1 ?start2 ?end2 @action ?start = Max2 ?start1 ?start2 ?end = Min2 ?end1 ?end2 ?new = MakeUri owl:Nothing ?start ?end Note how the relevant input information is hidden in the two container individuals bound to ?blank1 and ?blank2 and how the output is wrapped in a brand-new individual ?new, generated by MakeUri from the @action section.
Several points are worth mentioning here. Firstly, we are not dealing here with duration time in order to resolve expressions like Monday or 20 days against valid time. This needs to be handled by a richer temporal ontology and temporal arithmetic.
Secondly, temporal quantification, such as four hours every week, needs to be addressed by a richer temporal inventory. Thirdly, even though underspecified time is handled by our implementation through wildcards in the XSD dateTime format (e.g., year missing in Over New Year’s Eve, I have visited the Eiffel Tower), we do not focus on this here. The solution requires to make certain rule tests sensitive to the fact that underspecified time is only partially ordered. These tests then return true, false, or don’t-know, whereas only true indicates that the test has succeeded, leading to the instantiation of the right hand side of the rule. Fourthly, coalescing temporal information (i.e., building larger intervals from intervals with overlapping parts) should be addressed in custom rules and should not be regarded as part of the extended RDFS/OWL rule set, since this functionality depends on the (semantic) nature of predicates and the assumption whether temporal intervals are convex (i.e., contain no “holes”) or not.
And finally, certain temporal inferences such as p(~x; s; t) entails p(~x; s0; t0) in case s s0 t0 t should not be handled in the below rules, since termination of the computation of the deductive closure is no longer guaranteed. Such information can only be obtained on the query level. 3
We already indicated that we favor approach 1 as it is the
most perspicuous of the nine approaches presented above,
shows the best memory and runtime footprint, and always
guarantees a terminating closure computation for extended
RDFS
In the introduction, we argued that axiomatic knowledge
about classes (TBox) and properties (RBox) does not need
to have a notion of time—this is universal knowledge which
we assume to be static. For instance, we do not assume that
the subtype relationship between two classes only holds for
some period of time or that an URI should be regarded as a
property at time t and as a class at a different time t0 (even
though this would be possible). The assertional knowledge
of an ontology (ABox), i.e., the set of relation instances,
however, is what we equip with time (see the various
approaches for the marriedTo example in Figure 1), as this is
knowledge that has undergone a temporal change.
In this section, we present the schema (the TBox and
the RBox) of an ontology that we had developed
originally for the TAKE project (http://take.dfki.de) and that was
used in the KOMPARSE project (http://komparse.dfki.de)
to represent biographical information about celebrities
pol:Person or constrain the domain and range of potentially underspecified properties, e.g.,
> v 8op:hasHolder . bio:Agent The property hasHolder from the opinion ontology (prefix op) is a good example of a property for which only the domain has been specified, viz., op:Opinion:
> v 8op:hasHolder . op:Opinion However, hasHolder consciously lacks its range, since this information should only be added when several ontologies are brought together.
The above axioms together with the two terminological axioms from the biography (prefix bio) and the politics (prefix pol) ontologies bio:Person v bio:Agent pol:Journalist v pol:Person guarantee to draw legal inferences, such as journalists are holders of opinions, even though the interface axiom above constrain holders of opinions to be of type bio:Agent. TMO has been assembled from 16 sub-ontologies, some of them also dealing with the representation of biographical knowledge, others describing concepts that can be found in politics and sociology. Especially the opinion ontology can be used to model provenance information, important for biographical knowledge; for instance, information about the: holder of the opinion: hasHolder; source from which the info was taken: extractedFrom; time when the opinion was published: utteredAt; trustworthiness of the holder: holdersTrust; polarity of the opinion: hasPolarity.
The TMO ontology suite is freely available for academic research and to other sites upon request (see http://www.dfki.de/lt/onto/). Parts of the taxonomic structure of the biography ontology is depicted in Figure 2.
TMO, and thus the biography ontology, implements several “guidelines” that we have found useful in many projects which have dealt with the representation of time-dependent knowledge (some of the arguments have already been presented): 1. model the TBox and RBox axioms of an ontology as if there is no time, since the ontology schema is regarded to be immutable; consequence: standard ontology editors, such as Prote´ge´ can be used for this task. 2. cross-classify all properties as being either synchronic or diachronic; advantage: these property characteristics can be used, amongst other things, as distinguishing marks in entailment rules (see examples). 3. populate the ABox of an ontology with extended relation instances, i.e., with quintuples whose fourth and fifth argument encode the temporal extent of the preceding atemporal statement (the triple). 4. extend the RDFS/OWL entailment rules by a temporal dimension; example: use XSD’s date or dateTime format to implement an interval-based calendar time (used by the examples in this paper). The biography ontology assumes a tri-partite structure, defining a most general class Entity, having pairwise disjoint subclasses Abstract, Happening, and Object. TMO is a lightweight ontology that consists of 146 classes and 80 properties, and is of expressivity S HIN (D), according to the Ontology metrics pane of Prote´ge´ , version 4.3.0. A partial view of the three subclasses and properties linking them is given in Figure 3.
Ontological categories that do not fit into Happening or Object are regarded to be of type Abstract, thus this class is a kind of “remainder” category. Abstract things can be used to describe literal concepts, e.g., activities, academic degrees, ideas, inventions, the life, or personal, professional, and social roles. An abstraction manifestsIn real-world happenings, whereas the outcome of a happening leadsTo virtually everything (= Entity). For example: a specific military activity (the invasion of Poland) manifested in World War II. The outcome of WW-II has led to military inventions (Abstract), has led to the Cold War (Happening), and has led to the building of 86 U2 aircrafts (Object).
Happenings are things that “happen” or “unfold” and are disjointly categorized as being either static atomic Situations or dynamic decomposable Events. They come with a (possibly underspecified) startDate and endDate. A happening is basedOn or leadsTo entities (i.e., either abstract things, further happenings, or concrete objects), thus these properties can be used to encode pre- and post-conditions of a happening. An instance of this class also involves Agents and happensAt a Location. Situations help to “terminate” the decomposition of a Happening. The other subclass Event can be used to model simple unordered processes, as it comes with three relational properties of its own, viz., startsWith, continuesWith, and endsWith, all mapping to Happening (see Figure 2). 3.2.3 Object Objects are “physical” things and mostly deal with Agents (an exhaustive disjoint partition between Person, Group, and political State) and other categories that we think are relevant for biographical information, e.g., Location, material Property, or WorkAndProduct. A Person isAwareOf a Happening: (s)he “owns” it, can be part of it, or learns about a happening. As isAwareOf is a diachronic property, awareness of a happening might even turn into oblivion.
For a larger non-trivial example, let us again turn our attention to the marriage of Tony Blair and Cherie Booth. marriedTo is at the same time a symmetric, a diachronic, a functional, and an object property (see the Types pane at the bottom of Figure 4).
We mentioned that we have cross-classified every property from the biography ontology as being either synchronic or diachronic and have already discussed the temporal extension of the entailment rule for functional diachronic datatype properties in Section 2.2. Let us now focus on the complementary rule for functional diachronic object properties which is applicable to the marriedTo relation: ?p rdf:type owl:FunctionalProperty ?p rdf:type time:DiachronicProperty ?p rdf:type owl:ObjectProperty ?x ?p ?y ?s1 ?e1 ?x ?p ?z ?s2 ?e2 Here, as in the former example, the additional left hand side test IntersectionNotEmpty checks whether the two temporal intervals [s1; e1] and [s2; e2] have a non-empty intersection. Assuming that a person is not married to more than one partner at the same time, such a rule is able to identify individuals/URIs bound to ?y and ?z for two properly overlapping observations through the use of owl:sameAs. Consider again the Wikipedia entry for the marriage of Tony Blair and Cherie Booth that we used in the example from Section 2.2: tony blair marriedTo cherie booth
”1980-03-29”^^xsd:date ”2015-05-08”^^xsd:date and furthermore assume that the Economist article The loneliness of Tony Blair from December 2014 mentioned that Cherie Blair is Blair’s wife (quintuple again): tony blair marriedTo cherie blair
”2014-12-20”^^xsd:date ”2014-12-20”^^xsd:date Now it is safe to assume that Cherie Booth and Cherie Blair are in fact the same person, according to the successful application of the above temporal entailment rule: cherie booth owl:sameAs cherie blair It is worth noting that sameAs statements will not be equipped with a temporal extent—commonsense dictates that once we do identify individuals, they will never fall apart.
At every moment in time, we never know how long a
person is married to his/her partner in advance. That is
why we introduced another property divorcedFrom,
being the temporal disjoint object property to marriedTo (see
the owl:disjointObjectProperty pane in Figure 4). As the
Economist article does not specify the date of marriage, we
better opt for a moment in time, when Blair and Booth were
definitely married (actually a day: start = end). Luckily,
the right hand side sameAs inference from above, together
with another extended OWL entailment rule, called rdfp11
”1980-03-29”^^xsd:date ”2015-05-08”^^xsd:date is a valid entailment, exactly what we expect. 3.4
So far, our approach has argued for a direct encoding of the temporal extent through two further arguments, turning a binary relation, such as marriedTo Person Person into a quaternary one: marriedTo Person Person date date. Given the original relation signature, the non-temporal entailment rule schema for symmetric binary relations from ter Horst (2005) thus leads to the following instantiation: marriedTo(p; p0) ! marriedTo(p0; p) as symmetric relations swap their domain and range arguments (p; p0 being two people).
Now, if we add time (b = begin; e = end), we obtain:1 marriedTo(i; j; b; e) ! marriedTo(j; b; e; i) Clearly, something has gone wrong here because symmetric relations assume the same number of arguments in domain and range position. One solution would be to reduplicate the starting and ending points, so we would end up in sexternary relation:
marriedTo(i; b; e; j; b; e) ! marriedTo(j; b; e; i; b; e) This is not an appealing solution as the structures become larger, and rules and queries are harder to formulate, read, debug, and process. What we would like to see is something like:
marriedTo(i; j; b; e) ! marriedTo(j; i; b; e) whereas the second semicolon should indicate that the additional temporal arguments are extra arguments, belonging to the relation instance as such (a kind of relation instance annotation, not possible in OWL). Thus with this idea in mind, we can still keep the idea of having only binary relations, without introducing any new identifier (contrary to the rewrite schemas 2–7 from Figure 1).
Nevertheless, we are not arguing against arbitrary n-ary relations as we are convinced that many binary relations in today’s ontologies are ignoring additional arguments (e.g., properties oriented towards ditransitive verbs or having additional modifiers/adjuncts) or come along with unsatisfactory means to encode the additional arguments (relation composition, by taking the object of a binary relation instance into account). The current biography ontology, for instance, poorly models the property obtains as a relation 1For better readability, we separate the domain and range arguments from one another by using a semicolon. between people and (academic) degrees. In order to obtain the educational organization where the degree was obtained, we employ relation composition at the moment, using an additional property obtainedAt between degree and education:
obtainedAt obtains Person EducationalOrganization This way of representing the additional argument is related to approach 9 from Figure 1 and only works because obtains is inverse functional (a characteristics applicable to properties in OWL). Ideally, obtains should be modeled as a quinternary relation, having one domain argument, two range arguments, and two extra temporal arguments: obtains Person
Degree EducationalOrganization xsd:dateTime xsd:dateTime // domain // range // extra In order to easily define such non-binary relations, ontology editors need to be extended by Cartesian types. In Krieger and Willms (2015), we described -Prote´ge´ , an extension of the Prote´ge´ ontology editor that provides means to define such Cartesian types and to use them to type the domain, range, and extra arguments of non-binary relations. A first public version of -Prote´ge´ will be available in mid 2015. 4
The approaches considered in Section 2 were investigated on how well they perform w.r.t. binary relations whose two arguments are considered to be obligatory. Such a kind of relation is the default case in today’s popular knowledge resources, such as YAGO, DBpedia, BabelNet, or Google’s Knowledge Graph.
In case more (e.g., time) and especially optional arguments
are investigated, our verdict concerning the different
approaches might turn into a different direction, so the
representation format needs to be updated (in the best case) or
changed (in the worst case). Consider the following
example, taken from
Jones buttered the toast in the bathroom with a knife at midnight.
The binary base relation butter (we assume a direct mapping of the transitive verb to the relation name here) now needs to be split and/or extended by further optional arguments, as the following sentences are perfectly legal: Jones buttered the toast.
Jones buttered the toast in the bathroom.
Jones buttered the toast with a knife.
Jones buttered the toast at midnight.
Jones buttered the toast in the bathroom with a knife. Jones buttered the toast in the bathroom at midnight. ..... etc.
In principle, the number of adjuncts is not bounded, thus adding a large number of potentially underspecified direct relation arguments is probably a bad solution. Today’s technologies often address such hidden arguments through a kind of relation composition as we have seen above for the obtains example from the last section and listed as approach 9 in Figure 1. We think that this modeling “trick” is unsatisfactory as it operates on the object of the binary relation instance, but not on the relation instance itself (besides being only correct if the original relation is inverse functional, as explained before).
Our personal solution would model the obligatory arguments, including (under- or unspecified) time and perhaps space, as direct arguments of the corresponding relation instance or tuple (approach 1). A further argument, an event identifier, also takes part in the relation. Optional arguments, however, would be addressed through binary relations, now working on the event argument. Applying this kind of Davidsonian or event representation to the above example gives us (informal relational notation): 9e : butter(e; Jones; toast; at midnight) ^
location(e; bathroom) ^ instrument(e; knife)
It is worth noting that two of the approaches from Figure 1
are related to such an event representation, viz., 3 and 4.
Approach 3 (internal reification) can be seen as a kind
of “owlfication” of Neo-Davidsonian semantics
”1980-03-29”^^xsd:date ”2015-05-08”^^xsd:date needs to be expressed by (we use VerbNet terminology): e rdf:type Marry e agent tony blair e co-agent cherie booth e starts ”1980-03-29”^^xsd:date e ends ”2015-05-08”^^xsd:date Approach 4 (fact identifier) is a kind of external reification. YAGO uses its own extension of the N3 plain triple format, called N4, which associate unique identifiers i with each time-dependent fact. However, the association i := marriedTo(p; p0) has the disadvantage of not being part of the triple repository, as it is a quadruple technically. So we guess that there exists a separate extendable mapping table outside of the semantic repository, storing the triples. Luckily, the biography ontology presented in Section 3 both allows for extended relation instances (as shown before), but also Davidsonian-like events through the class Happening and its subclasses Event and Situation (see Figure 2). As there does not exist a Marry event class so far (but only the marriedTo property), such a class needs to be introduced as a subclass of class Event, if needed.
5
Several ontologies addressing the representation of
biographical information, cultural heritage information, and
news-related information exist today, all building on
Description Logics and Semantic Web technology
standards. These include ESO
As we have indicated in the beginning of Section 3
(Journalist example), OWL axiom constructors and
domain/range restrictions allow us to manually interface
our biography ontology with other ontologies, may they
be complimentary domain ontologies (opinion, politics,
sociology), overlapping biography event ontologies (see
above), or even OWL versions of upper ontologies (if
desired), such as DOLCE+DnS
nsl:Event Connecting with LODE essentially reduces to: bio:Happening lode:Event bio:happensAt lode:atPlace bio:involves lode:involvedAgent bio:basedOn v lode:involved bio:leadsTo v lode:involved Other properties from LODE either do not have a direct counterpart (lode:illustrate) or need to be decomposed (lode:atTime onto bio:startDate and bio:endDate). The sub-properties bio:startsWith, bio:continuesWith, and bio:endsWith from the class bio:Event would even allow us to decompose LODE events into smaller units, a feature partially available in the SEM ontology: bio:startsWith v sem:hasSubEvent bio:continuesWith v sem:hasSubEvent bio:endsWith v sem:hasSubEvent As our ontology comes with the class bio:Happening, it is possible to take advantage of the great effort invested in the definition of event types in the ESO ontology. We finally note that some of the mappings are not expressible through simple OWL axiom constructors, because they involve a translation from n-ary relation instances to sets of triples (and vice versa). This would require to apply HFC migration rules, similar to the rewrite rule of approach 3 in Figure 1 which mediates between the quaternary marriedTo relation and its event representation MarriedToEvent. 6
In this paper, we have presented an overview of nine approaches to the representation of time-dependent knowledge and have favored the direct encoding of the temporal information as extra arguments of the original relation instance. Nevertheless, allowing at the same time for an event-based representation of situations, happening in the real world, is profitable as a knowledge engineer might choose the representation which fits her/his needs. For instance, a marriage ceremony between two people is probably modeled best as an event, whereas the fact that these two people are married for a specific time period is better represented as a quaternary relation. The lightweight biography ontology, presented in this paper, allows both views through the very general class Happening and relations defined between classes which are extended by a starting and ending time, expressing the temporal extent in which the atemporal fact is true (called valid time in temporal databases).
Our debate on the right representation format can even be
viewed as the more general quest on how to integrate/add
important (meta) information that has been neglected in the
past for practical matters, but has gained a lot of
attention recently; see the W3C recommendation for the
provenance data model PROV-DM
The work described in this paper has been partially carried out in the ALL SIDES project, funded by the German Federal Ministry of Education and Research under contract number FKZ 01IW14002 and the PHEME project, funded by the European Union’s 7th Framework Programme under grant agreement no 611233. The authors would like to thank our three reviewers and Antske Fokkens for their useful comments, Hans Uszkoreit for giving the initial impetus for the development of the biography ontology several years ago, and Bernd Kiefer for always having an open ear in many discussions.
7