Human language treats time as a moving target. When a news article states that a company announced a merger "yesterday," or a clinical note mentions a patient experienced symptoms "three weeks ago," the meaning of these expressions shifts depending entirely on when they were written. For a machine trying to construct a chronological timeline, perform database lookups, or execute precise reasoning, these "slippery" expressions are highly problematic.
Temporal normalization is the process of resolving these relative, vague, or informal expressions into standardized, machine-readable formats (such as ISO-8601 standards like 2023-10-24). It bridges the gap between the fluid way humans express time and the rigid, absolute timelines required by computational systems.
The Core Mechanism: Anchors and Offsets
To transform a relative time expression into an absolute date, a system requires two components: a reference anchor and a functional operator (or offset).
"two days before yesterday"
│
├──► Reference Anchor: Document Creation Time (e.g., 2023-10-25)
└──► Functional Operators: (-1 day) for "yesterday", then (-2 days)
│
└──► Normalized Output: 2023-10-22
As Verhagen et al. demonstrate in the TARSQI pipeline, the most common reference anchor is a document's metadata, such as its publication or creation date. If a system knows the Document Creation Time (DCT) is 2023-10-25, it can resolve "yesterday" by evaluating the expression as a mathematical offset: $\text{DCT} - 1 \text{ day} = \text{2023-10-24}$.
However, narratives are rarely linear. In complex texts, the temporal focus frequently shifts, meaning the anchor point itself is dynamic. Mani et al. showed that systems must leverage discourse context and verb tenses to track how the active reference anchor moves from sentence to sentence. When the anchor is implicit or shifts mid-text, Sun et al. demonstrate that normalization can be framed as a multi-stage machine learning task: first identifying the correct reference anchor within the text, and then determining the directional relationship (the offset) from that anchor.
The Evolution of Resolution Engines
How do systems translate the messy syntax of natural language into precise mathematical operations? The field has evolved through three primary paradigms:
1. Compositional Grammars
Early approaches relied heavily on hand-crafted regular expressions, but these struggled with nested or complex relative logic. To solve this, Bethard introduced a compositional approach using Synchronous Context-Free Grammars (SCFGs) in this work. Instead of treating phrases as static text patterns, SCFGs map natural language structures directly to a formal algebra of temporal operators. This allows the system to compute highly complex, nested expressions (e.g., "the second Tuesday of next month") by evaluating them as a chain of functions. As Rigau et al. point out, this formal logic ensures the strict arithmetic consistency that neural networks often struggle to guarantee.
2. Hybrid Pipelines
While formal grammars excel at the strict logic of normalization, machine learning excels at identifying where these expressions begin and end in unstructured text. This realization led to hybrid architectures. As explored by Filannino et al. and Qiang, these systems decouple the problem: a statistical model or neural network identifies the boundaries of a temporal phrase, and a rule-based engine subsequently standardizes that specific chunk. This hybrid strategy avoids the computational bottleneck of running exhaustive regular expressions over entire documents while maintaining deterministic precision during the calculation phase.
3. LLM-Based Normalization
With the advent of large language models, recent frameworks have shifted toward generative normalization. For example, Chen et al. demonstrate that models like ChatGPT-4o can be used to directly transform vague or conversational time references into absolute date formats. While LLMs excel at understanding highly implicit context, they are often paired with symbolic verification layers to ensure their calculations remain mathematically sound.
Overcoming Cultural and Contextual Nuances
Time is not universally expressed through a single standard. Normalization engines must handle significant cultural and linguistic variations to remain robust:
- Non-Standard Calendars: Standard temporal extractors often fail when encountering historical or culturally specific texts. As Jeong et al. highlight, processing dates from systems like the lunar calendar requires specialized mapping logic to translate culture-specific frameworks into modern ISO-8601 standards.
- Linguistic Conventions: Some languages lack explicit morphological markers for time. For instance, Xue demonstrates that in "tenseless" languages like Chinese, systems must rely heavily on surrounding contextual clues and event structures to infer relative offsets from a reference time.
- Holiday-Relative Dates: Expressions like "two days after Thanksgiving" require external knowledge bases. Field et al. address this by using finite state transducers that incorporate regional holiday calendars to resolve local linguistic conventions into precise calendar formats.
Why It Matters: Downstream Impact
Without temporal normalization, downstream applications suffer from severe retrieval and reasoning failures.
In Question Answering (QA) systems, treating dates as literal strings prevents accurate filtering. As Saquete et al. show, converting a vague phrase like "the sixties" into a concrete numerical range (1960-01-01 to 1969-12-31) allows the system to apply logical ordering keys to validate when events occurred.
Similarly, in long-term AI agents, Liu demonstrates that converting relative time references into absolute timestamps during the memory encoding phase is critical; without this normalization, an agent's ability to resolve time-dependent queries across long interactions decreases by over 50%. By anchoring slippery language to an absolute timeline, temporal normalization provides the foundational truth required for reliable machine reasoning.
Key Foundational Work
Modeling Time: Back to Basics (1996) — contributed 2 concept elements to this direction.