Temporal Granularity

Temporal granularity is organized in a hierarchical structure, where each level represents a different precision of time measurement. Common levels include:

• Year (e.g., 2024)
• Month (e.g., 2024-05)
• Day (e.g., 2024-05-15)
• Hour (e.g., 2024-05-15T14)
• Minute/Second (e.g., 2024-05-15T14:30:00)
• Millisecond/Nanosecond (e.g., 2024-05-15T14:30:00.123Z)

Choosing a coarser granularity (e.g., month) aggregates events, while finer granularity (e.g., millisecond) captures precise sequences and durations. The hierarchy allows for roll-up (aggregation to a coarser level) and drill-down (disaggregation to a finer level) operations during analysis.

The chosen granularity acts as a filter on what temporal questions can be answered deterministically. A graph with day-level granularity can answer "What was the inventory level on May 15th?" but cannot resolve "Did the shipment arrive before or after 2:00 PM on May 15th?"

Key Query Types Enabled:

• Point-in-Time Queries: Retrieve the state of the graph at a specific timestamp, limited by the granularity's precision.
• Interval Queries: Find all facts valid during a given time range.
• Temporal Joins: Align events or entity states that occurred within the same temporal bucket (e.g., same hour).

Finer granularity enables more precise sequencing and causality analysis but increases data volume and query complexity.

Granularity directly influences the physical storage model and indexing strategy of a temporal graph database.

• Storage Overhead: Finer granularity (e.g., nanosecond) generates more distinct timestamps, potentially leading to significant storage expansion for versioned nodes or interval-based facts.
• Index Design: Temporal indexes (e.g., B-tree, specialized time-tree indexes) are built on the timestamp field. The cardinality of the index is determined by the granularity and time range covered.
• Partitioning Strategy: Data is often partitioned by time (e.g., by month or day) to optimize query performance. The partition key must align with the query patterns and the chosen granularity to avoid scanning unnecessary partitions.

The granularity must be aligned with the source system's event emission frequency and the minimum meaningful time unit for business logic.

Examples:

• Financial Trading: Requires microsecond or nanosecond granularity to sequence order book events and comply with regulatory audits.
• Supply Chain Tracking: Hourly or daily granularity is often sufficient for tracking shipment milestones and warehouse inventory levels.
• Clinical Workflows: Second-level granularity may be needed to timestamp medication administrations accurately within an electronic health record.

A mismatch, such as using day-level granularity for a high-frequency sensor stream, results in irreversible loss of critical sequential data.

Granularity imposes fundamental limits on the precision of temporal reasoning and the inference of new facts.

• Allen's Interval Algebra: Reasoning about qualitative relationships (e.g., 'before', 'meets', 'overlaps') between intervals becomes ambiguous if intervals are defined at too coarse a level.
• Temporal Interpolation: Estimating an entity's state at an unobserved time point is less accurate if the known states are far apart (coarse granularity).
• Causal Inference: Establishing causality between two events requires that their timestamps can be ordered with sufficient precision to rule out alternative sequences. Coarse granularity can obscure true causal order.

Temporal granularity interacts closely with other concepts in temporal knowledge graphs:

• Temporal Validity Interval: The start and end points of an interval are defined at a specific granularity (e.g., an interval from 2024-01-01 to 2024-12-31 at day-level precision).
• Versioned Node: Each version of a node is associated with a timestamp or interval at the system's defined granularity.
• Temporal Sliding Window: The window's duration (e.g., 'last 7 days') and slide interval (e.g., 'every 1 hour') are expressed in units dictated by the underlying granularity.
• Temporal Pattern Mining: Discovered patterns (e.g., 'Event A is always followed by Event B within 2 hours') are only as precise as the timestamps on the constituent events.

A time range, defined by a start and end timestamp, during which a specific fact or relationship in a knowledge graph is considered true. The granularity of these timestamps (e.g., day vs. nanosecond) is a direct consequence of the chosen temporal granularity.

• Closed Interval: [start_time, end_time] where the fact is valid.
• Open Interval: Used for facts with an unknown end, like a person's current employment.
• Instantaneous Event: Represented as a zero-duration interval or a single timestamp, requiring fine granularity for precision.

An extension of the SPARQL query language that incorporates temporal operators to query time-annotated RDF data. The expressiveness of these queries is constrained by the underlying data's temporal granularity.

• Temporal Functions: VALID_TIME(?fact), BEFORE(?interval1, ?interval2).
• Granularity-Aware Queries: A query for events "during Q3 2023" cannot return hourly results if data is stored at monthly granularity.
• Standardization: Efforts like SPARQL 1.2 and community extensions formalize this syntax.

A graph node that maintains multiple historical states, each associated with a specific point in time or validity interval. The density of these versions is governed by the system's temporal granularity and change capture mechanism.

• State-Based Versioning: Stores complete snapshots of node properties at each change time.
• Delta-Based Versioning: Stores only the changed properties between versions, optimizing storage.
• Querying: Accessed via temporal extensions to graph query languages (e.g., Cypher with temporal clauses).

The task of inferring missing facts in a temporal knowledge graph for a specific query time. The model's ability to make precise predictions is limited by the temporal granularity of its training data.

• Time-Aware Embeddings: Models like TComplEx or TuckERT learn representations where (subject, relation, object, timestamp) holds.
• Granularity Mismatch: A model trained on daily data cannot reliably predict intra-day stock price relationships.
• Evaluation: Metrics must account for correctness within a permissible time window based on granularity.

A software architecture pattern where state changes are stored as an immutable sequence of events. When used with a graph, it creates an event graph. The timestamp precision of each event is its temporal granularity.

• Immutable Log: The system of record is a chronologically ordered event log.
• State Derivation: The current graph state is derived by replaying all events up to a point in time.
• Audit Trail: Provides inherent temporal provenance for every state change.

A neural network architecture designed to learn from dynamic graph data by incorporating temporal dependencies. The model's temporal aggregation windows must align with the data's temporal granularity to capture meaningful patterns.

• Message Passing Across Time: Nodes aggregate features from their neighbors at previous time steps.
• Architectures: Include Temporal Graph Convolutional Networks (TGCN) and attention-based models.
• Use Case: Forecasting future links or node states in a dynamic graph.