Temporal SPARQL

These functions allow queries to filter triples based on their temporal annotations. They are essential for retrieving facts valid at a specific point in time or within an interval.

• temporal:during(?interval): Matches triples whose validity interval is completely contained within the specified ?interval.
• temporal:overlaps(?interval): Matches triples whose validity interval overlaps (shares any common time points) with ?interval.
• temporal:before(?time) / temporal:after(?time): Matches triples whose validity interval ends before or starts after the specified ?time.
• temporal:at(?time): A shorthand function that matches triples whose validity interval includes the instantaneous ?time point.

Example: ?event temporal:during ["2023-01-01T00:00:00"^^xsd:dateTime, "2023-12-31T23:59:59"^^xsd:dateTime] finds events that occurred entirely within the year 2023.

These functions create and deconstruct temporal intervals, which are the fundamental data type for representing validity periods.

• temporal:interval(?start, ?end): Constructs a time interval literal from start and end timestamps.
• temporal:start(?interval): Returns the starting timestamp of an interval.
• temporal:end(?interval): Returns the ending timestamp of an interval.
• temporal:duration(?interval): Calculates the length of the interval as an xsd:duration.
• temporal:instant(?time): Creates a zero-duration interval representing an instantaneous point in time.

Example: SELECT (temporal:duration(?validity) AS ?length) WHERE { ?fact :validityInterval ?validity } retrieves how long each fact was true.

These operators implement the 13 qualitative relations defined by James F. Allen's Interval Algebra, enabling complex temporal reasoning between two intervals.

Core relations include:

• temporal:before(?interval1, ?interval2): Interval1 ends before Interval2 starts.
• temporal:meets(?interval1, ?interval2): Interval1 ends exactly when Interval2 starts.
• temporal:overlaps(?interval1, ?interval2): Interval1 starts before Interval2, and they overlap.
• temporal:during(?interval1, ?interval2): Interval1 is completely contained within Interval2.
• temporal:starts(?interval1, ?interval2) / temporal:finishes(?interval1, ?interval2): Interval1 shares the same start or end time as Interval2, but is shorter.
• temporal:equals(?interval1, ?interval2): The two intervals are identical.

These operators return a boolean, enabling complex FILTER conditions for event sequencing and causality checks.

These functions support analyzing sequences of events or states over time, often used with GROUP BY and ordering.

• temporal:sequence(?node, ?property): Aggregates the chronological sequence of values for a given property of a versioned node.
• temporal:first(?intervalSet) / temporal:last(?intervalSet): Returns the chronologically first or last interval from a set or sequence.
• temporal:precedes(?event1, ?event2): A specialized operator checking if one event's validity interval ends before another's begins, establishing a direct temporal precedence.

Example: SELECT ?employee (temporal:sequence(?employee, :jobTitle) AS ?titleHistory) WHERE { ?employee a :Employee } GROUP BY ?employee creates a timeline of job title changes for each employee.

These keywords and functions modify the default interpretation of triple patterns within a query to be time-sensitive.

• VALID TIME Clause: A query-level modifier that specifies the temporal context for the entire query. For example, VALID TIME "2023-06-15"^^xsd:date causes all triple patterns to match only facts valid on that date.
• temporal:asOf(?time): A function that can be applied within a graph pattern to temporarily set the validity time for a specific set of triples.
• TEMPORAL FROM / TEMPORAL TO: Projection keywords used in SELECT statements to explicitly return the start and end timestamps of a matched triple's validity interval alongside its subject, predicate, and object.

These constructs are key to writing concise queries that avoid verbose FILTER conditions on every triple pattern.

Functions that derive new temporal knowledge or check for consistency, often leveraging a temporal reasoning engine.

• temporal:transitiveClosure(?relation, ?startTime, ?endTime): Computes the transitive closure of a temporal relationship (e.g., 'isPartOf') over a specified interval, inferring indirect relationships.
• temporal:consistent(?graphPattern): A boolean function that checks if a set of temporal constraints and facts in a graph pattern are logically consistent (e.g., no contradictions like an entity having two mutually exclusive states at the same time).
• temporal:interpolate(?entity, ?property, ?time): Attempts to infer the likely value of a property for an entity at a time point where no explicit data exists, based on known values before and after.

These advanced functions move beyond simple retrieval into the domain of temporal knowledge graph completion and validation.

This is the foundational use case for querying facts that were true at a specific point in time or within a given interval. It directly leverages the temporal validity interval annotations on triples.

• Example Query: Find all employees who held the title 'Senior Engineer' at any point during the year 2023.
• Key Operators: temporal:during, temporal:before, temporal:after, and temporal:contains are used to filter triples based on their associated timestamps or intervals.
• Application: Auditing historical organizational charts, verifying contractual terms active during a specific period, or reconstructing the state of a system at a past point in time.

Identify sequences of events or state changes that follow a specific temporal order. This is crucial for process mining, customer journey analysis, and root cause investigation.

• Example Query: Find all cases where a server's CPU spiked above 90%, followed within 5 minutes by a database connection failure.
• Key Constructs: Combines graph pattern matching with temporal ordering constraints using SPARQL's FILTER on timestamp values and sequence operators.
• Application: Analyzing event logs stored as an Event Graph to discover common failure pathways, optimizing operational workflows, or detecting fraudulent transaction sequences.

Perform analytical queries that aggregate data over time windows, such as calculating counts, averages, or sums per day, month, or quarter. This transforms a temporal knowledge graph into a time-series analytics platform.

• Example Query: Calculate the monthly average sales volume per product category for the last fiscal year.
• Key Functions: Uses SPARQL aggregation (GROUP BY, COUNT, AVG) combined with temporal extraction functions (e.g., year(?date), month(?date)) to group results by time granularity.
• Application: Business intelligence dashboards, monitoring key performance indicator trends over time, and performing cohort analysis on temporal entity data.

Trace the complete history of changes to a specific entity's properties or relationships. This is essential for compliance, debugging, and understanding evolution.

• Example Query: Retrieve all previous addresses for a customer, ordered by the validity start date, to see their relocation history.
• Key Approach: Queries target Versioned Nodes by matching the same entity subject across multiple triples with different temporal intervals, then ordering results by time.
• Application: Auditing data provenance (Temporal Provenance), fulfilling regulatory data subject access requests (e.g., GDPR), and tracking the revision history of configuration items or legal documents.

Execute queries to detect logical inconsistencies or impossible states within the temporal knowledge graph, such as overlapping validity intervals for mutually exclusive properties.

• Example Query: Identify all employees who are recorded as having two different managerial assignments with overlapping validity intervals.
• Key Logic: Uses complex FILTER conditions and negation (NOT EXISTS) to find triples that violate defined business rules or temporal constraints derived from Allen's Interval Algebra.
• Application: Enforcing data quality in Temporal Knowledge Graph pipelines, ensuring the logical consistency of event timelines, and supporting Temporal Fact Checking systems.

While primarily an inference task, Temporal SPARQL can be used to query the results of predictive models integrated into the graph, such as forecasted future states or probable relationship formations.

• Example Query: Retrieve all supplier relationships predicted to be at high risk of dissolution within the next quarter, based on a Temporal Link Prediction model's output stored in the graph.
• Integration: Queries union actual historical triples with projected future triples that have been materialized in the graph by a Temporal Knowledge Graph Completion (TKGC) system.
• Application: Proactive risk management, predictive maintenance scheduling, and strategic planning based on forecasted network evolution.

The foundational data structure for Temporal SPARQL queries. A Temporal Knowledge Graph is a knowledge graph where facts (triples) are explicitly associated with temporal validity intervals or timestamps. This allows the graph to represent not just what is true, but when it is true. For example, a triple <Employee123> <holdsPosition> <CTO> might be valid from 2022-01-01 to 2023-12-31. TKGs are essential for modeling historical records, event sequences, and evolving entity states.

The specialized storage engine for temporal graph data. A Temporal Graph Database natively supports the storage, indexing, and efficient querying of time-evolving nodes and edges. Unlike standard graph databases, they maintain historical versions and implement time-aware indexes to accelerate queries like "find all connections active during Q4 2023." Key features include:

• Native support for temporal validity intervals on edges and node properties.
• Time-travel queries to reconstruct the graph's state at any past point.
• Optimized storage for versioned nodes to manage state changes over time.

A machine learning technique for representing temporal facts in a continuous vector space. Temporal Knowledge Graph Embedding models learn low-dimensional vectors for entities, relations, and time. This allows for predictive tasks like temporal link prediction (e.g., "Will Company A acquire Company B in 2025?") and temporal knowledge graph completion. Models such as TTransE and DE-SimplE incorporate time embeddings or functional time representations to capture how relationships evolve, enabling reasoning about unseen future or past facts.

A specific modeling paradigm within temporal knowledge graphs. An Event Graph treats events as first-class entities (nodes) rather than properties of entities. For example, a ProductLaunchEvent node is connected to participating Company and Product nodes via participatedIn edges, with the event node itself having temporal properties. This model excels at capturing complex narratives, causal chains (causedBy), and temporal sequences (precededBy). It aligns closely with the Event Sourcing Pattern, where state is derived from an immutable log of past events.

A class of neural architectures for learning from dynamic graph data. Temporal Graph Neural Networks extend standard GNNs to incorporate time as a core dimension. They learn node representations by aggregating information from a node's neighbors across recent time steps, capturing evolving network dynamics. Key architectures include:

• Temporal Graph Convolutional Network (TGCN): Uses gated mechanisms to integrate historical embeddings.
• EvolveGCN: Dynamically evolves the GCN's parameters over time. TGNNs are used for temporal node classification, temporal link prediction, and temporal anomaly detection in streaming graph scenarios.

A formal calculus for qualitative temporal reasoning. Allen's Interval Algebra defines 13 possible primitive relations (e.g., before, meets, overlaps, during, equals) that can hold between two time intervals. Temporal SPARQL engines can leverage this algebra to perform complex qualitative queries beyond simple point-in-time or range checks. For instance, it can answer queries like "Find all projects that were active during the Q3 audit period" or "Identify policy changes that overlapped with the incident window." It provides a logical foundation for temporal reasoning engines.