The OWL-Time ontology is an OWL-2 DL ontology of temporal concepts, for describing the temporal properties of resources in the world or described in Web pages. The ontology provides a vocabulary for expressing facts about topological relations among instants and intervals, together with information about durations, and about temporal position including date-time information.

The namespace for OWL-Time terms is http://www.w3.org/2006/time#

The suggested prefix for the OWL-Time namespace is time

The (revised) OWL-Time ontology itself is available here.

The original OWL-Time ontology is still available there.

For OGC

This is a Public Draft of a document prepared by the Spatial Data on the Web Working Group (SDWWG) — a joint W3C-OGC project (see charter). The document is prepared following W3C conventions. The document is released at this time to solicit public comment.

Motivation and background

Temporal information is so common that it’s hard to find a real world Web service without it. For example, whenever you place an online order, the order date is always part of your order. When you reserve a car at a car rental site, you have to specify the dates you need it. In response to this need, a temporal ontology, OWL-Time, has been developed for describing the temporal content of Web pages, or the temporal properties of any resource denoted using a web identifier (URI), including real-world things if desired.

This document presents the OWL encodings of the ontology. For a first-order logic axiomatization of the ontology, see [HP-04].

This version of OWL-Time was developed in the Spatial Data on the Web Working Group (a joint activity involving W3C and the Open Geospatial Consortium). The ontology is based on the earlier draft by Hobbs and Pan, [OWL-T] incorporating modifications proposed by Cox [CO-15] to support more general temporal positions. The document has been completely re-written. The substantial changes are listed in the change-log.

Namespaces

The namespace for OWL-Time is http://www.w3.org/2006/time#. OWL-Time does not re-use elements from any other vocabularies, but does use some built-in datatypes from OWL and some additional types from XML Schema Part 2.

The table below indicates the full list of namespaces and prefixes used in this document.

Prefix Namespace
ex http://example.org/time/
geol http://example.org/geologic/
greg http://www.w3.org/ns/time-gregorian#
owl http://www.w3.org/2002/07/owl#
rdf http://www.w3.org/1999/02/22-rdf-syntax-ns#
rdfs http://www.w3.org/2000/01/rdf-schema#
time or
no prefix
http://www.w3.org/2006/time#
xsd http://www.w3.org/2001/XMLSchema#

Principles and vocabulary overview

Topological Temporal Relations

The basic structure of the ontology is based on an algebra of binary relations on intervals (e.g., meets, overlaps) developed by Allen and Ferguson [AL-84, AF-97] for representing qualitative temporal information, and to address the problem of reasoning about such information.

This is implemented in the ontology starting with a class :TemporalEntity which has properties that link to the temporal instants that define its beginning and end. There are two subclasses: :Interval and :Instant, and they are the only two subclasses of :TemporalEntity. Intervals are, intuitively, things with extent and instants are, intuitively, point-like in that they have no interior points, but it is generally safe to think of an instant as an interval with zero length, where the beginning and end are the same. The class :Interval has one subclass :ProperInterval, which corresponds with the common understanding of intervals, in that the beginning and end are distinct, and whose membership is therefore disjoint from :Instant. The class :ProperInterval has one subclass, :DateTimeInterval, whose position and extent may be expressed using a single :GeneralDateTimeDescription or xsd:dateTimeStamp.

UML-style diagram of temporal entity classes
Core model model of temporal entities.

Allen and Ferguson [AL-84, AF-97] have developed a calculus of binary relations on intervals (e.g., meets, overlaps) for representing qualitative temporal information and address the problem of reasoning about such information. The relations between intervals defined in their calculus can be defined in a relatively straightforward fashion in terms of :before and identityon the beginning and end points. The standard interval calculus assumes all intervals are proper, so their beginning and end are different.

Schematic of Interval Relations
Thirteen elementary possible relations between time periods [AF-97]. Two additional relations: In (the union of During, Starts and Finishes) and Disjoint (the union of Before and After) are not shown in the figure but are included in the ontology described below.

Temporal reference systems, clocks, calendars

The position of an Instant may be given using the datatype xsd:dateTimeStamp (or one of the truncated forms xsd:date, xsd:gYearMonth, xsd:gYear) which is built in to OWL 2 [OWL-2], and uses the conventional Gregorian calendar and 24-hour clock. While this satisfies most web applications, many other calendars and temporal reference systems are used in particular cultural and scholarly contexts. For example, the Julian calendar was used throughout Europe until the 16th century, and is still used for computing key dates in some orthodox Christian communities. Lunisolar (e.g. Hebrew) and lunar (e.g. Islamic) calendars are currently in use in some communities, and many similar have been used historically. In scientific and technical applications, Julian date counts the number of days since the beginning of 4713 BCE, and Loran-C, Unix and GPS time are based on seconds counted from a specified origin in 1958, 1970 and 1980, respectively. Archaeological and geological applications use chronometric scales based on years counted backwards from ‘the present’ (defined as 1950 for radiocarbon dating [RC-14]), or using named periods associated with specified correlation markers [CR-05, CR-14, MF-13]. Dynastic calendars (counting years within eras defined by the reign of a monarch or dynasty) were used earlier in many cultures. In order to support these more general applications, the representation of temporal position and duration must be flexible, and annotated with the temporal reference system in use.

A set of ordered intervals (e.g. named dynasties, geological periods, geomagnetic reversals, tree rings) can make a simple form of temporal reference system that supports logical reasoning, known as an ordinal temporal reference system [ISO-19108].

Measurement of duration needs a clock. In its most general form a clock is just a regularly repeating physical event ('tick') and a counting mechanism for the 'ticks'. These counts may be used to logically relate two events and to calculate a duration between the events.

A calendar is a set of algorithms that enables clock counts to be converted into practical everyday dates and times related to the movement of astronomical bodies (day, month, year).

For many purposes it is convenient to make temporal calculations in terms of clock durations that exceed everyday units such as days, weeks, months and years, using a representation of temporal position in a temporal coordinate system [ISO-19108], i.e. on a number line with a specified origin, such as Julian date, or Unix time. This may be converted to calendar units when necessary for human consumption.

Nevertheless, in practice much temporal information is not well-defined, in that there may be no clear statement about the assumed underlying calendar and clock.

Time position and time units

OWL 2 has two built-in datatypes relating to time: xsd:dateTime and xsd:dateTimeStamp [OWL-2]. Other XSD types such as xsd:date, xsd:gYear and xsd:gYearMonth [XSD-D] are also commonly used in OWL applications. These provide for a compact representation of time positions using the conventional Gregorian calendar and 24-hour clock, with timezone offset from UTC.

Four classes in the ontology support an explicit description of temporal position. :TemporalPosition is the common super-class, with a property :hasTRS to indicate the temporal reference system :TRS. :TimePosition has properties to alternatively describe the position using a number (i.e. a temporal coordinate), or a nominal value (e.g. geologic time period, dynastic name, archeological era). :GeneralDateTimeDescription has a set of properties to specify a date-time using calendar and clock elements. Its subclass :DateTimeDescription fixes the temporal reference system to the Gregorian calendar, so the :hasTRS property may be omitted on individuals from this class.

:TemporalUnit is a standard duration which indicates the granularity or precision of a time position.

UML-style diagram of classes for temporal position
Classes for temporal position.

Following the theoretical basis laid out by Allen and Ferguson [AL-84, AF-97], a time position has a finite extent, corresponding to the precision or temporal unit used. Thus, a :GeneralDateTimeDescription or :DateTimeDescription is strictly always a description of an interval, not an instant, with a duration corresponding to the value of its :unitType.

We use two different sets of properties for :GeneralDateTimeDescription or :DateTimeDescription and :GeneralDurationDescription or :DurationDescription, because their ranges are different. For example, :year (in :DateTimeDescription) has a range of xsd:gYear, while :years (in :GeneralDurationDescription) has a range of xsd:decimal so that you can say duration of 2.5 years.

Duration

The duration of an interval (or temporal sequence) can have many different descriptions. An interval can be 1 day 2 hours, or 26 hours, or 1560 minutes, and so on. It is useful to be able to talk about these descriptions in a convenient way as independent objects, and to talk about their equivalences. The extent of an interval can be given using multiple duration descriptions or individual durations (e.g., 2 days, 48 hours) , but these must all describe the same amount of time.

Four classes support the description of the duration of an entity. :TemporalDuration is the common super-class. :Duration has properties to describe the duration using a scaled number (i.e. a temporal quantity). :GeneralDurationDescription has a set of properties to specify a duration using calendar and clock elements, the definitions of which are given in the associated TRS description. Its subclass :DurationDescription fixes the temporal reference system to the Gregorian calendar, so the :hasTRS property may be omitted on individuals from this class.

:TemporalUnit is a standard duration which is used to scale a length of time.

UML representation of Temporal Duration and sub-classes
Classes for temporal duration.

Vocabulary specification

In this vocabulary specification, Manchester syntax [OWL-M] is used where the value of a field is not a simple term denoted by a URI or cURI.

Classes

:DateTimeDescription | :DateTimeInterval | :DayOfWeek | :Duration | :DurationDescription | :GeneralDateTimeDescription | :GeneralDurationDescription | :Instant | :Interval | :MonthOfYear | :ProperInterval | :TemporalDuration | :TemporalEntity | :TemporalPosition | :TemporalUnit | :TimePosition | :TimeZone

DateTimeDescription

RDFS Class: time:DateTimeDescription
Definition: Description of date and time structured with separate values for the various elements of a calendar-clock system. The temporal reference system is fixed to Gregorian Calendar, and the range of year, month, day properties restricted to corresponding XML Schema types xsd:gYear, xsd:gMonth and xsd:gDay, respectively.
Subclass of: time:GeneralDateTimeDescription
Subclass of: time:hasTRS value <http://www.opengis.net/def/uom/ISO-8601/0/Gregorian>
Subclass of: time:year only xsd:gYear
Subclass of: time:month only xsd:gMonth
Subclass of: time:day only xsd:gDay

Other datetime concepts can be defined by specialization of :DateTimeDescription - see examples below.

DateTimeInterval

RDFS Class: time:DateTimeInterval
Definition: time:DateTimeInterval is a subclass of time:ProperInterval, defined using the multi-element time:DateTimeDescription.
Subclass of: time:ProperInterval

The class :DateTimeInterval is a subclass of :ProperInterval, being an interval whose boundaries fall on the limits of a date-time description with truncated precision. Two properties :hasDateTimeDescription and :xsdDateTime provide alternative representations of the description of the interval.

Any :TemporalEntity has a duration, but only :DateTimeInterval can have :DateTimeDescription. For example, May 8 can be expressed as a :DateTimeDescription, but the interval from 1:30pm, May 8, to 1:30pm, May 9, cannot. Both have a duration of a day.

DayOfWeek

RDFS Class: time:DayOfWeek
Definition: The day of week
Instance of: owl:Class

Seven individual members of :DayOfWeek are included in the ontology, corresponding to the seven days used in the Gregorian calendar, and using the English names :Sunday, :Monday, :Tuesday, :Wednesday, :Thursday, :Friday, :Saturday.

Membership of the class :DayOfWeek is open, to allow for alternative week lengths and different day names.

Duration

RDFS Class: time:Duration
Definition: Duration of a temporal extent expressed as a number scaled by a temporal unit
Subclass of: :TemporalDuration
Subclass of: time:numericDuration exactly 1
Subclass of: time:unitType exactly 1

DurationDescription

RDFS Class: time:DurationDescription
Definition: Description of temporal extent structured with separate values for the various elements of a calendar-clock system. The temporal reference system is fixed to Gregorian Calendar, and the range of each of the numeric properties is restricted to xsd:decimal
Subclass of: time:GeneralDurationDescription
Subclass of: time:hasTRS value <http://www.opengis.net/def/uom/ISO-8601/0/Gregorian>
Subclass of: time:years only xsd:decimal
Subclass of: time:months only xsd:decimal
Subclass of: time:weeks only xsd:decimal
Subclass of: time:days only xsd:decimal
Subclass of: time:hours only xsd:decimal
Subclass of: time:minutes only xsd:decimal
Subclass of: time:seconds only xsd:decimal

Other duration concepts can be straightforwardly defined - see examples below.

GeneralDateTimeDescription

RDFS Class: time:GeneralDateTimeDescription
Definition: Description of date and time structured with separate values for the various elements of a calendar-clock system
Subclass of: :TemporalPosition
Subclass of: time:timeZone max 1
Subclass of: time:unitType exactly 1
Subclass of: time:year max 1
Subclass of: time:month max 1
Subclass of: time:day max 1
Subclass of: time:hour max 1
Subclass of: time:minute max 1
Subclass of: time:second max 1
Subclass of: time:week max 1
Subclass of: time:dayOfYear max 1
Subclass of: time:dayOfWeek max 1
Subclass of: time:monthOfYear max 1

Two properties :timeZone, and :unitType, along with :hasTRS provide for reference information concerning the reference system and precision of temporal position values.

Six datatype properties :year, :month, :day, :hour, :minute, :second, together with :timeZone support the description of components of a temporal position in a calendar-clock system. These correspond with the 'seven property model' described in ISO 8601 [ISO-8601] and XML Schema Definition Language Part 2: Datatypes [XSD-D], except that the calendar is not specified in advance, but is provided through the value of the :hasTRS property (defined above).

Two additional properties :week and :dayOfYear allow for the the numeric value of the week or day relative to the year.

The property :dayOfWeek provides the name of the day, and the property :monthOfYear provides the name of the month.

GeneralDurationDescription

RDFS Class: time:GeneralDurationDescription
Definition: Description of temporal extent structured with separate values for the various elements of a calendar-clock system.
Subclass of: :TemporalDuration
Subclass of: time:hasTRS exactly 1
Subclass of: time:years max 1
Subclass of: time:months max 1
Subclass of: time:weeks max 1
Subclass of: time:days max 1
Subclass of: time:hours max 1
Subclass of: time:minutes max 1
Subclass of: time:seconds max 1

Seven datatype properties :years, :months, :weeks, :days, :hours, :minutes, and :seconds support the description of components of a temporal extent in a calendar-clock system.

The property time:hasTRS indicates the temporal reference system applicable for the duration components.

Instant

RDF Class: time:Instant
Definition: A temporal entity with zero extent or duration
Subclass of: time:TemporalEntity

Seven properties, :inXSDDate, :inXSDDateTime (deprecated), :inXSDDateTimeStamp, :inXSDgYear, :inXSDgYearMonth, :inTimePosition, and :inDateTime provide alternative ways to describe the temporal position of an :Instant.

Interval

RDF Class: time:Interval
Definition: A temporal entity with an extent or duration
Subclass of: time:TemporalEntity

One property :inside links to an :Instant that falls inside the :Interval.

MonthOfYear

RDFS Class: time:MonthOfYear
Definition: The month of the year
Subclass of: time:DateTimeDescription
Subclass of: time:year exactly 0
Subclass of: time:month exactly 1
Subclass of: time:week exactly 0
Subclass of: time:day exactly 0
Subclass of: time:hour exactly 0
Subclass of: time:minute exactly 0
Subclass of: time:second exactly 0
Subclass of: time:unitType value time:unitMonth

Twelve individual members of :MonthOfYear are provided in separate namespace, corresponding to the twelve months used in the Gregorian calendar greg:January, greg:February, greg:March, greg:April, greg:May, greg:June, greg:July, greg:August, greg:September, greg:October, greg:November, greg:December. Each month is defined by setting the value of time:month to the corresponding value.

Membership of the class :MonthOfYear is open, to allow for alternative annual calendars and different month names.

ProperInterval

RDF Class: time:ProperInterval
Definition: A temporal entity with non-zero extent or duration, i.e. for which the value of the beginning and end are different
Subclass of: time:Interval
Disjoint with: time:Instant

Fifteen properties :intervalBefore, :intervalAfter, :intervalMeets, :intervalMetBy, :intervalOverlaps, :intervalOverlappedBy, :intervalStarts, :intervalStartedBy, :intervalDuring, :intervalContains, :intervalFinishes, :intervalFinishedBy, :intervalEquals :intervalDisjoint :intervalIn support the set of interval relations defined by Allen [AL-84] and Allen and Ferguson [AF-97].

TemporalDuration

RDF Class: time:TemporalDuration
Definition: Time extent; duration of a time interval separate from its particular start position
Instance of: owl:Class

TemporalEntity

RDF Class: time:TemporalEntity
Definition: A temporal interval or instant.
Instance of: owl:Class
Union of: time:Instant , time:Interval

Two properties, :before, :after, support ordering relationships between two :TemporalEntitys.

Two properties, :hasBeginning, :hasEnd, support the describing the bounds of a :TemporalEntity.

Two properties, :hasDuration, :hasDurationDescription, provide alternative ways to describe the extent of a :TemporalEntity.

One property :hasMember supports the inclusion of temporal entities in other resources.

TemporalPosition

RDF Class: time:TemporalPosition
Definition: A position on a time-line
Instance of: owl:Class
Subclass of: time:hasTRS exactly 1

The property time:hasTRS indicates the temporal reference system.

TemporalUnit

RDFS Class: time:TemporalUnit
Definition: A standard duration, which provides the scale factor for a time extent, or the granularity or precision for a time position.
Subclass of: time:TemporalDuration

Seven individual members of :TemporalUnit are included in the ontology, corresponding to the elements of the standard calendar-clock: :unitYear, :unitMonth, :unitWeek, :unitDay, :unitHour, :unitMinute and :unitSecond.

Membership of the class TemporalUnit is open, to allow for other temporal units used in some technical applications (e.g. millions of years, Baha'i month).

TimePosition

RDF Class: time:TimePosition
Definition: A temporal position described using either a (nominal) value from an ordinal reference system, or a (numeric) value in a temporal coordinate system.
Subclass of: :TemporalPosition
Subclass of: ( time:numericPosition exactly 1 ) or ( time:nominalPosition exactly 1 )

Two properties :nominalPosition and :numericPosition support the alternative descriptions of position or extent. One of these is expected to be present.

The temporal ordinal reference system should be provided as the value of the :hasTRS property

The temporal coordinate system should be provided as the value of the :hasTRS property

TimeZone

RDFS Class: time:TimeZone
Definition: A Time Zone is a geographic region that uses a clock with a specified offset from UTC. The region and offset are specified by the locally recognised governing authority.
Instance of: owl:Class

No specific properties are provided for the class :TimeZone, the definition of which is beyond the scope of this ontology. The class specified here is a stub, effectively the superclass of all time zone classes.

An ontology for time zone descriptions was described in [OWL-T] and provided as RDF in a separate namespace tzont:. However, that ontology was incomplete in scope, and the example datasets were selective. Furthermore, the use of a class from an external ontology as the range of an ObjectProperty in OWL-Time creates an undesirable dependency. Therefore, reference to the time zone class has been replaced with the 'stub' class in the normative part of this version of OWL-Time.

IETF and IANA also provide databases. These are well maintained, but individual iems are not available at individual URIs, i.e. not as "Linked Data".

The World Clock service provides a list of time zones, with the description of each available as an individual webpage with a convenient individual URI (e.g. https://www.timeanddate.com/time/zones/acwst. Currently this appears to offer best practice.

TRS

RDFS Class: time:TRS
Definition: A temporal reference system, such as a temporal coordinate system (with an origin, direction, and scale), a calendar-clock combination, or a (possibly hierarchical) ordinal system.
Instance of: owl:Class

No specific properties are provided for the class :TRS, the definition of which is beyond the scope of this ontology. The class specified here is a stub, effectively the superclass of all temporal reference system types.

Note that an ordinal temporal reference system, such as the geologic timescale, may be represented directly, using this ontology, as a set of :ProperIntervals, along with enough inter-relationships to support the necessary ordering relationships. See example below of Geologic Timescale.

A model and ontology for temporal reference system definitions is required. A taxonomy of temporal reference systems is provided in ISO 19108:2002 [ISO-19108], including (a) calendar + clock systems; (b) temporal coordinate systems (i.e. numeric offset from an epoch); (c) temporal ordinal reference systems (i.e. ordered sequence of named intervals, not necessarily of equal duration).

Properties

:after | :before | :day | :days | :dayOfWeek | :dayOfYear | :hasBeginning | :hasDuration | :hasDateTimeDescription | :hasDurationDescription | :hasEnd | :hasMember | :hasTemporalDuration | :hasTRS | :hour | :hours | :inside | :inTemporalPosition | :intervalAfter | :intervalBefore | :intervalContains | :intervalDisjoint | :intervalDuring | :intervalEquals | :intervalFinishedBy | :intervalFinishes | :intervalIn | :intervalMeets | :intervalMetBy | :intervalOverlappedBy | :intervalOverlaps | :intervalStartedBy | :intervalStarts | :inTimePosition | :inDateTime | :inXSDDate | :inXSDDateTime | :inXSDDateTimeStamp | :inXSDgYear | :inXSDgYearMonth | :minute | :minutes | :month | :monthOfYear | :months | :nominalPosition | :numericDuration | :numericPosition | :second | :seconds | :timeZone | :unitType | :week | :weeks | :xsdDateTime | :year | :years

after

RDF Property: time:after
Definition: Gives directionality to time. If a temporal entity T1 is after another temporal entity T2, then the beginning of T1 is after the end of T2.
Instance of: owl:ObjectProperty
Inverse Property: time:before

before

RDF Property: time:before
Definition: Gives directionality to time. If a temporal entity T1 is before another temporal entity T2, then the end of T1 is before the beginning of T2. Thus, before can be considered to be basic to instants and derived for intervals.
Instance of: owl:ObjectProperty
Domain: time:TemporalEntity
Range: time:TemporalEntity

day

RDF Property: time:day
Definition: Day position in a calendar-clock system. The range of this property is not specified, so can be replaced by any specific representation of a calendar day from any calendar.
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription

dayOfWeek

RDF Property: time:dayOfWeek
Definition: The day of week, whose value is a member of the class time:DayOfWeek
Instance of: owl:ObjectProperty
Domain: time:GeneralDateTimeDescription
Range: time:DayOfWeek

dayOfYear

RDF Property: time:dayOfYear
Definition: The number of the day within the year
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription
Range: xsd:nonNegativeInteger

days

RDF Property: time:days
Definition: length of a temporal extent expressed in days
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

hasBeginning

RDF Property: time:hasBeginning
Definition: Beginning of a temporal entity.
Instance of: owl:ObjectProperty
Domain: time:TemporalEntity
Range: time:Instant

hasDateTimeDescription

RDF Property: time:hasDateTimeDescription
Definition: Value of time:DateTimeInterval expressed as a structured value. The beginning and end of the interval coincide with the limits of the shortest element of the description.
Instance of: owl:ObjectProperty
Domain: time:DateTimeInterval
Range: time:GeneralDateTimeDescription

hasDuration

RDF Property: time:hasDuration
Definition: Duration of a temporal entity, expressed as a scaled value or nominal value
Instance of: owl:ObjectProperty
Subproperty of: time:hasTemporalDuration
Domain: time:TemporalEntity
Range: time:Duration

hasDurationDescription

RDF Property: time:hasDurationDescription
Definition: Duration of a temporal entity, expressed using a structured description
Instance of: owl:ObjectProperty
Subproperty of: time:hasTemporalDuration
Domain: time:TemporalEntity
Range: time:DurationDescription

hasEnd

RDF Property: time:hasEnd
Definition: End of a temporal entity.
Instance of: owl:ObjectProperty
Domain: time:TemporalEntity
Range: time:Instant

hasMember

RDF Property: time:hasMember
Definition: Supports the inclusion of temporal entities in other resources, such as temporal reference systems.
Instance of: owl:ObjectProperty
Range: time:TemporalEntity

hasTemporalDuration

RDF Property: time:hasTemporalDuration
Definition: Duration of a temporal entity
Instance of: owl:ObjectProperty
Domain: time:TemporalEntity
Range: time:TemporalDuration

hasTRS

RDF Property: time:hasTRS
Definition: The temporal reference system used by a temporal position or extent description.
Instance of: owl:ObjectProperty
Instance of: owl:FunctionalProperty
Range: time:TRS

hour

RDF Property: time:hour
Definition: Hour position in a calendar-clock system
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription
Range: xsd:nonNegativeInteger

hours

RDF Property: time:hours
Definition: length of a temporal extent expressed in hours
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

inDateTime

RDF Property: time:inDateTime
Definition: Position of an instant, expressed using a structured description
Instance of: owl:ObjectProperty
Subproperty of: time:inTemporalPosition
Domain: time:Instant
Range: time:GeneralDateTimeDescription

inside

RDF Property: time:inside
Definition: An instant that falls inside the interval. It is not intended to include beginnings and ends of intervals.
Instance of: owl:ObjectProperty
Domain: time:Interval
Range: time:Instant

inTemporalPosition

RDF Property: time:inTemporalPosition
Definition: Position of a time instant
Instance of: owl:ObjectProperty
Domain: time:Instant
Range: time:TemporalPosition

intervalAfter

RDF Property: time:intervalAfter
Definition: If a proper interval T1 is intervalAfter another proper interval T2, then the beginning of T1 is after the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
SubProperty of: time:after
SubProperty of: time:intervalDisjoint
Inverse of: time:intervalBefore

intervalBefore

RDF Property: time:intervalBefore
Definition: If a proper interval T1 is intervalBefore another proper interval T2, then the end of T1 is before the beginning of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
SubProperty of: time:before
SubProperty of: time:intervalDisjoint
Inverse of: time:intervalAfter

intervalContains

RDF Property: time:intervalContains
Definition: If a proper interval T1 is intervalContains another proper interval T2, then the beginning of T1 is before the beginning of T2, and the end of T1 is after the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalDuring

intervalDisjoint

RDF Property: time:intervalDisjoint
Definition: If a proper interval T1 is intervalDisjoint another proper interval T2, then the beginning of T1 is after the end of T2, or the end of T1 is before the beginning of T2, i.e. the intervals do not overlap in any way, but their ordering relationship is not known.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval

intervalDuring

RDF Property: time:intervalDuring
Definition: If a proper interval T1 is intervalDuring another proper interval T2, then the beginning of T1 is after the beginning of T2, and the end of T1 is before the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalContains

intervalEquals

RDF Property: time:intervalEquals
Definition: If a proper interval T1 is intervalEquals another proper interval T2, then the beginning of T1 is coincident with the beginning of T2, and the end of T1 is coincident with the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Disjoint with: time:intervalIn

intervalFinishedBy

RDF Property: time:intervalFinishedBy
Definition: If a proper interval T1 is intervalFinishedBy another proper interval T2, then the beginning of T1 is before the beginning of T2, and the end of T1 is coincident with the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalFinishes

intervalFinishes

RDF Property: time:intervalFinishes
Definition: If a proper interval T1 is intervalFinishes another proper interval T2, then the beginning of T1 is after the beginning of T2, and the end of T1 is coincident with the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
SubProperty of: time:intervalIn
Inverse of: time:intervalFinishedBy

intervalIn

RDF Property: time:intervalIn
Definition: If a proper interval T1 is intervalIn another proper interval T2, then the beginning of T1 is after the beginning of T2 or is coincident with the beginning of T2, and the end of T1 is before the end of T2 or is coincident with the end of T2, except that end of T1 may not be coincident with the end of T2 if the beginning of T1 is coincident with the beginning of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Disjoint with: time:intervalEquals

intervalMeets

RDF Property: time:intervalMeets
Definition: If a proper interval T1 is intervalMeets another proper interval T2, then the end of T1 is coincident with the beginning of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalMetBy

intervalMetBy

RDF Property: time:intervalMetBy
Definition: If a proper interval T1 is intervalMetBy another proper interval T2, then the beginning of T1 is coincident with the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalMeets

intervalOverlappedBy

RDF Property: time:intervalOverlappedBy
Definition: If a proper interval T1 is intervalOverlappedBy another proper interval T2, then the beginning of T1 is after the beginning of T2, the beginning of T1 is before the end of T2, and the end of T1 is after the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalOverlaps

intervalOverlaps

RDF Property: time:intervalOverlaps
Definition: If a proper interval T1 is intervalOverlaps another proper interval T2, then the beginning of T1 is before the beginning of T2, the end of T1 is after the beginning of T2, and the end of T1 is before the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalOverlappedBy

intervalStartedBy

RDF Property: time:intervalStartedBy
Definition: If a proper interval T1 is intervalStarted another proper interval T2, then the beginning of T1 is coincident with the beginning of T2, and the end of T1 is after the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
Inverse of: time:intervalStarts

intervalStarts

RDF Property: time:intervalStarts
Definition: If a proper interval T1 is intervalStarts another proper interval T2, then the beginning of T1 is coincident with the beginning of T2, and the end of T1 is before the end of T2.
Instance of: owl:ObjectProperty
Domain: time:ProperInterval
Range: time:ProperInterval
SubProperty of: time:intervalIn
Inverse of: time:intervalStartedBy

inTimePosition

RDF Property: time:inTimePosition
Definition: Position of an instant, expressed as a temporal coordinate or nominal value
Instance of: owl:ObjectProperty
Domain: time:Instant
Range: time:TimePosition
Subproperty of: time:inTemporalPosition

inXSDDate

RDF Property: time:inXSDDate
Definition: Position of an instant, expressed using xsd:date
Instance of: owl:DatatypeProperty
Domain: time:Instant
Range: xsd:date

inXSDDateTime

RDF Property: time:inXSDDateTime
Definition: Position of an instant, expressed using xsd:dateTime
Instance of: owl:DatatypeProperty
Domain: time:Instant
Range: xsd:dateTime
Deprecated: true

inXSDDateTimeStamp

RDF Property: time:inXSDDateTimeStamp
Definition: Position of an instant, expressed using xsd:dateTimeStamp, in which the time-zone field is mandatory
Instance of: owl:DatatypeProperty
Domain: time:Instant
Range: xsd:dateTimeStamp

(Was local Issue 8) time:inXSDDateTime uses xsd:dateTime which was available in OWL v1. The datatype xsd:dateTimeStamp, makes the timezone element mandatory instead of optional, was added in OWL2. Use of xsd:dateTimeStamp is recommended. time:inXSDDateTime is retained for backward-compatibility, but marked 'deprecated'. See SDWWG requirement 5.58 Update datatypes in OWL Time

inXSDgYear

RDF Property: time:inXSDgYear
Definition: Position of an instant, expressed using xsd:gYear
Instance of: owl:DatatypeProperty
Domain: time:Instant
Range: xsd:gYear

inXSDgYearMonth

RDF Property: time:inXSDgYearMonth
Definition: Position of an instant, expressed using xsd:gYearMonth
Instance of: owl:DatatypeProperty
Domain: time:Instant
Range: xsd:gYearMonth

minute

RDF Property: time:minute
Definition: Minute position in a calendar-clock system
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription
Range: xsd:nonNegativeInteger

minutes

RDF Property: time:minutes
Definition: length of a temporal extent expressed in minutes
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

month

RDF Property: time:month
Definition: Month position in a calendar-clock system. The range of this property is not specified, so can be replaced by any specific representation of a calendar month from any calendar.
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription

monthOfYear

RDF Property: time:monthOfYear
Definition: The month of the year, whose value is a member of the class time:MonthOfYear
Instance of: owl:ObjectProperty
Domain: time:GeneralDateTimeDescription
Range: time:MonthOfYear

months

RDF Property: time:months
Definition: length of a temporal extent expressed in months
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

nominalPosition

RDF Property: time:nominalPosition
Definition: The (nominal) value indicating temporal position in an ordinal reference system
Instance of: owl:DatatypeProperty
Domain: time:TimePosition
Range: xsd:string

numericDuration

RDF Property: time:numericDuration
Definition: Value of a temporal extent expressed as a number scaled by a temporal unit
Instance of: owl:DatatypeProperty
Domain: time:Duration
Range: time:Number

numericPosition

RDF Property: time:numericPosition
Definition: The (numeric) value indicating position within a temporal coordinate system
Instance of: owl:DatatypeProperty
Domain: time:TimePosition
Range: time:Number

second

RDF Property: time:second
Definition: Second position in a calendar-clock system.
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription
Range: xsd:decimal

seconds

RDF Property: time:seconds
Definition: length of a temporal extent expressed in seconds
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

timeZone

RDF Property: time:timeZone
Definition: The time zone for clock elements in the temporal position
Instance of: owl:ObjectProperty
Domain: time:GeneralDateTimeDescription
Range: time:TimeZone

unitType

RDF Property: time:unitType
Definition: The temporal unit which provides the precision of a date-time value or scale of a temporal extent
Instance of: owl:ObjectProperty
Domain: time:GeneralDateTimeDescription or time:Duration
Range: time:TemporalUnit

The property :unitType indicates the precision of a time position or duration, when that is expressed using :GeneralDateTimeDescription or :DateTimeDescription. Seven individual unitTypes are included in the ontology, corresponding to the conventional clock-calendar units.

week

RDF Property: time:week
Definition: The number of the week within the year
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription
Range: xsd:nonNegativeInteger

weeks

RDF Property: :weeks
Definition: length of a temporal extent expressed in weeks
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

xsdDateTime

How to use :xsdDateTime to describe a :DateTimeInterval is unclear at best, and appears to be untested. Propose deprecating it in the ontology, and removing it from the rec document.

RDF Property: time:xsdDateTime
Definition: Value of time:DateTimeInterval expressed as a compact value. The beginning and end of the interval coincide with the limits of the smallest non-zero element of the value.
Instance of: owl:DatatypeProperty
Domain: time:DateTimeInterval
Range: xsd:dateTime

(Was local Issue 7) Verify that this satisfies the SDWWG requirement 5.58 Update datatypes in OWL Time

year

RDF Property: time:year
Definition: Year position in a calendar-clock system. The range of this property is not specified, so can be replaced by any specific representation of a calendar year from any calendar.
Instance of: owl:DatatypeProperty
Domain: time:GeneralDateTimeDescription

years

RDF Property: time:years
Definition: length of a temporal extent expressed in years
Instance of: owl:DatatypeProperty
Domain: time:GeneralDurationDescription
Range: time:Number

Datatypes

:generalDay | :generalMonth | :generalYear | :Number

generalDay

RDFS Class: time:generalDay
Definition: Day of month - generalization of xsd:gDay, formulated as a text string with a pattern constraint to reproduce the same lexical form as xsd:gDay, except that values up to 99 are permitted, in order to support calendars with more than 31 days in a month. Note that the value-space is not defined, so a generic OWL2 processor cannot compute ordering relationships of values of this type.
Instance of: rdfs:Datatype
Subclass of:
owl:onDatatype xsd:string ;
  owl:withRestrictions (
    [
      xsd:pattern "---(0[1-9]|[1-9][0-9])(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?"^^xsd:string ;
    ]
  )

generalMonth

RDFS Class: time:generalMonth
Definition: Month of year - generalization of xsd:gMonth, formulated as a text string with a pattern constraint to reproduce the same lexical form as xsd:gMonth, except that values up to 20 are permitted, in order to support calendars with more than 12 months in the year. Note that the value-space is not defined, so a generic OWL2 processor cannot compute ordering relationships of values of this type.
Instance of: rdfs:Datatype
Subclass of:
owl:onDatatype xsd:string ;
  owl:withRestrictions (
    [
      xsd:pattern "--(0[1-9]|1[0-9]|20)(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?"^^xsd:string ;
    ]
  )

generalYear

RDFS Class: time:generalYear
Definition: Year number - generalization of xsd:gYear, formulated as a text string with a pattern constraint to reproduce the same lexical form as xsd:gYear. Note that the value-space is not defined, so a generic OWL2 processor cannot compute ordering relationships of values of this type.
Instance of: rdfs:Datatype
Subclass of:
owl:onDatatype xsd:string ;
  owl:withRestrictions (
    [
      xsd:pattern "-?([1-9][0-9]{3,}|0[0-9]{3})(Z|(\\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?"^^xsd:string ;
    ]
  )

Number

RDFS Class: time:Number
Definition: Generalized number
Instance of: rdfs:Datatype
Equivalent class: xsd:double or xsd:float or xsd:decimal

The datatype :Number provides for numbers expressed using any of the XSD types xsd:decimal (of which xsd:integer is a sub-type), xsd:float, or xsd:double (which allows exponential or scientific notation).

Individuals

:Friday | :Monday | :Saturday | :Sunday | :Thursday | :Tuesday | :Wednesday | :unitDay | :unitHour | :unitMinute | :unitMonth | :unitSecond | :unitWeek | :unitYear | greg:April | greg:August | greg:December | greg:February | greg:January | greg:July | greg:June | greg:March | greg:May | greg:November | greg:October | greg:September |

Class Individual
time:DayOfWeek time:Friday
time:Monday
time:Saturday
time:Sunday
time:Thursday
time:Tuesday
time:Wednesday
time:MonthOfYear greg:April
greg:August
greg:December
greg:February
greg:January
greg:July
greg:June
greg:March
greg:May
greg:November
greg:October
greg:September
time:TemporalUnit time:unitDay
time:unitHour
time:unitMinute
time:unitMonth
time:unitSecond
time:unitWeek
time:unitYear

Examples

DateTimeDescription vs dateTime

The following example illustrates the difference between using :DateTimeDescription and using the XML datatype xsd:dateTimeStamp. An instant that represents the start of a meeting, called ex:meetingStart, happens at 10:30am EST on 01/01/2006 can be expressed using both :inXSDDateTime and :inDateTime in OWL as:

ex:meetingStart
  a                    :Instant ;
  :inDateTime          ex:meetingStartDescription ;
  :inXSDDateTimeStamp  2006-01-01T10:30:00-5:00 .

ex:meetingStartDescription
  a           :DateTimeDescription ;
  :unitType   :unitMinute ;
  :minute     30 ;
  :hour       10 ;
  :day        "---01"^^xsd:gDay ;
  :dayOfWeek  :Sunday ;
  :dayOfYear  1 ;
  :week       1 ;
  :month      "--01"^^xsd:gMonth ;
  time:monthOfYear greg:January ;
  :timeZone   <https://www.timeanddate.com/time/zones/est> ;
  :year       "2006"^^xsd:gYear .

It is much more concise to use the XML Schema datatype xsd:dateTimeStamp. However, using :DateTimeDescription more information can be expressed, such as "week", "day of week" and "day of year", so in the example, on the first day of the year, and in the first week of the year, and we can also know that 01/01/2006 is Sunday and the month is January. Since, each field of :DateTimeDescription is separate it is easier to extract the value of some fields for the later use and easier to reason about.

The :timeZone property points to a definition of US Eastern Standard Time.

Use of temporal reference systems

The use of different temporal reference systems for the same absolute time is illustrated in the following examples. Abby's birthday is an :Instant whose position may be expressed using the conventional XSD xsd:dateTimeStamp type as 2001-05-23T08:20:00+08:00:

ex:AbbyBirthday
  a               :Instant ;
  :inDateTime     ex:AbbyBirthdayHebrew ;
  :inTimePosition ex:AbbyBirthdayUnix ;
  rdfs:label      "Abby's birthdate"^^xsd:string ;
  :inDateTime     ex:AbbyBirthdayGregorian ;
  :inXSDDateTime  "2001-05-23T08:20:00+08:00"^^xsd:dateTimeStamp ;
.

Using the :DateTimeDescription class, the elements of the date and time using the Gregorian Calendar are split out into separate properties:

ex:AbbyBirthdayGregorian
  a           	:DateTimeDescription ;
  :day        	"---23"^^xsd:gDay ;
  :dayOfWeek  	:Wednesday ;
  :dayOfYear 	"143"^^xsd:nonNegativeInteger ;
  :hour       	"8"^^xsd:nonNegativeInteger ;
  :minute     	"20"^^xsd:nonNegativeInteger ;
  :month      	"--05"^^xsd:gMonth ;
  :monthOfYear 	greg:May ;
  :timeZone   	<https://www.timeanddate.com/time/zones/awst> ;
  :unitType   	:unitMinute ;
  :year       	"2001"^^xsd:gYear ;
.

The :GeneralDateTimeDescription class may be used to express the same date using the Hebrew calendar:

ex:AbbyBirthdayHebrew
  a         	:GeneralDateTimeDescription ;
  :day      	"---01"^^:generalDay ;
  :hasTRS   	<http://dbpedia.org/resource/Hebrew_calendar> ;
  :month    	"--03"^^:generalMonth ;
  :monthOfYear 	ex:Sivan ;
  :year     	"5761"^^:generalYear ;
  :unitType 	:unitDay ;
.

The :TimePosition class may be used to express the same position in Unix time (also known as Posix time or Epoch time) (i.e. the number of seconds since the beginning of 1st January 1970):

ex:AbbyBirthdayUnix
  a                 :TimePosition ;
  :hasTRS           <http://dbpedia.org/resource/Unix_time> ;
  :numericPosition  990577200 ;
  rdfs:label        "Abby's birthdate in Unix time"^^xsd:string ;
.

Each of these examples refers to either a temporal reference system or time zone described externally, using its URI. RDF representations are available from DBPedia (e.g. http://dbpedia.org/resource/Unix_time) though these do not have specific time semantics.

The RDF representation of this example is available here.

Temporal precision

For the purposes of radiocarbon dating (which is the technique used in geological age determination for materials up to around 60,000 years old) 'the Present' is conventionally fixed at 1950 [RC-14]. This can be described as an individual :Instant, with its position expressed using any of the three alternatives:

geol:Present
  a :Instant ;
  :inDateTime [
    a :DateTimeDescription ;
    :unitType :unitYear ;
    :year "1950"^^xsd:gYear ;
  ] ;
  :inTimePosition [
    a :TimePosition ;
    :hasTRS <http://www.opengis.net/def/crs/OGC/0/ChronometricGeologicTime> ;
    :numericPosition "0.0"^^:Number ;
  ] ;
  :inXSDDateTime "1950-01-01T00:00:00Z"^^xsd:dateTimeStamp ;
  rdfs:label "The present"^^xsd:string ;
.

Expressed using ::DateTimeDescription the ::unitType - which determines the precision - is set to :unitYear, and only the :year element is provided in the value. The TRS value is not provided explicitly, as it is fixed in the ontology description to http://www.opengis.net/def/uom/ISO-8601/0/Gregorian.

In the :TimePosition variant, the TRS is given as http://www.opengis.net/def/crs/OGC/0/ChronometricGeologicTime which has units of millions of years, starting from the present, positive backwards.

For the value expressed using xsd:dateTimeStamp the position within the year is set arbitrarily to midnight at the beginning of 1st January. This level of precision is strictly spurious, but is required to satisfy the lexical pattern of the datatype.

iCalendar

iCalendar [DE-09] is a widely supported standard for personal data interchange. It provides the definition of a common format for openly exchanging calendaring and scheduling information across the Internet. The representation of temporal concepts in this time ontology can be straightforwardly mapped to iCalendar. For example, duration of 15 days, 5 hours and 20 seconds is represented in iCalendar as P15DT5H0M20S, which can be represented in the time ontology as:

:hasDurationDescription
  a         :DurationDescription ;
  :seconds  20 ;
  :hours    5 ;
  :days     15 .

The iCalendar homepage features the example of Abraham Lincoln's birthday as celebrated in 2008. This may be represented in multiple ways using OWL-Time, including the following.

As a :DateTimeInterval using the :DateTimeDescription form:

_:DTI-1
  rdf:type :DateTimeInterval ;
  dc:coverage """LOCATION:Hodgenville, Kentucky
    GEO:37.5739497;-85.7399606""" ;
  dc:date "2015-04-21T14:14:03.00"^^xsd:dateTimeStamp ;
  dc:description """Born February 12\\, 1809\\nSixteenth President (1861-1865)
    http://AmericanHistoryCalendar.com""" ;
  dc:subject "Civil War People" ;
  dc:subject "U.S. Presidents" ;
  rdfs:label "Abraham Lincoln" ;
  skos:closeMatch <2008-04-28-04-15-56-62-@americanhistorycalendar.com> ;
  :hasDateTimeDescription [
    rdf:type :DateTimeDescription ;
    :day "---12"^^xsd:gDay ;
    :hasTRS <http://www.opengis.net/def/uom/ISO-8601/0/Gregorian> ;
    :month "--02"^^xsd:gMonth ;
    :unitType :unitDay ;
    :year "2008"^^xsd:gYear ;
  ] ;
.

The boundaries of the interval are implicitly the beginning and end of the day specified in the :DateTimeDescription.

As a :DateTimeInterval using the :xsdDateTime form:

al:DTI-3
  rdf:type :DateTimeInterval ;
  rdfs:label "Abraham Lincoln" ;
  :xsdDateTime "2008-02-12T00:00:00.00-05:00"^^xsd:dateTimeStamp ;
.

In this formulation, the length of the entity is implicitly one day, as there is no sub-day value provided in the :xsdDateTime property.

As a :TemporalEntity using the :TimePosition to define the beginning and end:

_:TE-2
  rdf:type :TemporalEntity ;
  rdfs:label "Abraham Lincoln" ;
  :hasBeginning [
    rdf:type :Instant ;
    :inTimePosition [
      rdf:type :TimePosition ;
      :hasTRS <http://dbpedia.org/resource/Unix_time> ;
      :numericPosition "1202752800"^^:Number ;
    ] ;
  ] ;
  :hasDuration [
    rdf:type :Duration ;
    :numericDuration "1"^^:Number ;
    :unitType :unitDay ;
  ] ;
  :hasEnd [
    rdf:type :Instant ;
    :inTimePosition [
      rdf:type :TimePosition ;
      :hasTRS <http://dbpedia.org/resource/Unix_time> ;
      :numericPosition "1202839200"^^:Number ;
    ] ;
  ] ;
.

In this formulation, the length of the entity is explict, as the value of the :hasDuration property.

Several other formulations are possible, some of which are shown in the RDF representation is available here.

Geologic timescale

The geologic timescale is defined as a set of named intervals arranged in a hierarchy, such that there is only one subdivision of the intervals of each rank (e.g. 'Era') by a set of intervals of the next rank (in this case 'Period') [CR-05]. Since the relative ordering is well-defined this graph can therefore serve as an ordinal temporal reference system. Fig. 5 shows how the geologic timescale can be expressed as a set of :ProperIntervals related to each other using only :intervalMetBy, :intervalStartedBy, :intervalFinishedBy. Many other interval relationships follow logically from the ones shown (for example 'Neogene Period' :intervalDuring 'Cenozoic Era') but the ones shown are sufficient to describe the full topology.

(Part of) the international chronostratigraphic chart, formalized as a set of proper intervals
Part of the geologic timescale formalized as ProperIntervals, with ordering relationships described using the predicates defined in this ontology.

For example, the 'Archean Eon' is a :ProperInterval described as follows:

geol:Archean
  rdf:type            :ProperInterval ;
  :hasBeginning       geol:BaseArchean ;
  :hasEnd             geol:BaseProterozoic ;
  :intervalMeets      geol:Proterozoic ;
  :intervalMetBy      geol:Hadean ;
  rdfs:label          "Archean Eon"^^xsd:string ;
.

The beginning of the Archean Eon is an :Instant, described as follows:

geol:BaseArchean
  rdf:type :Instant ;
  :inTimePosition [
    rdf:type          :TimePosition ;
    :hasTRS           <http://www.opengis.net/def/crs/OGC/0/ChronometricGeologicTime> ;
    :numericPosition  "4000"^^:Number ;
  ] ;
  rdfs:label "Base of Archean Eon"^^xsd:string ;
. 

Note that the position of this :Instant is specified using a :TimePosition, which is a numeric value relative to the temporal coordinate system indicated as the value of the :hasTRS property.

The RDF representation of this example is available here.

A Use Case for Scheduling

Suppose someone has a telecon scheduled for 6:00pm EST on November 5, 2006. 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 can specify the facts about the telecon and the meeting using our ontology in OWL that will allow a temporal reasoner to determine whether there is a conflict:

ex:telecon
  a             :Interval ;
  :hasBeginning ex:teleconStart .

ex:meeting
  a                       :Interval ;
  :hasBeginning           ex:meetingStart ;
  :hasDurationDescription ex:meetingDuration .

ex:teleconStart
  a               :Instant ;
  :inXSDDateTime  "2006-11-05T18:00:00-5:00"^^xsd:dateTimeStamp .

ex:meetingStart
  a               :Instant ;
  :inXSDDateTime  "2006-11-05T14:00:00-8:00"^^xsd:dateTimeStamp .

ex:meetingDuration
  a         :DurationDescription ;
  :minutes  45 .

The telecon and the meeting are defined as intervals. :hasBeginning is used for specifying the start times of the meetings. The datetimes are specified using :inXSDDateTime. The duration of the meeting is specified using the :DurationDescription class.

Web commerce applications

Congo.com and Bravo Air are examples from the OWL-S 0.9 draft release [OWL-S]. Congo.com is a fictitious book-selling service site, and Bravo Air is a fictitious airline-ticketing service site. These examples demonstrate how the time ontology can be used to support OWL-S, including use cases for defining input parameters and (conditional) output parameters.

Input Parameters

In the profile of the Congo.com example (i.e. CongoProfile.owl), for example, our time ontology is currently used for describing the input parameter CreditCardExpirationDate:

profile:CreditCardExpirationDate
  a                     profile:ParameterDescription ;
  profile:parameterName ex:creditCardExpirationDate ;
  profile:restrictedTo  :Instant ;
  profile:referTo       congoProcess:creditCardExpirationDate .

In this example :Instant is used to describe CreditCardExpirationDate, because the expiration date is actually an instant -- the midnight, of the day the credit card expires.

In the Bravo Air example, our time ontology can be used to describe the existing input parameters, DepartureDate and ArrivalDate. We will change this to the more appropriate DepartureTime and ArrivalTime. We can define DepartureTime in the profile of the Bravo Air example (i.e. BravoAirProfile.owl) as:

profile:DepartureTime
  a                     profile:ParameterDescription ;
  profile:parameterName ex:DepartureTime ;
  profile:restrictedTo  :Instant ;
  profile:referTo       ba_process:outboundDate_In .

DepartureTime is defined as :Instant. With this definition, as we discussed in the previous datetime description section, an instance of DepartureTime can has either an :inXSDDateTime property/relation pointing to a specific value of XML Schema datatype dateTime, say 2006-01-01T10:30:00-5:00, or an :inDateTime object-property/relation pointing to an instance of :DateTimeDescription class specifying a specific time, say 10:30am EST on 01/01/2006, Sunday. It would be the user’s decision to define the time in either way based on the trade-offs discussed in the previous section.

(Conditional) Output Parameters

In fact, there is much more that our time ontology can do to support OWL-S. In the Congo.com and Bravo Air examples, the time ontology is not used for any output parameters. However, in the real world many service outputs are time-related. For example, in the Congo.com example we can add two outputs that are very common in real world book-selling sites: process time and delivery duration.

Adding a ProcessTime output parameter

ProcessTime is a conditional output parameter that specifies how long before the book will be ready for delivery, say, 24 hours, which depends on whether the book is in stock. In this use case, the process time is returned only if the book is in stock. It can be defined in the process model of the Congo.com example (i.e. CongoProcess.owl) as:

ex:ProcessTime
  a               owl:Class ;
  rdfs:subClassOf :Interval ;
.

ex:fullCongoBuyProcessTime
  a                   rdf:Property ;
  rdfs:subPropertyOf  process:output ;
  rdfs:domain         ex:FullCongoBuy ;
  rdfs:range       
    [ a               owl:Class ;
      rdfs:subClassOf process:ConditionalOutput ;
      rdfs:subClassOf 
        [ a                 owl:Restriction ;
          owl:allValuesFrom ex:BookInStock ;
          owl:onProperty    process:coCondition
        ] ;
    ] ;
  rdfs:subClassOf
    [ a                 owl:Restriction ;
      owl:allValuesFrom ex:ProcessTime ;
      owl:onProperty    process:coOutput
    ] ;
.

ProcessTime is defined as an interval, rather than a duration. As discussed previously, in our time ontology durations are properties of intervals. Thus to talk about a duration, i.e. a quantity of time, an interval must be defined first. This approach may look roundabout at first glance. However, the process time is not purely a quantity of time; it has a location on the time line. The beginning of the process time is the time the user places the order, and the end of the process time is the time the order is shipped out. An advantage of defining ProcessTime as an interval is that if the relationship among the order time, the shipping time, and the process time is known, any one of them (e.g. the shipping time) can be computed from the other two (e.g. the order time and the process time) by temporal arithmetic.

Adding a DeliveryDuration output parameter

DeliveryDuration is a conditional output parameter that specifies how long it will take for the customer to receive the book after it is shipped out, which depends on the delivery type the customer selects. As defined in the process model of the Congo.com example (i.e. CongoProcess.owl), the current delivery types are FedExOneDay, FedEx2-3day, UPS, and OrdinaryMail.

To add this output parameter may seem similar to the above ProcessTime example. However, since an instance of Condition is a logical formula that evaluates to true or false (see the comment with the definition of Condition [PR-OS]), DeliveryType cannot be directly used as a condition to determine the delivery duration. Thus one property and one condition are defined for each delivery type.

DeliveryDuration is defined with two boundaries: one minDeliveryDuration and one maxDeliveryDuration. For example, an order with the FedEx2-3day delivery type takes 2 to 3 days, so its min delivery duration is 2 days, and its max delivery duration is 3 days. For the delivery duration of the order with FedExOneDay delivery type, the min and max delivery duration will both be 1 day. We can define DeliveryDuration in the process model of the Congo.com example (i.e. CongoProcess.owl) as:

ex:DeliveryDuration
  a       owl:Class ;
  rdfs:subClassOf
    [ a               owl:Restriction ;
      owl:cardinality 1 ;
      owl:onProperty  ex:maxDeliveryDuration
    ] ;
  rdfs:subClassOf
    [ a               owl:Restriction ;
      owl:cardinality 1 ;
      owl:onProperty  ex:minDeliveryDuration
    ] .

ex:maxDeliveryDuration
  a           rdf:Property ;
  rdfs:domain ex:DeliveryDuration ;
  rdfs:range  :Interval .

ex:minDeliveryDuration
  a           rdf:Property ;
  rdfs:domain ex:DeliveryDuration ;
  rdfs:range  :Interval .

Both minDeliveryDuration and maxDeliveryDuration are defined as properties of DeliveryDuration. For the same reason discussed for the process time example, both properties use Interval as their ranges. The cardinality of 1 for both properties in the definition of DeliveryDuration indicates that an instance of DeliveryDuration must have one and only one property value for minDeliveryDuration and maxDeliveryDuration respectively. For example, in order to define delivery duration for FedEx2-3day, we have to first define a condition of FedEx2-3day being selected:

ex:FedEx2-3dayCondition
  a               owl:Class ;
  rdfs:subClassOf process:Condition .

Then we define an output property, called deliverySelectFedEx2-3day that is conditional on FedEx2-3dayCondition defined above:

ex:deliverySelectFedEx2-3day
  a                   rdf:Property ;
  rdfs:subPropertyOf  process:output ;      
  rdfs:domain         ex:SpecifyDeliveryDetails ;
  rdfs:range 
    [ a               owl:Class ;
      rdfs:subClassOf process:ConditionalOutput ;
      rdfs:subClassOf
        [ a                 owl:Restriction ;
          owl:allValuesFrom ex:FedEx2-3dayDuration ;
          owl:onProperty    process:coOutput
        ] ;
      rdfs:subClassOf
        [ a                 owl:Restriction ;
          owl:allValuesFrom ex:FedEx2-3dayCondition ;
          owl:onProperty    process:coCondition
        ] ;
    ] .

This definition says that deliverySelectFedEx2-3day is a conditional output, and if FedEx2-3dayCondition is true, an instance of FedEx2-3dayDuration class will be the output. FedEx2-3dayDuration is not defined yet. In order to define it, we have to define its min delivery duration, i.e. 2 days, and max delivery duration, i.e. 3 days. Since the range of minDeliveryDuration and maxDeliveryDuration is :Interval, intervals with specific durations need to be created first. For FedEx2-3dayDuration, we need to define Interval2Days and Interval3Days first as follows:

ex:Interval2Days
  a               owl:Class ;
  rdfs:subClassOf :Interval ;
  rdfs:subClassOf
    [ a               owl:Restriction ;
      owl:hasValue    P2D ;
      owl:onProperty  :durationDescriptionDataType
    ] .

ex:Interval3Days
  a               owl:Class ;
  rdfs:subClassOf :Interval ;
  rdfs:subClassOf
    [ a               owl:Restriction ;
      owl:hasValue    P3D ;
      owl:onProperty  :durationDescriptionDataType
    ] .

These two definitions use durationDescriptionDataType, a relatively simpler duration property of :Interval using the XML Schmea datatype xsd:duration as its range. P2D and P3D are values of the XML Schema datatype xsd:duration, meaning 2 days and 3 days.

Finally, FedEx2-3dayDuration restricts the value of minDeliveryDuration and maxDeliveryDuration to class Interval2Days and Interval3Days respectively as follows:

ex:FedEx2-3dayDuration
  a               owl:Class ;
  rdfs:subClassOf ex:DeliveryDuration ;
  rdfs:subClassOf
    [ a                 owl:Restriction ;
      owl:allValuesFrom ex:Interval3Days ;
      owl:onProperty    ex:maxDeliveryDuration
    ] ;
  rdfs:subClassOf
    [ a                 owl:Restriction ;
      owl:allValuesFrom ex:Interval2Days ;
      owl:onProperty    ex:minDeliveryDuration
    ] .

Properties to output delivery durations when the user selects other delivery types (FedExOneDay, UPS, and OrdinaryMail) can be defined similarly.


Summary of Classes and Properties in the Time Ontology

Classes (subclass relations)

Properties (sorted by domain value)

Property Name Domain Range
:before :TemporalEntity :TemporalEntity
:after :TemporalEntity :TemporalEntity
:hasBeginning :TemporalEntity :Instant
:hasEnd :TemporalEntity :Instant
:hasTemporalDuration :TemporalEntity :TemporalDuration
:hasDuration :TemporalEntity :Duration
:hasDurationDescription :TemporalEntity :GeneralDurationDescription
:inside :Interval :Instant
:intervalEquals :ProperInterval :ProperInterval
:intervalAfter :ProperInterval :ProperInterval
:intervalBefore :ProperInterval :ProperInterval
:intervalDisjoint :ProperInterval :ProperInterval
:intervalMeets :ProperInterval :ProperInterval
:intervalMetBy :ProperInterval :ProperInterval
:intervalOverlaps :ProperInterval :ProperInterval
:intervalOverlappedBy :ProperInterval :ProperInterval
:intervalStarts :ProperInterval :ProperInterval
:intervalStartedBy :ProperInterval :ProperInterval
:intervalIn :ProperInterval :ProperInterval
:intervalContains :ProperInterval :ProperInterval
:intervalDuring :ProperInterval :ProperInterval
:intervalFinishes :ProperInterval :ProperInterval
:intervalFinishedBy :ProperInterval :ProperInterval
:hasDateTimeDescription :DateTimeInterval :GeneralDateTimeDescription
:xsdDateTime (deprecated) :DateTimeInterval xsd:dateTime
:inTemporalPosition :Instant :TemporalPosition
:inTimePosition :Instant :TimePosition
:inDateTime :Instant :GeneralDateTimeDescription
:inXSDDate :Instant xsd:date
:inXSDDateTime (deprecated) :Instant xsd:dateTime
:inXSDDateTimeStamp :Instant xsd:dateTimeStamp
:inXSDgYearMonth :Instant xsd:gYearMonth
:inXSDgYear :Instant xsd:gYear
:numericDuration :Duration :Number
:years :GeneralDurationDescription :Number
:months :GeneralDurationDescription :Number
:weeks :GeneralDurationDescription :Number
:days :GeneralDurationDescription :Number
:hours :GeneralDurationDescription :Number
:minutes :GeneralDurationDescription :Number
:seconds :GeneralDurationDescription :Number
:numericPosition :TimePosition :Number
:nominalPosition :TimePosition xsd:string
:timeZone :GeneralDateTimeDescription :TimeZone
:unitType :GeneralDateTimeDescription :TemporalUnit
:year :GeneralDateTimeDescription
:month :GeneralDateTimeDescription
:day :GeneralDateTimeDescription
:hour :GeneralDateTimeDescription xsd:nonNegativeInteger
:minute :GeneralDateTimeDescription xsd:nonNegativeInteger
:second :GeneralDateTimeDescription xsd:decimal
:week :GeneralDateTimeDescription xsd:nonNegativeInteger
:dayOfYear :DateTimeDescription xsd:nonNegativeInteger
:dayOfWeek :DateTimeDescription :DayOfWeek
:monthOfYear :DateTimeDescription :MonthOfYear
:hasTRS :TemporalPosition or :GeneralDurationDescription :TRS
:hasMember :TemporalEntity

Datatypes

Changes from previous versions

This version of OWL-Time was developed in the Spatial Data on the Web Working Group (a joint activity involving W3C and the Open Geospatial Consortium). The Ontology is based on the one described in the 2006 Draft are [OWL-T] though the document has been completely re-written. The principal technical changes are as follows:

Response to Requirements identified in working group analysis

A number of requirements relating to Time were identified in the Spatial Data on the Web Use Cases & Requirements.

The following notes indicate where these have been addressed. (TBC)

(Was local Issue 1) Most of the properties defined in the original ontology have global constraints on the domain and range. If the rdfs:domain were left unspecified, the properties could be used more widely without undesirable entailments. Their use in the context of the classes in the ontology is adequately controlled through guarded restrictions (local cardinality constraints) - superseded by ISSUE-65

(Was local Issue 2) The Time ontology is concerned only with formalizing temporal intervals and instants, and does not include any predicates to tie temporal objects to spatial entities or features, or other things. The editors note that predicates that concern temporal behaviour and properties will usually be part of an application or associated with a community of practice. Nevertheless, there may be some generic predicates that could be conveniently provided as part of the generic time ontology. Some may already exist in the ontology (:before, :after, :hasEnd, :hasBeginning, :intervalEquals ) but their rdfs:domain is :TemporalEntity or :ProperInterval, so this may need to be generalized to avoid inappropriate entailments. Else predicates with similar names could be provided for linking to other entities.

The SDWWG requirement 5.56 Valid time relates to ISSUE-65.

(Was local Issue 3) Temporal vagueness requirement. Extended Data/Time Format (EDTF) is a detailed proposal for how to encode temporal vagueness, and some other concerns, by extending the xsd:dateTime syntax . The editors consider that would be the wrong direction since it would make the encoding inconsistent with all XSD-based processors. On the other hand, specific RDF properties matching the ones proposed in EDTF could be used to make it amenable to RDF reasoning. However, it could be done in a separate namespace. Note that some of the concerns in EDTF are already accommodated in OWL-Time (e.g. 'unspecified' appears to only require the timeUnit to be chosen appropriately).

The SDWWG requirement 5.49 Temporal vagueness relates to ISSUE-26.

The classes :GeneralDateTimeDescription, :DateTimeDescription, :TimePosition address the 'date' and 'time' requirement from 5.7 Date, time and duration

The classes :GeneralDurationDescription, :DurationDescription, :Duration address the 'duration' requirement from 5.7 Date, time and duration

The class :TRS and property :hasTRS addresses the following requirements from the SDWWG: 5.9 Different time models, 5.48 Temporal reference system, 5.28 Nominal temporal references.

(Was local Issue 4) Past, present future - this appears to already be supported using capabilities in OWL-Time, but needs to be verified.

The SDWWG requirement 5.25 Multilingual support relates to the documentation of the ontology.

References

[AF-97]
Allen, J. F. and Ferguson, G. 1997. Actions and events in interval temporal logic. In: Spatial and Temporal Reasoning. O. Stock, ed., Kluwer, Dordrecht, Netherlands, pp. 205-245. doi:10.1007/978-0-585-28322-7_7
[AL-84]
Allen, J. F. 1984. Towards a general theory of action and time. Artificial Intelligence 23, pp. 123-154. doi:10.1016/0004-3702(84)90008-0
[CO-15]
Cox, S. J. D. 2015. Time Ontology Extended for Non-Gregorian Calendar Applications. Semantic Web Journal 7, pp. 201-209 doi:10.3233/SW-150187
[CR-05]
S.J.D. Cox, S.M. Richard, A formal model for the geologic time scale and global stratotype section and point, compatible with geospatial information transfer standards. Geosphere 1 (2005) 119. doi:10.1130/GES00022.1.
[CR-14]
S.J.D. Cox, S.M. Richard, A geologic timescale ontology and service, Earth Sci. Informatics. 8 (2014) 5–19. doi:10.1007/s12145-014-0170-6.
[DE-09]
Desruisseaux, B. 2009. Internet Calendaring and Scheduling Core Object Specification (iCalendar), RFC5545. http://www.ietf.org/rfc/rfc5545.txt
[FIPS]
FIPS 55 County instance file. http://www.daml.org/2003/02/fips55/
[HP-04]
Hobbs, J. R. and Pan, F. 2004. An Ontology of Time for the Semantic Web. ACM Transactions on Asian Language Processing (TALIP): Special issue on Temporal Information Processing, 3, No. 1, March 2004, pp. 66-85. doi:10.1145/1017068.1017073
[ISO-19108]
ISO 19108:2002 Geographic information -- Temporal schema. http://www.iso.org/iso/iso_catalogue/catalogue_detail?csnumber=26013
[ISO-8601]
ISO 8601:2004 Data elements and interchange formats -- Information interchange -- Representation of dates and times http://www.iso.org/iso/catalogue_detail?csnumber=40874
[ISO-C]
ISO Country instance file. http://www.daml.org/2001/09/countries/iso
[MF-13]
X. Ma, P. Fox, Recent progress on geologic time ontologies and considerations for future works, Earth Sci. Informatics. 6 (2013) 31–46. doi:10.1007/s12145-013-0110-x.
[OE-06]
OWL code of the entry sub-ontology of time. http://www.w3.org/2006/time-entry
[OT-06]
OWL code of the time ontology. http://www.w3.org/2006/time
[OWL-2]
Owl2-quick-reference https://www.w3.org/TR/owl2-quick-reference/#Built-in_Datatypes
[OWL-M]
Horridge, M. and Patel-Schneider, P. 2012. OWL 2 Web Ontology Language Manchester Syntax (Second Edition). W3C Working Group Note https://www.w3.org/TR/owl2-manchester-syntax/
[OWL-S]
OWL-S homepage. http://www.daml.org/services/owl-s/
[OWL-T]
Hobbs, J. R. and Pan, F. 2006. Time Ontology in OWL. W3C Working Draft https://www.w3.org/TR/2006/WD-owl-time-20060927/
[PA-05]
Pan, F. 2005. A Temporal Aggregates Ontology in OWL for the Semantic Web. In: Proceedings of the AAAI Fall Symposium on Agents and the Semantic Web, Arlington, Virginia, pp. 30-37. https://pdfs.semanticscholar.org/daf3/2ec8803b0749952ee89be3644303cb6b3ff2.pdf
[PH-04]
Pan, F and Hobbs, J. R. 2004. Time in OWL-S. In: Proceedings of the AAAI Spring Symposium on Semantic Web Services, Stanford University, CA, pp. 29-36. http://www.isi.edu/~hobbs/time/pub/pan-hobbs-AAAI-SSS04.pdf
[PH-05]
Pan, F and Hobbs, J. R. 2005. Temporal Aggregates in OWL-Time. In Proceedings of the 18th International Florida Artificial Intelligence Research Society Conference (FLAIRS), Clearwater Beach, Florida, pp. 560-565, AAAI Press. http://www.isi.edu/~hobbs/FLAIRS-05.pdf
[PR-OS]
The process file of the OWL-S 0.9 release. http://www.daml.org/services/owl-s/0.9/Process.owl
[RC-14]
Guidelines to Authors, Radiocarb. Mag. (2014). https://journals.uair.arizona.edu/index.php/radiocarbon/about/submissions#authorGuidelines (accessed September 9, 2014)
[TTL-14]
Prud'hommeaux, E. and Carothers, G. 2014. RDF 1.1 Turtle - Terse RDF Triple Language. W3C Recommendation. https://www.w3.org/TR/turtle/
[XSD-D]
XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes. W3C Recommendation 5 April 2012 https://www.w3.org/TR/xmlschema11-2/

Acknowledgements

The editors would like to thank Jerry Hobbs and Feng Pan for producing the original draft.