Copyright © 2017 OGC & W3C ® (MIT, ERCIM, Keio, Beihang), W3C liability, trademark and document use rules apply.
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.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at https://www.w3.org/TR/.
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.
This document was published by the Spatial Data on the Web Working Group as a Working Draft. This document is intended to become a W3C Recommendation. If you wish to make comments regarding this document, please send them to public-sdw-comments@w3.org (subscribe, archives). All comments are welcome.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This document is governed by the 1 September 2015 W3C Process Document.
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.
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/ |
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# |
This section is non-normative.
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
.
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 identity on the beginning and end points. The standard interval calculus assumes all intervals are proper, whose beginning and end are different.
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.
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.
Three classes in the ontology support a more explicit description of temporal position. All have 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.
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.
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. An interval can have multiple duration descriptions (e.g., 2 days, 48 hours), but can only have one duration.
Three classes support the description of the duration of an entity. :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.
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.
:DateTimeDescription
|
:DateTimeInterval
|
:DayOfWeek
|
:Duration
|
:DurationDescription
|
:GeneralDateTimeDescription
|
:GeneralDurationDescription
|
:Instant
|
:Interval
|
:ProperInterval
|
:TemporalEntity
|
:TemporalUnit
|
:TimePosition
|
:TimeZone
|
:TRS
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://dbpedia.org/resource/Gregorian_calendar> |
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.
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.
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.
RDFS Class: | time:Duration |
---|---|
Definition: | Duration of a temporal extent expressed as a number scaled by a temporal unit |
Instance of: | owl:Class |
Subclass of: | time:numericDuration exactly 1 |
Subclass of: | time:unitType exactly 1 |
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://dbpedia.org/resource/Gregorian_calendar> |
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.
RDFS Class: | time:GeneralDateTimeDescription |
---|---|
Definition: | Description of date and time structured with separate values for the various elements of a calendar-clock system |
Instance of: | owl:Class |
Subclass of: | time:hasTRS exactly 1 |
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 |
Three properties :hasTRS
, :timeZone
, and :unitType
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.
RDFS Class: | time:GeneralDurationDescription |
---|---|
Definition: | Description of temporal extent structured with separate values for the various elements of a calendar-clock system. |
Instance of: | owl:Class |
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.
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
.
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
.
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 |
Thirteen properties
:intervalBefore
, :intervalAfter
,
:intervalMeets
, :intervalMetBy
,
:intervalOverlaps
, :intervalOverlappedBy
,
:intervalStarts
, :intervalStartedBy
,
:intervalDuring
, :intervalContains
,
:intervalFinishes
, :intervalFinishedBy
,
:intervalEquals
support the set of interval relations defined by Allen and Ferguson [AF-97].
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 :TemporalEntity
s.
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.
RDFS Class: | time:TemporalUnit |
---|---|
Definition: | A temporal unit of measure, which provides a scale factor for a time quantity. |
Instance of: | owl:Class |
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).
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. |
Instance of: | owl:Class |
Subclass of: | time:hasTRS exactly 1 |
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
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.
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 :ProperInterval
s, 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).
:after
|
:before
|
:day
|
:days
|
:dayOfWeek
|
:dayOfYear
|
:hasBeginning
|
:hasDuration
|
:hasDateTimeDescription
|
:hasDurationDescription
|
:hasEnd
|
:hasMember
|
:hasTRS
|
:hour
|
:hours
|
:inside
|
:intervalAfter
|
:intervalBefore
|
:intervalContains
|
:intervalDuring
|
:intervalEquals
|
:intervalFinishedBy
|
:intervalFinishes
|
:intervalMeets
|
:intervalMetBy
|
:intervalOverlappedBy
|
:intervalOverlaps
|
:intervalStartedBy
|
:intervalStarts
|
:inTimePosition
|
:inDateTime
|
:inXSDDate
|
:inXSDDateTime
|
:inXSDDateTimeStamp
|
:inXSDgYear
|
:inXSDgYearMonth
|
:minute
|
:minutes
|
:month
|
:months
|
:nominalPosition
|
:numericDuration
|
:numericPosition
|
:second
|
:seconds
|
:timeZone
|
:unitType
|
:week
|
:weeks
|
:xsdDateTime
|
:year
|
:years
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 |
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 |
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 |
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 |
RDF Property: | time:dayOfYear |
---|---|
Definition: | The number of the day within the year |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDateTimeDescription |
Range: | xsd:nonNegativeInteger |
RDF Property: | time:days |
---|---|
Definition: | length of a temporal extent expressed in days |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
RDF Property: | time:hasBeginning |
---|---|
Definition: | Beginning of a temporal entity. |
Instance of: | owl:ObjectProperty |
Domain: | time:TemporalEntity |
Range: | time:Instant |
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 |
RDF Property: | time:hasDuration |
---|---|
Definition: | Duration of a temporal entity, expressed as a scaled value or nominal value |
Instance of: | owl:ObjectProperty |
Domain: | time:TemporalEntity |
Range: | time:Duration |
RDF Property: | time:hasDurationDescription |
---|---|
Definition: | Duration of a temporal entity, expressed using a structured description |
Instance of: | owl:ObjectProperty |
Domain: | time:TemporalEntity |
Range: | time:DurationDescription |
RDF Property: | time:hasEnd |
---|---|
Definition: | End of a temporal entity. |
Instance of: | owl:ObjectProperty |
Domain: | time:TemporalEntity |
Range: | time:Instant |
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 |
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 |
RDF Property: | time:hour |
---|---|
Definition: | Hour position in a calendar-clock system |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDateTimeDescription |
Range: | xsd:nonNegativeInteger |
RDF Property: | time:hours |
---|---|
Definition: | length of a temporal extent expressed in hours |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
RDF Property: | time:inDateTime |
---|---|
Definition: | Position of an instant, expressed using a structured description |
Instance of: | owl:ObjectProperty |
Domain: | time:Instant |
Range: | time:GeneralDateTimeDescription |
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 |
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 |
Inverse of: | time: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 |
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 |
Inverse of: | time: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 |
RDF Property: | time:intervalEquals |
---|---|
Definition: | If a proper interval T1 is intervalEquals another proper interval T2, then the beginning of T1 is the beginning of T2, and the end of T1 is the end of T2. |
Instance of: | owl:ObjectProperty |
Domain: | time:ProperInterval |
Range: | time:ProperInterval |
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 the end of T2. |
Instance of: | owl:ObjectProperty |
Inverse of: | time: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 the end of T2. |
Instance of: | owl:ObjectProperty |
Domain: | time:ProperInterval |
Range: | time:ProperInterval |
RDF Property: | time:intervalMeets |
---|---|
Definition: | If a proper interval T1 is intervalMeets another proper interval T2, then the end of T1 is the beginning of T2. |
Instance of: | owl:ObjectProperty |
Domain: | time:ProperInterval |
Range: | time:ProperInterval |
RDF Property: | time:intervalMetBy |
---|---|
Definition: | If a proper interval T1 is intervalMetBy another proper interval T2, then the beginning of T1 is the end of T2. |
Instance of: | owl:ObjectProperty |
Inverse of: | time:intervalMeets |
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 |
Inverse of: | time: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 |
RDF Property: | time:intervalStartedBy |
---|---|
Definition: | If a proper interval T1 is intervalStarted another proper interval T2, then the beginning of T1 is the beginning of T2, and the end of T1 is after the end of T2. |
Instance of: | owl:ObjectProperty |
Inverse of: | time:intervalStarts |
RDF Property: | time:intervalStarts |
---|---|
Definition: | If a proper interval T1 is intervalStarts another proper interval T2, then the beginning of T1 is 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 |
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 |
RDF Property: | time:inXSDDate |
---|---|
Definition: | Position of an instant, expressed using xsd:date |
Instance of: | owl:DatatypeProperty |
Domain: | time:Instant |
Range: | xsd:date |
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 |
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
RDF Property: | time:inXSDgYear |
---|---|
Definition: | Position of an instant, expressed using xsd:gYear |
Instance of: | owl:DatatypeProperty |
Domain: | time:Instant |
Range: | xsd:gYear |
RDF Property: | time:inXSDgYearMonth |
---|---|
Definition: | Position of an instant, expressed using xsd:gYearMonth |
Instance of: | owl:DatatypeProperty |
Domain: | time:Instant |
Range: | xsd:gYearMonth |
RDF Property: | time:minute |
---|---|
Definition: | Minute position in a calendar-clock system |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDateTimeDescription |
Range: | xsd:nonNegativeInteger |
RDF Property: | time:minutes |
---|---|
Definition: | length of a temporal extent expressed in minutes |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
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 |
RDF Property: | time:months |
---|---|
Definition: | length of a temporal extent expressed in months |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
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 |
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 |
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 |
RDF Property: | time:second |
---|---|
Definition: | Second position in a calendar-clock system. |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDateTimeDescription |
Range: | xsd:decimal |
RDF Property: | time:seconds |
---|---|
Definition: | length of a temporal extent expressed in seconds |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
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 |
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.
RDF Property: | time:week |
---|---|
Definition: | The number of the week within the year |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDateTimeDescription |
Range: | xsd:nonNegativeInteger |
RDF Property: | :weeks |
---|---|
Definition: | length of a temporal extent expressed in weeks |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
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
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 |
RDF Property: | time:years |
---|---|
Definition: | length of a temporal extent expressed in years |
Instance of: | owl:DatatypeProperty |
Domain: | time:GeneralDurationDescription |
Range: | time:Number |
:generalDay
|
:generalMonth
|
:generalYear
|
:Number
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 ;
]
)
|
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 ;
]
)
|
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 ;
]
)
|
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).
:Friday
|
:Monday
|
:Saturday
|
:Sunday
|
:Thursday
|
:Tuesday
|
:Wednesday
|
:unitDay
|
:unitHour
|
:unitMinute
|
:unitMonth
|
:unitSecond
|
:unitWeek
|
:unitYear
Class | Individual |
---|---|
time:DayOfWeek |
time:Friday |
time:DayOfWeek |
time:Monday |
time:DayOfWeek |
time:Saturday |
time:DayOfWeek |
time:Sunday |
time:DayOfWeek |
time:Thursday |
time:DayOfWeek |
time:Tuesday |
time:DayOfWeek |
time:Wednesday |
time:TemporalUnit |
time:unitDay |
time:TemporalUnit |
time:unitHour |
time:TemporalUnit |
time:unitMinute |
time:TemporalUnit |
time:unitMonth |
time:TemporalUnit |
time:unitSecond |
time:TemporalUnit |
time:unitWeek |
time:TemporalUnit |
time:unitYear |
This section is non-normative.
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 1 ;
:dayOfWeek :Sunday ;
:dayOfYear 1 ;
:week 1 ;
:month 1 ;
:timeZone <https://www.timeanddate.com/time/zones/est> ;
:year 2006 .
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, we can also know that 01/01/2006 is Sunday, on the first day of the year, and in the first week of the year. 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.
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 ;
:hour "8"^^xsd:nonNegativeInteger ;
:minute "20"^^xsd:nonNegativeInteger ;
:month "--05"^^xsd:gMonth ;
: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 ;
:year "5761"^^:generalYear ;
:unitType :unitDay ;
.
The :TimePosition
class may be used to express the same position on the Unix time scale (i.e. the number of seconds since 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.
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 [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.
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 :ProperInterval
s 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.
For example, the 'Phanerozoic Eon' is a :ProperInterval
described as follows:
geol:Phanerozoic
rdf:type :ProperInterval ;
:hasBeginning geol:BasePhanerozoic ;
:hasEnd geol:Present ;
:intervalFinishedBy geol:Cenozoic ;
:intervalMetBy geol:Proterozoic ;
:intervalStartedBy geol:Paleozoic ;
rdfs:label "Phanerozoic Eon"^^xsd:string ;
.
The beginning of the Phanerozoic Eon is an :Instant
, described as follows:
geol:BasePhanerozoic
rdf:type :Instant ;
:inTimePosition [
rdf:type :TimePosition ;
:hasTRS <http://www.opengis.net/def/crs/OGC/0/ChronometricGeologicTime> ;
:numericPosition "541.0"^^:Number ;
] ;
rdfs:label "Base of Phanerozoic 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.
It may be useful to define specialized concepts by specialization.
For example, "January" can be defined as a a subclass of :DateTimeDescription
with the restrictions that the :unitType
property has allValuesFrom
unitMonth and property :month
hasValue
of 1:
ex:January a owl:Class ; rdfs:subClassOf :DateTimeDescription ; rdfs:subClassOf [ a owl:Restriction ; owl:onProperty :unitType owl:hasValue :unitMonth ] ; rdfs:subClassOf [ a owl:Restriction ; owl:onProperty :month owl:hasValue --01 ; ] .
For example, duration "Year" could be defined as a subclass of "DurationDescription" with the restrictions that the "years" property is required (with "cardinality" of 1) and all other properties (e.g., "hours", "months") should not be present (with "cardinality" of 0):
ex:Year a owl:Class ; rdfs:subClassOf :DurationDescription ; rdfs:subClassOf [ a owl:Restriction ; owl:cardinality 1 ; owl:onProperty :years ] ; rdfs:subClassOf [ a owl:Restriction ; owl:cardinality 0 ; owl:onProperty :months ] ; ... rdfs:subClassOf [ a owl:Restriction ; owl:cardinality 0 ; owl:onProperty :seconds ] .
We use "cardinality = 0" instead of restricting the values of days, etc. to 0. The reason is that using "cardinality = 0" means all those properties/fields (days, etc.) should not be specified (i.e., the granularity is "year"), while restricting all those values to 0 means they all have a fixed value of 0 (i.e., x years 0 months 0 days ...) and the granularity is actually "second", which is not the correct semantics of "year".
Note that there is a distinction between a year as a duration and a calendar year. The year from December 22, 2006 to December 21, 2007 is the former but not the latter.
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.
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.
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.
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.
ProcessTime
output parameterProcessTime
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.
DeliveryDuration
output parameterDeliveryDuration
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.
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:
:GeneralDateTimeDescription
and :GeneralDurationDescription
are generalizations of the corresponding classes from the 2006 draft, for cases which the temporal reference system is not fixed to the Gregorian Calendar in advance:TimePosition
and :Duration
are new classes to enable position or duration to be described using a number or nominal value :hasTRS
enables time values to be associated with a temporal reference system, represented by a new ('stub') class :TRS
:Year
and :January
are deprecated, and the code showing how they could be derived by sub-classing moved into the Examples chapter:TimeZone
in the main namespace is used instead. The new class is a 'stub' with no properties, to serve as a superclass for any implementationA 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.
The editors would like to thank Jerry Hobbs and Feng Pan for producing the original draft.