About Temporal Reasoner

Reasoning about time and temporal relations are important in context-aware systems. While prototyping CoBrA, I have implemented a temporal reasoner based on the ontology and axioms described in "A DAML Ontology of Time" by Jerry R. Hobbs and the ISO 8601 Date and Time Formats described in "XML Schema Part 2: Datatypes" (W3C Recommendation 02 May 2001).

The goal of developing this reasoner is to provide an off-the-shelf rule-based reasoner for processing and reasoning about temporal information that is described by Semantic Web languages (e.g., OWL and RDF). In particular, the design of this reasoner is aimed to support the processing of XSD time descriptions (e.g. processing date/time, duration, time zone, and UTC normalization).

To support more sophisticated temporal reasoning (e.g., interval calculus) over XSD-encoded information, this reasoner implements a subset of the DAML Time ontology axioms.

Limitations of the current reasoner implementation: (i) only the XSD built-in type dateTime is supported, (ii) the reasoner does not provide truth maintenance, (iii) the notion of infinity is not supported in the temporal reasoning, (iv) the reasoner cannot deduce sub-instants or sub-intervals that are not explicitly specified in the input of the reasoning rules.

The reasoner is implemented in Prolog (tested with swi-prolog). Source codes are available in a release package in the [code.base]. Here are session runs of the test programs: run_test_time_util.txt, run_test_time.txt

Design overview

The reasoner consists of two layers: (i) the Base Temporal Reasoner, which consists of rules for processing ISO 8601 date and time descriptions, and (ii) the Extended Temporal Reasoner, which consists of rules for processing ontology and axioms described in DAML-Time.

Functions of the Base Temporal Reasoner are the following:

1. Parsing an instant of time represented in XSD dateTime.
2. Providing constructs for manipulating default time zone that is used in the process of normalizing non-UTC time to UTC time.
3. Providing constructs for comparing the temporal order (i.e. before, after, and equals) of two XSD dateTime instants. If dateTime instants have time zone difference, they are converted into UTC for comparison.

Functions of the Extended Temporal Reasoner are the following:

1. Using the temporal comparison constructs provided by the Base Temporal Reasoner to build inference support for the high level temporal reasoning.
2. Providing a set of uniformed constructs for comparing time instants and time intervals (the implementation is based on the DAML-Time axioms).

a very-short user guide

The following user guide documentation is for the version 1.0 of the temporal reasoner. You need to install SWI-Prolog 5.0.10 (or higher). The program should work on all platforms that are supported by the SWI-Prolog distribution.

After download the source code from the [code.base] and unpack the tar-gzipped file, you should find the following files:

1. README
2. time.pl
3. time_util.pl
4. test_time.pl
5. test_time_util.pl

The time_util.pl is the implementation of the Base Temporal Reasoner, and the time.pl is the implementation of the Extended Temporal Reasoner.

The test_time_util.pl is the regression test program for testing the time_util.pl. The test_time.pl is the regression test program for testing the time.pl.

To try out the Base Temporal Reasoner, start SWI-Prolog and load test_time_util.pl. Execute the goal "go." at the Prolog prompt. The result of this execution will display testing results of the rules defined in the test_time_util.pl.

To try out the Extended Temporal Reasoner, start SWI-Prolog and load test_time.pl. Execute the goal "go." at the Prolog prompt. The result of this execution will display testing results of the rules defined in the test_time.pl.

NOTE: make sure you stop and restart the Prolog system in between loading the test programs. Because both programs uses the goal "go" to kick-off the execution. The Prolog system will complaint the redefine of a static goal if both test programs are loaded at the same time.