Documentation for an Entry Sub-Ontology of Time in OWL Feng Pan and Jerry R. Hobbs USC Information Sciences Institute Marina del Rey, California Outline DAML-Time (http://www.cs.rochester.edu/~ferguson/daml/) is an abstract ontology of time intended to be a complete specification of a theory of time as required for Semantic Web applications. Included in it is a rich collection of axioms that tightly constrain the interpretation of the the predicates and functions of the theory. But for most simple applications this is far more than is required, and its complexity constitutes a barrier to the use of the ontology. The purpose of this "entry sub-ontology" is to provide quick access to the essential vocabulary in OWL for the basic temporal concepts and relations. The entry sub-ontology can be found at http://www.isi.edu/~pan/damltime/time-entry.owl It covers topological relations among instants and intervals and instant-like and interval-like events, such as "before" and "overlaps". It includes measures for durations, so we can say a meeting will last 45 minutes. It includes clock and calendar terms, so we can say a meeting starts at 3:00pm on Monday, June 23, 2003. The most basic temporal concepts in this ontology are instant, interval, instant event, and interval event. TemporalEntity has only two subclasses: Instant and Interval. Event has only two subclasses: InstantEvent and IntervalEvent. InstantThing has only two subclasses: Instant and InstantEvent. IntervalThing has only two subclasses: Interval and IntervalEvent. TemporalThing has only two subclasses: InstantThing and IntervalThing. Thus, "IntervalThing" can describe both a meeting and the time span the meeting occupies. The class ProperInterval is intended to be the class of intervals whose beginning and end are distinct; it is disjoint with the class Instant. The class ProperIntervalThing is the class interval things whose beginning and end are distinct; it is disjoint with the class InstantThing. The basic topological temporal relations are "before", "after", "begins", "ends", and "inside". "Before" and "after" are relations between temporal things, whereas "begins", "ends", and "inside" are between instant things and temporal things. The relations between proper interval things are based on Allen's temporal interval calculus, and include intEquals, intBefore, intMeet, intOverlaps, intStarts, intDuring, intFinishes, intAfter, intMetby, intOverlappedBy, intContains, intFinishedBy, startsOrDuring, and nonoverlap. A temporal thing can have a "duration description". The DurationDescription class has the following datatype properties: years: number of years, at most one decimal number months: number of months, at most one decimal number weeks: number of weeks, at most one decimal number days: number of days, at most one decimal number hours: number of hours, at most one decimal number minutes: number of minutes, at most one decimal number seconds: number of seconds, at most one decimal number It's possible to have multiple descriptions for the same duration. For example, 1 day and 2 hours is the same duration as 26 hours. It is for this reason that there is a separate duration description object, rather than simply having these as properties of temporal things. The object property "durationDescriptionOf" is a relation between temporal things and duration descriptions. However, this may be more complicated than many users need. For this reason, we have also included a datatype property "durationDescriptionDataType", which is a relation between temporal things and the XML Schema datatype: duration. The user has the freedom to use either of these two properties/relations to specify a duration description for a temporal thing. "instantPairDurationDescriptionOf" and "instantPairDurationDescriptionDataType" are similar to above two relations. The only difference is that the domain of these two relations is "InstantThingPair", i.e. two instant things. With these two relations, given two instants, in order to talk about the duration between these two instants, one doesn't have to first creat a new interval with those two instants as the beginning and end of the interval. CalendarClockInterval is a subclass of ProperInterval, and the class CalendarClockDescription is used to specify the date and time of a temporal thing. It has the following properties: unitType: its temporal unit type, exactly one value of class TemporalUnit year: the year it is in, at most one value of a XML Schema gYear datatype month: the month it is in, at most one value of a XML Schema gMonth datatype week: the week of a year it is in, at most one nonnegative integer day: the day of a month it is in, at most one value of a XML Schema gDay datatype dayOfWeekField: the day of a week it is in, at most one nonnegative integer dayOfYearField: the day of a year it is in, at most one nonnegative integer hour: the hour it is in, at most one nonnegative integer minute: the minute it is in, at most one nonnegative integer second: the second it is in, at most one decimal number timeZone: the time zone it is in, linking to the time zone class in the time zone ontology at http://www.isi.edu/~pan/timezone/timezoneontology/timezone-ont.owl For example, the temporal unit type of 10:30 is minute (unitMinute), and the temporal unit type of March 20, 2003 is day (unitDay). The unit type is required. With a given temporal unit type, all the fields/properties for smaller units will be ignored. For instance, if the temporal unit type is day (unitDay), the values of the field/property hour, minute, and second, if present, will be ignored. The object property calendarClockDescriptionOf is a relation between a calendar-clock interval and a calendar-clock description, whereas the datatype property calendarClockDescriptionDataType is a relation between a calendar-clock interval and the XML Schema datatype: dateTime. The user has the freedom to use either of these two properties/relations to specify a calendar-clock description for a calendar-clock interval. The object property inCalendarClock is a relation between instant things and calendar-clock descriptions, whereas the datatype property inCalendarClockDataType is a relation between instant things and the XML Schema datatype: dateTime. The user has the freedom to use either of these two properties/relations to specify that an instant thing is in a calendar-clock interval; e.g. an instant, say the beginning of a meeting, can be 6:00pm. The OWL portions of the ontology are defined in the file http://www.isi.edu/~pan/damltime/time-entry.owl The OWL portions of the instances for the use case described below can be found at: http://www.isi.edu/~pan/damltime/time-entry-case1.owl Use Case Suppose someone has a telecon scheduled for 6:00pm EST on 11/05/03. You would like to make an appointment with him for 2:00pm PST on the same day, and expect the meeting to last 45 minutes. Will there be an overlap? In this use case we specify the facts about the meeting in the OWL ontology that will allow a temporal reasoner to determine whether there is a conflict. The namespaces used are as follows: ]> The description for the telecon can be written in OWL using this onotlogy as follows: 2003-11-05T18:00:00.000-5:00 2003 11 5 18 0 The description for the meeting can be written in OWL using this ontology as follows: PT45M 2003-11-05T14:00:00.000-8:00 2003 11 5 14 0 45