OWL-Time

OWL-Time establishes two fundamental temporal entities:

• Instant: A point in time with zero duration, representing a specific moment (e.g., a signing timestamp).
• Interval: A temporal entity with a positive duration, defined by a beginning and ending instant (e.g., a contract's effective period).

This dual representation allows systems to model both instantaneous events and durative states, which is critical for distinguishing between a Temporal Trigger and an Obligation Lifecycle.

The ontology natively implements Allen's Interval Algebra, defining thirteen mutually exclusive relations between two intervals:

• before and after: One interval ends before the other begins.
• meets and metBy: One interval ends exactly when the other begins.
• overlaps and overlappedBy: Intervals share a portion but neither contains the other.
• starts and startedBy: Intervals share a beginning instant.
• finishes and finishedBy: Intervals share an ending instant.
• during and contains: One interval is entirely within the other.
• equals: Intervals are identical.

These relations enable a Temporal Dependency Graph to reason about the sequence of contractual obligations.

OWL-Time distinguishes between time positions and the coordinate systems used to describe them via the TemporalReferenceSystem class:

• Gregorian Calendar: The standard civil calendar for expressing dates.
• Unix Time: A system describing time as a running count of seconds since the Unix epoch.
• Geologic Timescales: Domain-specific reference systems.

This explicit modeling is essential for Date Normalization, ensuring that a deadline expressed as 'Q3 2025' can be unambiguously converted to a machine-readable ISO 8601 instant.

The ontology provides rich classes for describing durations and temporal positions:

• Duration: Represents a length of time using properties like years, months, days, hours, minutes, and seconds.
• DateTimeDescription: Allows for partial or underspecified temporal descriptions, such as 'Monday' or 'January 2025', without pinning them to a specific instant.

This capability directly supports a Duration Parser in converting natural language phrases like 'thirty calendar days' into a structured, computable format for calculating a Grace Period.

OWL-Time supports complex temporal topologies beyond simple intervals:

• Proper Interval: An interval where the beginning and ending instants are distinct (positive duration).
• Temporal Unit: A standardized duration used as a building block, such as a 'day' or 'week'.
• DateTimeInterval: An interval defined by a start and end DateTimeDescription.

This allows for modeling recurring patterns, such as a Business Day Convention, where a sequence of proper intervals (business days) is interspersed with excluded intervals (weekends and holidays).

As a W3C standard, OWL-Time is designed for the Semantic Web stack:

• Uses RDF/OWL for data interchange and reasoning.
• Can be combined with other ontologies like FOAF or schema.org.
• Enables SPARQL queries over temporal data.

This interoperability is foundational for building a Temporal Knowledge Graph, where a query can retrieve all contracts 'in effect' at a specific Point-in-Time Retrieval date by reasoning over the temporal properties of each agreement.

A formal system for reasoning about propositions qualified in terms of time. Unlike OWL-Time, which provides a vocabulary for describing temporal entities, Temporal Logic provides the rules of inference.

• Linear Temporal Logic (LTL): Reasons about a single timeline; useful for modeling a specific contract's execution path.
• Computation Tree Logic (CTL): Reasons about branching futures; useful for modeling contingent obligations that depend on uncertain events.
• Key operators include G (always/globally), F (eventually/finally), X (next), and U (until).

A calculus defining 13 mutually exclusive relations between two time intervals, forming the logical backbone for qualitative temporal reasoning in OWL-Time.

• Relations include: before, meets, overlaps, starts, during, finishes, and their inverses, plus equals.
• Enables a system to infer that if obligation A is before obligation B, and B is before C, then A is before C without explicit dates.
• Essential for detecting temporal contradictions in complex multi-document scenarios.

A knowledge graph where facts are associated with a temporal scope (valid time), enabling queries about the state of legal relationships at different points in time.

• Extends a standard RDF triple (subject, predicate, object) to a quad by adding a temporal interval.
• Allows queries like: 'What were all active indemnification obligations on 2023-06-15?'
• OWL-Time provides the standard vocabulary for representing the temporal intervals attached to each fact in the graph.

A database design pattern that tracks data along two orthogonal time axes:

• Valid Time: When a fact is true in the real world (e.g., the contract's effective date period).
• Transaction Time: When the fact was recorded in the database.
• This distinction is critical for legal systems, allowing a user to query 'what did we believe the deadline was on Tuesday?' versus 'what was the actual contractual deadline?'

The algorithmic process of finding a valid timeline of events that satisfies all specified temporal constraints extracted from a set of contracts.

• Formulated as a Constraint Satisfaction Problem (CSP) where variables are events, domains are timepoints, and constraints are Allen relations or numeric bounds.
• Used to answer: 'Is there any possible schedule where all deadlines across these 50 vendor agreements are met?'
• A failure to find a solution indicates a temporal contradiction requiring human review.

A markup language standard for representing temporal events, time expressions, and their linking relationships within a document.

• Tags like <EVENT>, <TIMEX3>, and <TLINK> make temporal semantics machine-readable.
• A <TIMEX3> tag normalizes a phrase like 'the last business day of the month' into a formal value using ISO 8601.
• Serves as a bridge between unstructured legal text and the structured temporal reasoning enabled by OWL-Time.