TimeML Annotation

The tag used to annotate explicit time references, normalizing them to a standard value for machine processing.

• Types: Date, Time, Duration, and Set (e.g., 'every month').
• Normalization: The value attribute converts 'October 26, 2023' to 2023-10-26.
• Anchoring: The anchorTimeID attribute links relative expressions like 'last week' to a reference point.
• Modifiers: Captures quantifiers such as 'approximately' or 'more than'.

The tag for annotating situations that happen or hold true, serving as the nodes in a temporal graph.

• Classes: OCCURRENCE, STATE, REPORTING, I_STATE, I_ACTION, ASPECTUAL.
• Tense & Aspect: Attributes capture grammatical cues like tense=PAST and aspect=PERFECTIVE.
• Polarity: The polarity=NEG attribute explicitly marks negated events (e.g., 'did not pay').
• Modality: Captures the context of possibility or necessity (e.g., 'shall deliver').

The relation tag that establishes the chronological order between two events or an event and a time expression.

• Core Relations: Encodes Allen's interval algebra primitives like BEFORE, AFTER, INCLUDES, and SIMULTANEOUS.
• Graph Construction: TLINKs create the directed temporal dependency graph required for critical path analysis.
• Inference: Enables reasoning about the happens-before relationship between contractual obligations.

The tag that marks function words and phrases indicating the nature of a temporal relation.

• Examples: 'during', 'before', 'after', 'while', 'until'.
• Disambiguation: Resolves ambiguous TLINKs by providing the lexical evidence for the link.
• Scope: The SIGNAL tag is linked to a TLINK via its signalID attribute, grounding the relation in explicit text.

A relation tag specifically for linking an aspectual event to its argument event, encoding the internal temporal structure.

• Phases: Distinguishes between the INITIATES, CULMINATES, TERMINATES, and CONTINUES phases of an event.
• Example: In 'started to perform the audit', an ALINK connects 'started' to 'perform' with the INITIATES relation.
• Obligation Lifecycle: Critical for modeling the state machine of a contractual duty from inception to fulfillment.

The relation tag that connects a modal or evidential event to its subordinate event, capturing context like modality and factuality.

• Modality: Links 'shall' to 'deliver' to encode a deontic obligation.
• Factuality: Distinguishes between factual, counterfactual, and conditional events.
• Legal Relevance: Essential for parsing deontic logic structures like permissions and prohibitions in regulatory text.

A formal system of rules and symbolism for reasoning about propositions qualified in terms of time. In contract analysis, TL provides the mathematical foundation for proving whether a sequence of obligations is logically consistent.

• Linear Temporal Logic (LTL): Models time as a single, linear sequence of states—ideal for a single contract's execution timeline
• Computation Tree Logic (CTL): Models time as branching possibilities, useful for analyzing contingent obligations that depend on uncertain future events
• Key operators: G (always/globally), F (eventually/finally), X (next), U (until)

TimeML annotations serve as the input facts that a temporal logic reasoner evaluates against a set of axioms.

A calculus for qualitative temporal reasoning that defines thirteen mutually exclusive relations between two time intervals. These relations form the backbone of temporal constraint reasoning in contracts.

• Core relations: before, meets, overlaps, starts, during, finishes, and their inverses, plus equals
• Composition table: Allows inference of a third relation from two known relations (e.g., if A is before B and B is before C, then A is before C)
• Contract application: Determining if a payment deadline (during a grace period) conflicts with a termination right (before the payment)

TimeML's TLINK tags directly encode these interval relations between annotated events and times.

A directed graph structure where nodes represent contractual events or deadlines and edges represent the temporal precedence constraints between them. This is the primary computational artifact generated from TimeML annotations.

• Nodes: Events (EVENT tags), time expressions (TIMEX3 tags), and milestones
• Edges: TLINK relationships encoding before, after, simultaneous, includes, etc.
• Topological sort: Reveals the mandatory execution order of obligations
• Cycle detection: Identifies temporal contradictions—e.g., Obligation A must occur before Obligation B, but B must also occur before A

Critical path analysis runs on this graph to identify the sequence of obligations that determines the overall transaction timeline.

The algorithmic process of finding a valid timeline of events that satisfies all specified temporal constraints and precedence rules extracted from a set of contracts. TimeML annotations define the constraint set.

• Simple Temporal Network (STN): A framework where constraints are expressed as bounds on the distance between time points (e.g., 'Event B must occur 5 to 10 days after Event A')
• Disjunctive Temporal Problem (DTP): Handles 'or' constraints common in contracts (e.g., 'delivery within 30 days of signing OR within 14 days of inspection')
• Consistency checking: Determines if a set of deadlines is logically satisfiable or contains an inherent contradiction
• Solution extraction: Generates one or all valid schedules that satisfy every constraint

The NLP task of automatically identifying and normalizing the specific date or time by which a contractual obligation must be performed. This is the primary downstream consumer of TimeML annotations.

• Input: Unstructured legal text (e.g., 'The Tenant shall pay rent on the first day of each calendar month')
• TimeML role: TIMEX3 tags normalize 'first day of each calendar month' into a computable recurrence rule; EVENT tags identify 'pay' as the obligation; TLINKs connect them
• Output: A structured deadline object with an absolute or relative date, recurrence pattern, and linked obligation
• Challenges: Resolving relative dates ('within 30 days of Closing'), handling business day conventions, and interpreting vague terms ('promptly', 'reasonable time')

A logical inconsistency between two or more temporal statements in a contract, such as an obligation being due both before and after a specified triggering event. TimeML annotation surfaces these conflicts for resolution.

• Direct contradiction: 'Payment due on January 1, 2025' and 'Payment due on March 1, 2025' for the same obligation
• Transitive contradiction: A before B, B before C, C before A—forms an impossible cycle in the dependency graph
• Implicit contradiction: A sunset clause terminates the contract on Dec 31, but an obligation is scheduled for Jan 15 of the following year
• Detection method: Run temporal constraint satisfaction on the TLINK graph; any unsatisfiable constraint set flags a contradiction

Resolving these contradictions is critical for obligation management systems to avoid compliance failures.