Time Travel with the BiTemporal RDF Model

Abstract

The Internet is not just used for communication, transactions, and cloud storage; it also serves as a massive knowledge store where both people and machines can create, analyze, and use data and information. The Semantic Web was designed to enable machines to interpret the meaning of data, facilitating more informed and autonomous decision-making. The foundation of the Semantic Web is the Resource Description Framework (RDF). The standard RDF is limited to representing simple binary relationships in the form of the $<subjectpredicateobject>$ triple. In this paper, we present a new data model called BiTemporal RDF (BiTRDF), which adds valid time and transaction time to the standard RDF. Our approach treats temporal information as references instead of attributes, simplifying the semantics while enhancing the model’s expressiveness and consistency. BiTRDF treats all resources and relationships as inherently bitemporal, enabling the representation and reasoning of complex temporal relationships in RDF. Illustrative examples demonstrate the model’s support for type propagation, domain-range inference, and transitive relationships in a temporal setting. While this work lays a theoretical foundation, future research will address implementation, query language support, and compatibility with RDF streams and legacy systems.

1. Introduction

The Semantic Web envisions an Internet where data is interconnected and organized to enable computers to understand and interpret the meaning of data. This empowers more intelligent and automated information processing, as well as data and knowledge integration and sharing. The initiative to define, develop, and standardize vocabularies for this purpose was guided by the World Wide Web Consortium (W3C). This led to the establishment of the Semantic Web Stack, commonly referred to as the Semantic Web Layer Cake [1]. Under this structure, the Resource Description Framework (RDF) employs sets of triples to articulate nuanced meanings as the endorsed standard for the Semantic Web by the W3C. Universal Resource Identifier (URI) confers an identification mechanism for subjects, objects, and predicates, enabling seamless linkage and integration across diverse knowledge repositories distributed among websites on the Internet [2]. Subsequent development saw the Web Ontology Language (OWL) [3] extending the RDF and RDF schema, providing an enhanced vocabulary for defining classes and properties [4].

Temporal data is essential in applications that require historical accuracy or retrospective analysis, with two primary categories: valid time, which records the period during which facts are true in the real world, and transaction time, which records when facts are stored or modified in a knowledge base. These two time dimensions are particularly important in domains that require historical accuracy, auditability, or retrospective analysis, such as legal, financial, or scientific datasets.

Building on this foundation, just as temporal relational databases manage time-varying data and knowledge to capture changes over time, there is growing recognition of the importance of representing temporal information within the RDF and RDF schema. A temporal RDF would enable the handling of evolving data and historical context in similar ways to the capability offered by bitemporal databases. Nevertheless, an RDF triple, denoted as $<spo>$, where s, p, and o represent the subject, predicate, and object, respectively, has its limitations in expressing only binary relations. To represent n-ary relations accurately and effectively, reification is frequently employed, utilizing additional triples to achieve it. This process often introduces excessive complexity and increased computational overhead.

Besides temporal data, various practical applications may also require other essential data aspects, such as probability, spatial information, confidence levels, and data provenance. The recognition of these diverse data aspects has motivated ongoing research efforts aimed at devising methods and frameworks to extend RDF to support multiple facets of data representation. The field has indeed nurtured a rich body of literature, providing a robust foundation for both researchers and practitioners in the community.

Our research endeavors revolve around the development of an innovative bitemporal RDF model that addresses the pressing need for comprehensive temporal representation and reasoning for expanding application needs. Our novel model requires no additional structural complexity. Its intrinsic design seamlessly bitemporalizes all resources to represent temporal data.

The main contributions of this article include the following:

• The creation of a new bitemporal RDF model that introduces both bitemporal resources and bitemporal relationships as the cornerstones of our model.
• The seamless uniform temporalization of the standard RDF into its bitemporal counterpart. This transformation ensures that every element within the RDF ecosystem becomes inherently bitemporal, marking a fundamental shift in the way temporal data is represented and processed.
• Using time as a reference rather than a fixed attribute enhances flexibility by allowing various time representations, improves consistency by distinguishing time from core attribute values, and ensures compatibility with evolving temporal modeling practices without requiring extensive restructuring.

The remainder of this paper is organized as follows: Section 2 reviews related work on temporal RDF extensions. Section 3 introduces the BiTRDF model, including its syntax and semantics. Section 4 provides illustrative examples of practical application. Section 5 discusses the model’s implications, outlines directions for future implementation, and concludes the paper.

2. Literature Review

Our model is built on the intersection of two key domains: the Semantic Web, with a specific focus on the RDF, and temporal databases, particularly bitemporal databases. In this section, we first provide an overview of the existing body of work in these two fields. We then offer a brief exploration of ongoing research in temporal RDFs. Ultimately, we bridge this contextual discussion to our proposed model, BiTemporal RDF, establishing the foundation for its significance and relevance within the larger landscape of Semantic Web and temporal database research.

2.1. Time

Time, an unbounded and continuous phenomenon in the universe, continues indefinitely without any end. When we want to keep track of time in a database, we typically conceptualize time as a straight line T with a start and a direction, like a road. To use it in computing, we mark discrete points on this timeline T. These points are “time instants”. A pair of time instants, $t_s$ and $t_e$, creates a period of time that starts at the time instant $t_s$ and ends at the time instant $t_e$, where $t_s$ is before $t_e$. This period of time is a “time interval” [5]. In temporal databases, two types of time are typically considered: valid time and transaction time. Valid time refers to the time when a fact is true in the real world, reflecting the temporal data associated with that fact. Transaction time, on the other hand, is about when we record things in a database, which might not be exactly the same as when they happen in the real world. To handle both of these time aspects, we use “bitemporal time”. This includes both valid time and transaction time. Using bitemporal time in a database lets us do more with our data. We can ask questions not just about the facts themselves but also about when those facts were true and when they were recorded in the database, like time traversing.

2.2. RDF

The RDF serves as the foundation for describing all sorts of things, known as resources. Resources can be very diverse, ranging from physical objects and abstract ideas to specific data types and even web pages [6,7]. In the RDF, these resources fall into three main categories: Internationalized Resource Identifiers (IRIs), blank nodes, and literals. IRIs are like unique addresses for resources, helping us to identify and link them across the web. Blank nodes are placeholders for resources when we do not have a specific IRI for them. Literals, on the other hand, are used for values like numbers or text. Since the definitions and syntax of the RDF remain consistent with the W3C standard, we include core components and definitions of the RDF based on what the standard describes in the W3C specifications [6,8,9,10].

2.3. Temporal RDFs

Reifying temporal data in the RDF presents a significant challenge. To address this, numerous proposals have emerged to facilitate the embedding of temporal data within the RDF. In our review of the existing research on temporal extensions to the RDF spanning the past two decades, we categorized these extensions into three distinct groups [11].

2.3.1. Graph-Level Embedding

In graph-level embedding, temporal data is applied to all RDF triples within an RDF graph. An RDF database can contain one or more RDF graphs. Each RDF graph can be assigned a unique $IRI$, enabling it to be treated similarly to an RDF resource. By utilizing this $IRI$, all the triples within the RDF graph can be referenced.

For example, the named graph approach was developed by Carroll et al. [12] and Tappolet and Bernstein [13]. Carroll et al. defined a named graph as an RDF graph with a URIref, which could be used in the graph itself, in other RDF graphs, or not at all. More formally, all nodes in an RDF graph are V = $U\cup B\cup L$, where U is the set of URIs, B is the set of blank nodes, and L is the set of literals. The set $T=V\times U\times V$ is the set of all RDF triples (or RDF graphs). The set of RDF graphs G is the power set of T. A named graph $ng$ is a pair $(n,g)$ with $n\in U$ and $g\in G$ [12].

The named graph approach is used by the W3C recommendations in the RDF dataset definition, which states that an RDF dataset is a default RDF graph (with no name) and some (zero or more) named graphs. More formally, an RDF dataset is a set of $\{G,(u_1,G_1),(u_2,G_2),...,(u_n,G_n)\}$ where G is the default graph, and $(u_i,G_i)$ is a named graph where $u_i$ is a URIref and $G_i$ is an RDF graph. Each $u_i$ is distinct [6]. The model is shown in Figure 1a.

Graph-level embedding builds upon the named graph specifications in the standard RDF, enabling the assignment of temporal information to a graph composed of a set of standard RDF triples. This technique leverages the simultaneous assignment of temporal data to a set of triples, potentially optimizing time and space usage. Additionally, SPARQL facilitates the selection of graphs using the FROM or FROM NAMED clause. However, for this approach to be effective, all triples within the graph must share the same temporal data. Otherwise, they should be in separate graphs. Furthermore, if frequent temporal changes lead to the creation of numerous named groups, multiple versions of the triples must be introduced and assigned to different named groups. Consequently, managing a large-scale and rapidly evolving knowledge base becomes a complex challenge.

2.3.2. Triple-Level Embedding

Embedding temporal data at the triple level entails associating temporal information with individual RDF triples through various labeling techniques. This approach is characterized by its flexibility and expressive potential, primarily because each RDF triple operates independently. It aligns with the principles found in SQL 2011, which introduces temporal support and aligns with the inherent logic of temporal databases.

With triple level embedding, the fundamental unit that carries temporal data is the RDF triple itself. This approach closely follows the conventional understanding of temporal databases. Notably, some extensions explicitly adopt reification as their method, as exemplified by the Temporal RDF [14], Enhanced Temporal RDF [15], and the Temporal Probabilistic Database Model [16,17]. Others, like RDF+ [18] and RDF Streams [19,20,21], implicitly integrate reification into their processes. Meanwhile, some extensions rely on mapping functions and similar techniques, such as the Bitemporal Knowledge Graph [22] and the multi-temporal RDF [23].

Although the triple-level embedding approaches may necessitate the inclusion of numerous additional triples, they retain simplicity in terms of explanation and representation. This simplicity comes despite the augmented number of triples, and it results in manageable time and space complexities. Furthermore, many of these extensions adhere to RDF standards, making it feasible to build them on top of existing RDF frameworks.

For example, the Temporal RDF was introduced by Gutierrez, et al. to make it possible to incorporate temporal data into the standard RDF [14,15]. This approach handles evolving RDF data models using the labeling solution. The definition of the Temporal RDF begins with a temporal triple $<spo>:\left[t\right]$, where $<spo>$ represents an RDF triple and t denotes the temporal label. In this definition, t is a natural number that indicates a time instant. To denote a time interval, the temporal triple is expressed as $<spo>:[t_1,t_2]$, which is the union of all $<spo>:\left[t\right]$ such that $t_1\le t\le t_2$.

A temporal graph is a collection of temporal triples. It is simple to implement, uses both point-based and interval-based temporal data, and is consistent with the standard definition of RDF [14]. The model is shown in Figure 1b.

2.3.3. Resource-Level Embedding

Resource-level embedding recognizes that temporal information may vary among the subject, predicate, and object of an RDF triple. It considers each individual resource as a carrier of temporal data, instead of treating each triple as an indivisible entity. Many of these extensions focus on the predicate, which signifies the relationship between the subject and object. Examples include Singleton Property [24], aRDF [25], Property Annotated RDF [26], and MRDF [27].

Alternatively, certain extensions focus on the subject and object, representing the entities within the relationship. This is evident in approaches like 4D fluents [28] and RDF* [29,30,31]. Some extensions encompass more than one of these elements or even all of them. Examples include TA-RDF [32], n-ary relations [33,34], and TKB [35,36].

Certain models permit the coexistence of both temporal and non-temporal resources, such as the Temporal RDF(S) Data Graph model [37], while others require that all resources possess temporal attributes, such as the VTRDF model [38] and Temporal Property Graph Model [39]. In a temporal property graph, each node and edge is associated with a (name, interval) pair, where the name represents the RDF resource and the interval represents the valid time interval. Also, a property graph is a type of RDF graph where every node and edge is labeled with a (property, value) pair. If a node or edge is valid for the entire lifespan of the graph, the temporal labels are omitted for simplicity.

Moreover, most of these extensions treat a temporal resource as an instance of a temporal class, essentially treating temporality as an attribute. This approach is evident in extensions like 4D fluents [28], n-ary relations [33,34], and tOWL [40]. Conversely, some extensions employ labeling techniques through reification or mapping, as exemplified by aRDF [25], Temporal Knowledge Base [35,36], and TA-RDF [32].

For instance, Welty and Fikes introduced the 4D fluents model [28] to represent changes in information across time. The central challenge they address is how to logically accommodate the fact that the same entity can appear to be different at various times. Within the 3D perspective, a distinction is made between endurants—entities wholly present at each moment—and perdurants—entities that unfold through temporal segments. In contrast, the 4D or perdurantist perspective asserts that all entities possess temporal parts and thus exist as four-dimensional objects extended through time. The model is depicted in Figure 1c.

A key benefit of the 4D fluents approach is that it associates temporal information directly with the temporal parts, allowing binary fluents to be captured as simple binary relationships between these parts. Each temporal part is bound to a specific interval representing the duration over which the fluent holds. However, modeling a single fluent using this method necessitates two additional entities for the temporal parts and results in six RDF triples—exceeding the number typically involved in standard RDF reification. Nevertheless, the 4D fluents approach offers a notable advantage by leveraging OWL’s built-in reasoning capabilities, including support for transitive and inverse properties.

Figure 1 illustrates representative examples of the three temporal RDF embedding approaches discussed above.

Each of these embeddings addresses specific needs and trade-offs. Graph-level embedding is efficient for batch contexts at a high level; triple-level embedding supports precise modeling at the statement level; resource-level embedding enables the most granular representation but at higher structural cost. Our proposed BiTRDF model is primarily aligned with resource-level embedding, in that each resource is assigned its own valid and transaction time. Furthermore, rather than treating time as any attributes, the theoretical framework developed by Tansel [5,41,42] in temporal databases treats time as temporal references of values, and we built the BiTRDF model upon it.

3. BiTemporal RDF Model

While most temporal RDF models reviewed in the previous section focus on extending the RDF by introducing valid time, we also acknowledge the importance of integrating transaction time into RDF, resulting in what we aim to develop: the BiTemporal RDF Model (BiTRDF) [43]. BiTemporal RDF enhances the traditional RDF by representing both when a fact is valid in the real world and when it is stored or modified in the knowledge base. BiTRDF achieves this by uniformly extending the standard RDF to a bitemporal structure in which all resources and relationships are treated as inherently bitemporal. In the following sections, we will first describe our modeling approach, followed by a formal definition of the model components, associated operations, and query examples.

3.1. Modeling Approaches

Consider the fact that a student named Tom enrolls in a Machine Learning course. Under standard RDF specifications, this fact may be represented as a triple: <Tom enrolls MachineLearning>, where Tom, enrolls, and MachineLearning are RDF resources. This triple is static unless temporal information is explicitly incorporated. If we know when Tom enrolled and when that record was stored, we can enhance the triple with temporal data, enabling temporal-aware reasoning.

RDF resources intrinsically exhibit time attributes, namely when they were created or ceased being used in the system. For instance, the fact that Tom was born on 1 January 1980, and is still alive, a specific valid time interval [1980-1-1, now], reflects the time attribute of the resource named Tom. Similarly, suppose that a Machine Learning course was established on 1 January 1985, and is currently offered, another valid time interval, [1985-1-1, now], provides its time attribute.

Being able to systematically track the history of RDF resources, triples, and graphs provides opportunities for practical temporal querying and historical analysis, while also facilitating proper temporal data integration. This can be achieved by incorporating transaction time into the RDF. For instance, to denote that the resource “Tom” was documented in the knowledge store on 29 August 2008, we need a transaction time interval, [2008-8-29, now] for it. Likewise, to signify that the resource "enroll" was recorded in the knowledge store on 1 January 2020, a transaction time interval, [2020-1-1, now], would be used.

Conventionally, the role of time in a knowledge store is to serve as attribute values associated with predicates or relationships, similar to other eligible resources. For example, the date “1980-1-1” serves as Tom’s “Birthday” attribute. The temporal RDF models reviewed in the previous sections adopted the time attribute approach.

Alternatively, time can also serve as a reference for attributes, instead of being the attribute value itself [41]. For instance, consider a salary attribute of “$45,000”. A valid time reference [2005-1-1, now] indicates that the salary “$45,000” has been valid since 1 January 2005. In addition, a transaction time reference [2004-10-31, now] denotes that the salary “$45,000” was recorded in the knowledge store on 31 October 2004. Figure 2 summarizes and compares these two approaches to handling temporal data.

Our proposed BiTemporal RDF model treats time as a reference, not an attribute. Each resource is associated with a valid time interval (when it is true) and a transaction time interval (when it is recorded). This approach allows the precise tracking of both real-world truth and database recording, supporting advanced historical queries. Our motivation for using reference-based time in BiTRDF includes:

• Flexibility: Different time representations (symbolic, date-based) can be supported without altering data structure.
• Consistency: Separating time from core attribute values avoids semantic ambiguity and improves data alignment.
• Compatibility: Time reference modeling supports future temporal extensions and is more easily aligned with bitemporal database theory.

3.2. Preliminaries

Throughout this paper, we adopt the prefixes “rdf:”, “rdfs:”, and “xsd:” as defined by W3C [10]. Additional namespaces and prefixes for the BiTRDF model are summarized as follows:

• @PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
• @PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
• @PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
• @PREFIX bitrdf: <http://example.org/bitrdf-syntax#>
• @PREFIX bitrdfs: <http://example.org/bitrdf-schema#>
• @PREFIX ex: <http://example.org/example#>
• @PREFIX : <http://example.org/temporal-SW#>

The following symbols and conventions associated with time are used:

• Time: T;
• Time Instants: $T_P$;
• Time Intervals: $T_I$;
• Valid Time Instants: $V{T}_P$;
• Valid Time Intervals: $V{T}_I$;
• Transaction Time Instants: $T{T}_P$;
• Transaction Time Intervals: $T{T}_I$;
• Start of Time: $t_0$. We also use 0 for simplicity;
• End of Time: $t_{\infty }$. We also use ∞ for simplicity;
• Current Time: $t_{now}$. We also use $now$ for simplicity;
• Entire Span of Time: $[t_0,t_{\infty })$. We also use $[0,\infty )$ for simplicity;
• Beginning of a time interval: $t_s$. This represents the lower bound of a time interval $[t_s,t_e)$, where $[t_s,t_e)\in T_I$;
• Ending of a time interval: $t_e$. This represents the upper bound of a time interval $[t_s,t_e)$, where $[t_s,t_e)\in T_I$.

Considering flexibility without losing generality, we use a few types of timestamps. First, calendar dates, such as 1998-1-1, are used as real timestamps in our examples. For simplicity and flexibility, we also use a symbolic representation of time, such as [$t_1$, $t_9$) or [3, 12), where $t_1$, $t_9$, 3, and 12 are time instants. Lastly, we also annotate the timestamp using the XMLSchema datetime type, as follows:

• “1998-01-01T10:00:00”\^^xsd:dateTime

As the BiTemporal RDF model extends the standard RDF model, we follow the established definitions and notations of the standard RDF model [9]. For instance, the set of all IRIs is I, the set of all blank nodes is B, the set of all literals is L, the set of all RDF properties is p, and the set of all RDF resources is $R=(I\cup B\cup L)$. We have also adopted the notation from the Valid Time RDF (VTRDF) model [38].

3.3. BiTemporal Resources

A BiTemporal resource $r^{bit}=(r•vt•tt)$ is an RDF resource $r\in R$ that is temporally referenced to both known valid ($vt\in V{T}_I$) and transaction ($tt\in T{T}_I$) time based on the time referencing approach described in Figure 2. Essentially, this represents a standard RDF resource $r\in R$ associated with two distinct temporal dimensions. To represent a bitemporal resource $r^{bit}\in R^{bit}$, where $R^{bit}$ is the set of bitemporal resources, we use the following components:

• Resource r
  The resource $r\in R$ represents the resource with which the valid time and the transaction time components are associated.
• Valid time $vt$
  The interval $vt\in V{T}_I$ represents the reference time period during which the resource r is valid in its existence. The interval $vt$ can also be denoted as $[v{t}_s,v{t}_e)$, where $v{t}_s$ and $v{t}_e$ represent the beginning and the end of the valid time interval, respectively.
• Transaction time $tt$
  The interval $tt\in T{T}_I$ represents the reference time period during which the resource is recorded in the knowledge store. The interval $tt$ can also be denoted as $[t{t}_s,t{t}_e)$, where $t{t}_s$ and $t{t}_e$ represent the beginning and end of the transaction time interval, respectively.
• The delimiter ‘•’
  The symbol ‘•’ separates the above three components: r, $vt$, and $tt$.

The set of bitemporal resources $R^{bit}=R\times V{T}_I\times T{T}_I=(I\cup B\cup L)\times V{T}_I\times T{T}_I$ is therefore defined as

$$\begin{array}{c}{R}^{bit}=\{r•vt•tt|r\in R\wedge vt\in V{T}_I\wedge tt\in T{T}_I\}\end{array}$$

(1)

where the ∧ is the logical AND operator.

3.3.1. Resource Projection Operator

The projection operator ${\Pi }_k$ extracts information from a bitemporal resource based on the specified projection dimension k. A bitemporal $r^{bit}$ projected to its k dimension, ${\Pi }_k(r^{bit})$, is defined as

$$\begin{array}{c}{\Pi }_k(r^{bit})=f_k:r^{bit}\to k\\ \mathrm{where}k\in \{r,vt,v{t}_s,v{t}_e,tt,t{t}_s,t{t}_e\},\\ r^{bit}\in R^{bit},r\in R,vt,tt\in T_I,\mathrm{and}v{t}_s,v{t}_e,t{t}_s,t{t}_e\in T_P.\end{array}$$

(2)

Let $r^{bit}\in R^{bit}$ be a bitemporal resource and $k\in \{r,vt,v{t}_s,v{t}_e,tt,t{t}_s,t{t}_e\}$ be the set of projection dimensions. The projection operator works as follows:

• Resource Projection
  The projection operator projects a bitemporal resource to its resource component:

  $${\Pi }_r(r^{bit})=r^{bit}.r=r$$

  (3)
• Valid Time Projection
  The valid time projection operator projects a bitemporal resource to its valid time component:

  $$\begin{array}{c}\hfill {\Pi }_{vt}(r^{bit})=r^{bit}.vt=vt\end{array}$$

  (4)

  $$\begin{array}{c}\hfill {\Pi }_{v{t}_s}(r^{bit})=r^{bit}.v{t}_s=v{t}_s\end{array}$$

  (5)

  $$\begin{array}{c}\hfill {\Pi }_{v{t}_e}(r^{bit})=r^{bit}.v{t}_e=v{t}_e\end{array}$$

  (6)
• Transaction Time Projection
  The transaction time projection operator projects a bitemporal resource to its transaction time component:

  $$\begin{array}{c}\hfill {\Pi }_{tt}(r^{bit})=r^{bit}.tt=tt\end{array}$$

  (7)

  $$\begin{array}{c}\hfill {\Pi }_{t{t}_s}(r^{bit})=r^{bit}.t{t}_s=t{t}_s\end{array}$$

  (8)

  $$\begin{array}{c}\hfill {\Pi }_{t{t}_e}(r^{bit})=r^{bit}.t{t}_e=t{t}_e\end{array}$$

  (9)

The projection operation and the relationships among the bitemporal resource and its projection dimensions are depicted in Figure 3.

As in the standard RDF model where the set of RDF resources is defined as $R=(I\cup B\cup L)$, with the projection operator we extend the definition to the bitemporal version, $R^{bit}=(I^{bit}\cup B^{bit}\cup L^{bit})$, where each element is defined as follows:

• Bitemporal IRIs, denoted as $I^{bit}$, are defined as

  $$\begin{array}{c}{I}^{bit}=\left\{r^{bit}\right|r^{bit}\in R^{bit}\wedge r^{bit}.r\in I\wedge r^{bit}.vt\in V{T}_I\wedge r^{bit}.tt\in T{T}_I\}\end{array}$$

  (10)
• Bitemporal blank nodes, denoted as $B^{bit}$, are defined as

  $$\begin{array}{c}{B}^{bit}=\left\{r^{bit}\right|r^{bit}\in R^{bit}\wedge r^{bit}.r\in B\wedge r^{bit}.vt\in V{T}_I\wedge r^{bit}.tt\in T{T}_I\}\end{array}$$

  (11)
• Bitemporal literals, denoted as $L^{bit}$, is defined as

  $$\begin{array}{c}{L}^{bit}=\left\{r^{bit}\right|r^{bit}\in R^{bit}\wedge r^{bit}.r\in L\wedge r^{bit}.vt=[t_0,t_{\infty })\wedge r^{bit}.tt=[t_0,t_{\infty })\}\end{array}$$

  (12)

For simplicity, the temporal reference of all bitemporal literals $l^{bit}\in L^{bit}$ defaults to the entire span of valid and transaction times shown in Expression (12) unless otherwise specified.

3.3.2. Bitemporal Property

A bitemporal property $p^{bit}=(p•vt•tt)$ is an RDF property $p\in P$ that is temporally referenced to both the known valid ($vt\in V{T}_I$) and transaction ($tt\in T{T}_I$) time. Essentially, this means that it is a standard RDF property $p\in P$ associated with two distinct temporal dimensions that denote its validity time interval and the interval when it is recorded in the knowledge store. The set of $p^{bit}$ constitutes $P^{bit}=P\times V{T}_I\times T{T}_I$.

3.3.3. Resource Rollback Operator

The rollback operator ${\delta }_t$ returns to a time interval $t_I\in T_I$ of a previous state in the knowledge store. It is devised mainly for the transaction time component from bitemporal resources and continues to work with bitemporal triples and bitemporal RDF graphs. Let $r^{bit}$ be a bitemporal resource and $t_I\in T_I$ be a time interval that denotes a previous state. The rollback of a bitemporal resource, ${\delta }_{t_I}(r^{bit})$, is defined as

$$\begin{array}{c}{\delta }_{t_I}(r^{bit})=\left\{\begin{array}{cc}{r}^{\prime }•v{t}^{\prime }•t{t}^{\prime }\hfill & \begin{array}{c}\hfill \mathrm{if}{r}^{bit}\in R^{bit}\wedge r^{\prime }=r^{bit}.r\wedge v{t}^{\prime }=r^{bit}.vt\wedge \\ \hfill t{t}^{\prime }=t_I\cap r^{bit}.tt\wedge t{t}^{\prime }\ne \varnothing \end{array}\hfill \\ \mathrm{undefined}\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

(13)

For the special case of a time instant as a previous state, t can be represented as an interval, $t_I^{\prime }=[t,t+1)$. Hence, ${\delta }_{t_I}$ can be written as

$$\begin{array}{c}{\delta }_{t_I}(r^{bit})=\left\{\begin{array}{cc}{r}^{\prime }•v{t}^{\prime }•t_I^{\prime }\hfill & \mathrm{if}{r}^{bit}\in R^{bit}\wedge r^{\prime }=r^{bit}.r\wedge v{t}^{\prime }=r^{bit}.vt\wedge t_I^{\prime }\subseteq r^{bit}.tt\hfill \\ \mathrm{undefined}\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

(14)

3.3.4. Bitemporal Data Type

Let D be the set of standard RDF data types, $[t_0,t_{\infty })$ be the entire span of time, and $D^{bit}=D\times [t_0,t_{\infty })\times [t_0,t_{\infty })$ be the Cartesian product. A bitemporal data type, $d^{bit}\in D^{bit}$, is a data type defined in the standard RDF with default entire span of valid and transaction times. Bitemporal data types are used to represent bitemporal literals, which have a default entire span of the valid and transaction times.

3.4. Bitemporal Triples

A bitemporal triple, denoted as $<s^{bit}{p}^{bit}{o}^{bit}>$, follows the format of a standard RDF triple, where $s^{bit}$, $p^{bit}$, and $o^{bit}$ represent the subject, predicate, and object of the bitemporal triple respectively. In Section 3.3, we categorized bitemporal resources into three subsets: $I^{bit}$, representing bitemporal IRIs with IRI value components; $B^{bit}$, denoting bitemporal blank nodes whose value components are blank nodes; and $L^{bit}$, referring to bitemporal literals with literal value components. In addition, we defined the set of bitemporal properties as $P^{bit}$.

The set of bitemporal triples, $TRIPL{E}^{bit}=(I^{bit}\cup B^{bit})\times P^{bit}\times (I^{bit}\cup B^{bit}\cup L^{bit})$, is defined as

$$\begin{array}{c}TRIPL{E}^{bit}=\{<s^{bit}{p}^{bit}{o}^{bit}>\mid s^{bit}\in (I^{bit}\cup B^{bit})\wedge p^{bit}\in P^{bit}\wedge \\ o^{bit}\in (I^{bit}\cup B^{bit}\cup L^{bit})\wedge \\ p^{bit}.vt\ne \varnothing \wedge p^{bit}.tt\ne \varnothing \wedge \\ \forall t(t\in p^{bit}.tt\wedge p^{bit}.tt\subseteq (s^{bit}.tt\cap o^{bit}.tt)\wedge s^{bit}.tt\cap o^{bit}.tt\ne \varnothing )\to \\ (p^{bit}.vt\subseteq (s^{bit}.vt\cap o^{bit}.vt)\wedge s^{bit}.vt\cap o^{bit}.vt\ne \varnothing )\}\end{array}$$

(15)

3.4.1. BiTemporal Triple Integrity

For any bitemporal triple to conserve temporal semantics, an integrity constraint, called BiTemporal Triple Integrity, over the predicate $p^{bit}$ is necessary. Let $<s^{bit}{p}^{bit}{o}^{bit}>$ be a bitemporal triple. BiTemporal Triple Integrity is defined as follows:

$$\begin{array}{c}\forall t(t\in p^{bit}.tt\wedge p^{bit}.tt\subseteq (s^{bit}.tt\cap o^{bit}.tt)\wedge s^{bit}.tt\cap o^{bit}.tt\ne \varnothing )\to \\ (p^{bit}.vt\subseteq (s^{bit}.vt\cap o^{bit}.vt)\wedge s^{bit}.vt\cap o^{bit}.vt\ne \varnothing )\end{array}$$

(16)

In a bitemporal triple $<s^{bit}{p}^{bit}{o}^{bit}>$, the bitemporal property $p^{bit}$ defines a relationship between the subject $s^{bit}$ and the object $o^{bit}$. For this relationship to be valid, both the subject and object must coexist during the same temporal span. As an example, a person cannot live in a city before being born, just as a student cannot enroll in a course prior to its creation. Unlike standard RDF triples—which do not impose temporal constraints—a bitemporal triple must satisfy a temporal integrity condition. Specifically, for every transaction time instant t within the transaction time interval of $p^{bit}$, the valid time interval of $p^{bit}$ must be a nonempty subset of the intersection of the valid time intervals of $s^{bit}$ and $o^{bit}$; similarly, the transaction time interval of $p^{bit}$ must be a nonempty subset of the intersection of the transaction time intervals of $s^{bit}$ and $o^{bit}$.

3.4.2. Triple Projection Operator

We define the triple projection operator applied to a bitemporal triple as

$${\Pi }_k(<s^{bit}{p}^{bit}{o}^{bit}>)=f_k:<s^{bit}{p}^{bit}{o}^{bit}>\to r^{bit}$$

(17)

where $k\in \{s^{bit},p^{bit},o^{bit}\}$, and $s^{bit}$, $p^{bit}$, and $o^{bit}$ correspond to the subject, the predicate, and the object in a triple, $<s^{bit}{p}^{bit}{o}^{bit}>\in TRIPL{E}^{bit}$, and $r^{bit}\in R^{bit}$.

Let $<s^{bit}{p}^{bit}{o}^{bit}>$ be a bitemporal triple. The triple projection operator works as follows:

$$\begin{array}{c}\hfill {\Pi }_{s^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>)=s^{bit}\end{array}$$

(18)

$$\begin{array}{c}\hfill {\Pi }_{p^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>)=p^{bit}\end{array}$$

(19)

$$\begin{array}{c}\hfill {\Pi }_{o^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>)=o^{bit}\end{array}$$

(20)

3.4.3. Triple Rollback Operator

Based on the resource rollback operator defined in Expression 13, we derive the triple rollback operator, ${\delta }_{t_I}$. Let $<s^{bit}{p}^{bit}{o}^{bit}>$ be a bitemporal triple and $t_I$ be a non empty time interval, and the triple rollback operator is defined as

$$\begin{array}{c}{\delta }_{t_I}(<s^{bit}{p}^{bit}{o}^{bit}>)=\left\{\begin{array}{cc}<s_1^{bit}{p}_1^{bit}{o}_1^{bit}>\hfill & \begin{array}{c}\hfill \mathrm{if}<s^{bit}{p}^{bit}{o}^{bit}>\in TRIPL{E}^{bit}\wedge \\ \hfill t{t}^{\prime }=(t_I\cap s^{bit}.tt\cap p^{bit}.tt\cap o^{bit}.tt)\wedge \\ \hfill t{t}^{\prime }\ne \varnothing \wedge \\ \hfill s_1^{bit}={\delta }_{t{t}^{\prime }}(s^{bit})\wedge \\ \hfill p_1^{bit}={\delta }_{t{t}^{\prime }}(p^{bit})\wedge \\ \hfill o_1^{bit}={\delta }_{t{t}^{\prime }}(o^{bit})\end{array}\hfill \\ \mathrm{undefined}\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

(21)

where the subscript 1 represents the triple obtained from the rollback operation.

3.4.4. Bitemporal Underlying Triple

Let $<s^{bit}{p}^{bit}{o}^{bit}>$ be a bitemporal triple. Its underlying triple is defined as follows:

$$\begin{array}{c}u(<s^{bit}{p}^{bit}{o}^{bit}>)=\{<s_1{p}_1{o}_1>|<s^{bit}{p}^{bit}{o}^{bit}>\in TRIPL{E}^{bit}\wedge \\ s_1={\Pi }_r({\Pi }_{s^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>))\wedge \\ p_1={\Pi }_r({\Pi }_{p^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>))\wedge \\ o_1={\Pi }_r({\Pi }_{o^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>))\}\end{array}$$

(22)

The underlying triple of a bitemporal is a standard RDF triple.

3.5. Bitemporal Graphs

A bitemporal RDF graph, $G^{bit}$, is a set of unmergeable bitemporal triples. The set of bitemporal RDF graphs, denoted as $BiTG$, is defined as

$$r\begin{array}{c}BiTG=\{<s^{bit}{p}^{bit}{o}^{bit}>\mid <s^{bit}{p}^{bit}{o}^{bit}>\in TRIPL{E}^{bit}\wedge \\ \forall t(t\in (s^{bit}.tt\cap o^{bit}.tt\cap p^{bit}.tt)\to \\ \neg \exists <a^{bit}{b}^{bit}{c}^{bit}>(<a^{bit}{b}^{bit}{c}^{bit}>\in TRIPL{E}^{bit})\wedge \\ ((s^{bit}.r=a^{bit}.r\wedge p^{bit}.r=b^{bit}.r\wedge o^{bit}.r=c^{bit}.r)\wedge \\ (s^{bit}.vt\cap a^{bit}.vt\ne \varnothing \vee s^{bit}.v{t}_e=a^{bit}.v{t}_s)\wedge s^{bit}.tt\cap a^{bit}.tt\ne \varnothing )\wedge \\ (p^{bit}.vt\cap b^{bit}.vt\ne \varnothing \vee p^{bit}.v{t}_e=b^{bit}.v{t}_s)\wedge p^{bit}.tt\cap b^{bit}.tt\ne \varnothing \wedge \\ (o^{bit}.vt\cap c^{bit}.vt\ne \varnothing \vee o^{bit}.v{t}_e=c^{bit}.v{t}_s)\wedge o^{bit}.tt\cap c^{bit}.tt\ne \varnothing \vee \\ \neg \exists <a^{bit}{b}^{bit}{c}^{bit}>(s^{bit}.r=c^{bit}.r\wedge s^{bit}.vt\cap c^{bit}.vt\ne \varnothing \wedge s^{bit}.tt\cap c^{bit}.tt\ne \varnothing )\vee \\ \neg \exists <a^{bit}{b}^{bit}{c}^{bit}>(o^{bit}.r=a^{bit}.r\wedge o^{bit}.vt\cap a^{bit}.vt\ne \varnothing \wedge o^{bit}.tt\cap a^{bit}.tt\ne \varnothing ))\}\end{array}$$

(23)

If two bitemporal triples share identical subject, predicate, and object values, their valid time intervals must be disjointed for all time instants within the intersection of their respective transaction time intervals. Bitemporal triples that violate this condition are not permitted within a bitemporal RDF graph.

3.5.1. Rollback Operator

Let $G^{bit}$ be a bitemporal RDF graph and $t_I$ be a time interval.

$$\begin{array}{c}{\delta }_{t_I}(G^{bit})=\{<s_1^{bit}{p}_1^{bit}{o}_1^{bit}>|<s^{bit}{p}^{bit}{o}^{bit}>\in G^{bit}\wedge \\ <s_1^{bit}{p}_1^{bit}{o}_1^{bit}>={\delta }_{t_I}(<s^{bit}{p}^{bit}{o}^{bit}>)\}\end{array}$$

(24)

3.5.2. Time Slice Operator

Let $G^{bit}$ be a bitemporal RDF graph, $i_I$, and $t_I$ be time intervals. We define the Time Slice Operator $\mathbb{TS}$ where $i_I$ represents valid time and $t_I$ represents transaction time.

$$\begin{array}{c}{\mathbb{TS}}_{i_I{t}_I}(G^{bit})=\{<s_1^{bit}{p}_1^{bit}{o}_1^{bit}>\mid <s^{bit}{p}^{bit}{o}^{bit}>\in {\delta }_{t_I}(G^{bit})\wedge \\ s_1^{bit}.r=s^{bit}.r\wedge p_1^{bit}.r=p^{bit}.r\wedge o_1^{bit}.r=o^{bit}.r\wedge \\ i_I^{\prime }=(i_I\cap s^{bit}.vt\cap p^{bit}.vt\cap o^{bit}.vt)\wedge i_I^{\prime }\ne \varnothing \wedge \\ s_1^{bit}.vt=i_I^{\prime }\wedge p_1^{bit}.vt=i_I^{\prime }\wedge o_1^{bit}.vt=i_I^{\prime }\wedge \\ s_1^{bit}.tt=s^{bit}.tt\wedge p_1^{bit}.tt=p^{bit}.tt\wedge o_1^{bit}.tt=o^{bit}.tt\}\end{array}$$

(25)

3.5.3. Bitemporal RDF Subgraph

A bitemporal RDF graph $G_1^{bit}$ is a subgraph of another bitemporal RDF graph $G_2^{bit}$ if:

• The set of bitemporal triples in $G_1^{bit}$ is a subset of bitemporal triples in $G_2^{bit}$, or 
• $G_1^{bit}$ is the result of ${\delta }_{t_I}(G_2^{bit})$, or 
• $G_1^{bit}$ is the result of $\mathbb{TS}(G_2^{bit})$.

3.5.4. Bitemporal RDF Underlying Graph

Let $G^{bit}$ be a bitemporal RDF graph, $G^{bit}\in BiTG$. The underlying graph $u(G^{bit})$ is defined as

$$\begin{array}{c}u(G^{bit})=\{<s_1{p}_1{o}_1>|<s^{bit}{p}^{bit}{o}^{bit}>\in G^{bit}\wedge \\ s_1={\Pi }_r({\Pi }_{s^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>))\wedge \\ p_1={\Pi }_r({\Pi }_{p^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>))\wedge \\ o_1={\Pi }_r({\Pi }_{o^{bit}}(<s^{bit}{p}^{bit}{o}^{bit}>))\}\end{array}$$

(26)

3.5.5. Bitemporal RDF Mapping Function

A mapping function, $M^{bit}:(I^{bit}\cup B^{bit}\cup L^{bit})\to (I^{bit}\cup B^{bit}\cup L^{bit})$, maps a bitemporal IRI, a bitemporal blank node, or a bitemporal literal to a bitemporal IRI, a bitemporal blank node, or a bitemporal literal. $M^{bit}$ is defined to map elements in a bitemporal RDF graph $G_1^{bit}$ to a bitemporal RDF graph $G_2^{bit}$. Let $G_1^{bit}$ and $G_2^{bit}$ be two bitemporal RDF graphs, $i^{bit}$ be a bitemporal IRI, $b^{bit}$ be a bitemporal black node, and $l^{bit}$ be a bitemporal literal. The bitemporal resource-level mapping cases are defined as

• $M^{bit}(i_1^{bit})\to i_2^{bit}$, where $i_1^{bit}$ appears as a node in $G_1^{bit}$, $i_2^{bit}$ appears as a node in $G_2^{bit}$, and $i_1^{bit}.r=i_2^{bit}.r$.
• $M^{bit}(l_1^{bit})\to l_2^{bit}$, where $l_1^{bit}$ appears as a node in $G_1^{bit}$, $l_2^{bit}$ appears as a node in $G_2^{bit}$, and $l_1^{bit}.r=l_2^{bit}.r$.
• $M^{bit}(b^{bit})\to i^{bit}$, where $b^{bit}$ appears as a node in $G_1^{bit}$, $i^{bit}$ appears as a node in $G_2^{bit}$, and $b^{bit}.r=i^{bit}.r$.
• $M^{bit}(b_1^{bit})\to b_2^{bit}$, where $b_1^{bit}$ appears as a node in $G_1^{bit}$, and $b_2^{bit}$ appears as a node in $G_2^{bit}$.

3.6. Vocabulary, Semantics, and Entailment

We adopt the design philosophy of the standard RDF specification, which distinctly separates syntactic representation from semantic interpretation. As demonstrated in previous sections, BiTRDF preserves the core RDF triple structure while adding temporal semantics through a set of dedicated vocabulary. This ensures compatibility with all standard RDF serializations, such as Turtle, N-Triples, RDF/XML, and JSON, etc. As a result, temporal annotations appear as regular RDF triples using our defined namespaces, and no syntax-specific modifications are required. As we illustrate key semantic patterns of the BiTRDF model through concrete examples, the complete formal semantics will be fully elaborated in subsequent work to maintain clarity and brevity here.

Our BiTemporal RDF model extends the standard RDF model’s theoretic semantics by introducing a dual-layer semantic architecture that simultaneously captures the transaction time and valid time. The first layer (valid time) defines the period during which a fact is true in the real world, whereas the second layer (transaction time) records when the fact is added or changed in the knowledge store. Each layer functions independently yet interacts via temporal integrity rules. For instance, a fact’s valid time cannot precede its transaction time. This separation supports both temporal dimensions while staying rooted in the RDF model’s theoretic foundations.

BiTRDF introduces a small set of core vocabularies to support bitemporal semantics:

bitrdf:type, bitrdf:Property

bitrdfs:domain, bitrdfs:range, bitrdfs:Class, bitrdfs:subClassOf, bitrdfs:subPropertyOf

To make the BiTRDF model semantics intuitive, we demonstrate how the model captures and reasons about temporal relationships and knowledge through examples using the core vocabularies. Since BiTRDF extends RDF at the semantic level without altering its fundamental triple structure, it is serialization-agnostic. It can be represented in any RDF-compliant syntax (e.g., Turtle, N-Triples, RDF/XML) using the appropriate namespaces and annotations.

3.6.1. Example 1: Bitemporal Type Propagation

Consider the following bitemporal triples in Figure 4.

In this example, :NY is explicitly declared as being of type :state, as indicated by the first triple in Figure 4. This declaration holds true throughout the entire timeline, both in the transaction time and valid time. The second triple establishes that Tom has a :livesIn relationship with :NY during the valid interval [5,10), which is stored in the knowledge store during the same period. This temporal alignment enables the inference of new triples for the knowledge store. Given that individuals typically reside in states or regions, and Tom is stated to live in :NY, we can logically deduce that Tom is a :person. Furthermore, the relationship :livesIn is a property, which implies that it should also have a declared type in the model. These inferences are shown in Figure 5.

For Tom’s being a :person, the valid time and the transaction time intervals with a bitrdf:type relationship must align with Tom’s temporal information, which is [1, now][1, now]. This indicates that Tom has been considered a person from the moment he exists until the present moment. Alternatively, the transaction time interval of bitrdf:type could be set to the moment the inference is executed and the inferred triple needs to be inserted into the knowledge store. This approach reflects a more dynamic perspective, where the bitrdf:type relationship is valid at the time the inference is made, regardless of Tom’s transaction time interval.

Additionally, the :livesIn property is similarly inferred within the BiTRDF context. Its valid time and transaction time intervals initially inherit those of the original triple [5,10)[5,10), representing when Tom’s residence in :NY is valid and recorded. The property bitrdf:Property has the valid time and the transaction time intervals of [0, now], which is general or universal, covering its entire existence without specific temporal constraints. Since the :livesIn property may appear in other triples, the valid time and the transaction time intervals must be unified. In this process, the union operation consolidates the temporal elements from multiple instances of the :livesIn property. For simplicity and convenience, we transform the inferred triple to make both the valid time and the transaction time intervals of :livesIn [0, now]. In other words, we can deduce that :livesIn exists universally for all entities and is applicable throughout the entire valid time and transaction time intervals, which is represented as [0, now].

3.6.2. Example 2: Bitemporal Domain-Range Inheritance

Consider the following bitemporal triples in Figure 6, which define the domain and range of the property as a bitemporal attribute.

Based on these triples, we can infer additional triples, as shown in Figure 7. In standard RDF inference, the process is relatively simple: we infer entity types based on the domain and range of properties. However, in a biemporal model, we must not only infer these relationships but also determine the valid time and the transaction time intervals for each inferred triple. This involves aligning the temporal information of the entities and the properties in the triples. For example, when associating Tom with the :person class, the valid time and the transaction time intervals of the bitrdf:type property must align with Tom’s own temporal data, which is recorded as [1, now][1, now]. This indicates that Tom’s association with the class was recorded at time 1 and remains valid up to the present moment. Additionally, the valid time intervals for the object resources, :person and :course, in Figure 7 are both ([0, now]). This implies that these resources have been considered valid from the moment they are defined (at time 0) and remain valid until now, reflecting their ongoing validity status in the knowledge base. Similarly, the property bitrdf:type between :DB and :course inherits the valid time and the transaction time intervals from the original triple involving :DB, which is [0, now][10, now]. This indicates that the fact of :DB being associated with :course was recorded or defined at time 0 and became valid at time 10 until now, aligning with its specified temporal constraints.

3.6.3. Example 3: Bitemporal Subclass Transitivity

Consider the following bitemporal triples in Figure 8, which define the class hierarchy.

In this example, the transitive nature of subclass relationships allows us to deduce additional knowledge. Since :Tom is an :instructor, which is a subclass of :person, and :person is a :Human, we can infer that :Tom is also a :Human, as shown in Figure 9. The two subclass properties in the bitemporal triples represent general properties within the knowledge base. Therefore, their valid time and transaction time intervals are set to [0, now][0, now]. This indicates that these properties are not specifically associated with individual entities and are applicable universally across the entire knowledge base. They are not tied to any specific time when they are defined or used. The valid time and the transaction time intervals for the bitrdf:type property in the inferred triple align with the property describing :Tom as a type of :instructor in the original triple, ensuring temporal consistency and validity in the knowledge base.

3.6.4. Example 4: Temporal Property Transitivity

Consider the following bitemporal triples in Figure 10 that define the transitive property.

In this semantic example, we consider that :FIEDept and :SchoolOfBusiness were both established at time 10, while :CUNY has existed since time 0. This affects the valid time intervals in the knowledge base: both :FIEDept and :SchoolOfBusiness are assigned a factual valid time interval of [10, now], reflecting their establishment at time 10. In contrast, :CUNY has a valid time starting from 0, indicating its long-standing presence. This context allows us to infer that :Tom’s affiliation with :CUNY is an indirect result of his relationship with :FIEDept, which is part of :SchoolOfBusiness, itself a component of :CUNY.

Using the transitive property of :isPartOf and the fact that :worksAt is a sub-property of :isPartOf, we can infer the relationship :Tom :isPartOf :CUNY with both a valid time of [10, now] and a transaction time of [10, now], as shown in Figure 11. The valid time [10, now] for this inferred triple aligns with the establishment of :FIEDept and :SchoolOfBusiness, making this association valid only from time 10, despite :CUNY’s existence since time 0. The transaction time [10, now] shows that this knowledge about :Tom’s association with :CUNY was first recorded at time 10, consistent with the creation of both :FIEDept and :SchoolOfBusiness. This bitemporal framework ensures temporal consistency, representing :Tom’s inferred affiliation within the historical structure of :CUNY.

3.7. Querying Bitemporal Databases

While our current work focuses on the definitions of the BiTemporal RDF model, we recognize the need for a corresponding query language to fully realize its potential. Building on the query language for our earlier Valid Time RDF model, VT-SPARQL [38], we propose prototyping Bitemporal SPARQL (BT-SPARQL) as a natural extension shown in Figure 12. BT-SPARQL would retain the essential constructs of SPARQL while introducing mechanisms to query across both valid time and transaction time dimensions. Key features of BT-SPARQL would include (1) support for bitemporal resource variables, such as {?x.vt.tt}, (2) extended dot notation to project either temporal component, (3) temporal predicates—including Allen’s temporal relations [44]—for both valid time and transaction time dimensions, and (4) implicit enforcement of Bitemporal Triple Integrity, as defined in Section 3.4.1. The grammar would extend VT-SPARQL’s SELECT and CONSTRUCT clauses to support bitemporal patterns, and also incorporate filters to express cross-dimensional constraints. For example, it could retrieve resources that were valid during the interval I but recorded in the database after time t. We defer full formalization to future work, as the semantics of bitemporal operators require careful design, particularly when the transaction time evolves and overlaps in the database. Nevertheless, below is an example query based on our preliminary BT-SPARQL prototype.

4. Discussion

We illustrate the practical use of the BiTRDF model through a case study in Figure 13 that exemplifies its unique capacity to simultaneously track valid time and transaction time in knowledge representation.

For conciseness, we represent dates as integers (e.g., 1 or 2), where 0 denotes the temporal origin $t_0$ and $now$ represents the current time $t_{now}$. The progression of this BiTRDF knowledge store is detailed as follows:

4.1. Time 0

At time 0, the BiTRDF knowledge store was initialized with three bitemporal triples. These represent state types NJ, NY, and CO. The initial state of the knowledge store at time 0 contains the following:

• :NJ[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :NY[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :CO[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .

4.2. Time 1

At time 1, Tom was noted in the BiTRDF knowledge store as a person, and it was also recorded that Tom lives in NJ. The “livesIn” predicate carried the bitemporal component [1,now][1,now], indicating its currency at time 1. The BiTRDF knowledge store at time 1 is represented as follows:

• :NJ[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :NY[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :CO[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :Tom[1,now][1,now] bitrdf:type[1,now][1,now] :person[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[1,now][1,now] :NJ[0,now][0,now] .

4.3. Time 5

At time 5, Tom moved to NY. The BiTRDF knowledge store is therefore updated as follows:

• For the predicate :livesIn[1,now][1,now] in the triple, the valid time interval was adjusted to [1,5). This indicates that the predicate is no longer valid after time 5. Similarly, the transaction time interval changed to [1,5), reflecting that the triple was updated at time 5.
• We then added a bitemporal triple to capture that “Tom lives in NY” at time 5. In this new triple, the predicate :livesIn[5,now][5,now] has a valid time interval of [5,now], signifying its validity from time 5 onwards. Its transaction time interval is also [5,now], showing that this triple was recorded at time 5.

The BiTRDF knowledge store at time 5 is as follows:

• :NJ[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :NY[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :CO[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :Tom[1,now][1,now] bitrdf:type[1,now][1,now] :person[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[1,5)[1,5) :NJ[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[5,now][5,now] :NY[0,now][0,now] .

4.4. Time 10

At time 10, Tom moved to CO. We updated the BiTRDF knowledge store as follows:

• The predicate :livesIn[5,now][5,now] within the triple saw its valid time interval updated to [5,10), signifying that the predicate is no longer valid past time 10. Concurrently, the transaction time interval shifted to [5,10), indicating the triple’s update at time 10.
• A new bitemporal triple was then introduced to show that “Tom lives in CO” at time 10. In this new triple, the predicate :livesIn[10,now][10,now] has a valid time interval of [10,now], confirming its validity from time 10 onward. Its transaction time interval is also [10,now], denoting that this triple was recorded at time 10.

At time 10, we also recorded the following information in the BiTRDF knowledge store: (1) Tom works at CU (University of Colorado); (2) Tom teaches DB (Database); (3) DB has textbook DBText; (4) the price of DBText is 15; (5) Tom teaches ML (Machine Learning); (6) ML has textbook MLText; and (7) the price of MLText is 30. The BiTRDF knowledge store at time 10 is as follows:

• :NJ[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :NY[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :CO[0,now][0,now] bitrdf:type[0,now][0,now] :state[0,now][0,now] .
• :Tom[1,now][1,now] bitrdf:type[1,now][1,now] :person[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[1,5)[1,5) :NJ[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[5,10)[5,10) :NY[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[10,now][10,now] :CO[0,now][0,now] .
• :Tom[1,now][1,now] :worksAt[10,now][10,now] :CU[0,now][10,now] .
• :Tom[1,now][1,now] :teaches[10,now][10,now] :DB[0,now][10,now] .
• :Tom[1,now][1,now] :teaches[10,now][10,now] :ML[0,now][10,now] .
• :DB[0,now][10,now] :book[10,now][10,now] :DBText[10,now][10,now] .
• :ML[0,now][10,now] :book[10,now][10,now] :MLText[10,now][10,now] .
• :DBText[10,now][10,now] :price[10,now][10,now] 15[0,now][10,now] .
• :MLText[10,now][10,now] :price[10,now][10,now] 30[0,now][10,now] .

The evolution of a part of the sample BiTRDF knowledge store below is shown in Figure 14. Since the subject of all triples is the same, Tom, we only show the predicates in the figure for simplicity.

• :Tom[1,now][1,now] :livesIn[1,5)[1,5) :NJ[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[5,10)[5,10) :NY[0,now][0,now] .
• :Tom[1,now][1,now] :livesIn[10,now][10,now] :CO[0,now][0,now] .

5. Conclusions

5.1. Benefits

This paper presents the BiTemporal RDF (BiTRDF) model, an extension to the RDF that incorporates both valid time and transaction time through a reference-based approach. By treating time as a reference rather than as an attribute, BiTRDF simplifies semantic interpretation while expanding the expressiveness of the RDF for representing temporal knowledge.

A key strength of BiTRDF lies in its universal treatment of all resources and relationships as bitemporal. This enables the consistent modeling of temporal dimensions across subjects, predicates, and objects, supporting historical traceability, semantic inference, and data integrity enforcement through temporal alignment constraints. Unlike other temporal RDF approaches that treat temporality as an external construct, BiTRDF integrates temporal reasoning directly into the model structure.

Examples and user cases in the paper demonstrate how BiTRDF supports type propagation, domain-range inference, and temporal transitivity. The model’s operators—including projection, rollback, and time slicing—provide mechanisms for navigating temporal data without modifying the underlying RDF structure.

5.2. Limitations and Future Direction

While BiTRDF offers a strong theoretical foundation, its practical realization requires tremendous future work. One critical direction is the development of query language extensions to support time-aware operations such as rollback, time slicing, and bitemporal joins. These features will require extending SPARQL aligned with BiTRDF semantics. The dual time dimensions in BiTRDF inevitably increase data volume and complexity. To address this, we plan to investigate efficient storage and retrieval techniques, particularly indexing structures optimized for bitemporal data. For instance, the skip-list-based bitemporal RDF index proposed by Zhang et al. [45] offers a promising foundation for performance improvements. Implementation pathways are also under consideration. Rather than replacing the existing RDF infrastructure, BiTRDF may be layered onto current triple stores using annotation schemes or middleware translation [42].

Applying BiTRDF to existing RDF databases raises compatibility challenges, particularly when handling legacy data with missing or incomplete temporal annotations. For instance, temporal context or quantifiers in Wikidata are often inconsistent or sparse [46]. Similar issues are likely to arise in practical settings, such as enterprise knowledge graphs. Future research will investigate strategies to support incremental adoption in legacy systems, including (1) intelligent defaulting mechanisms that assign now for current factual assertions and UNKNOWN for historical facts, (2) techniques for partial temporal annotation propagation, and (3) mapping procedures for legacy system integration. As an example, our model would default the valid time to now for factual assertions and UNKNOWN for historical facts. Furthermore, we plan to explore probabilistic extensions to the bitemporal model based on the probabilistic temporal knowledge graph in [22] to handle uncertainty in temporal assertions.

To validate the model in real-world scenarios, we plan to conduct empirical studies focused on scalability, query performance, and semantic reasoning. Comparisons with RDF*, RDF4J, and native bitemporal databases will help position BiTRDF within the broader landscape of temporal data models. Lastly, although the present work focuses exclusively on time, the design of BiTRDF can naturally extend to support additional dimensions such as location, confidence levels, and provenance. It may also be adapted for RDF stream processing applications where temporal granularity and update semantics are critical.

In summary, BiTRDF bridges temporal database theory and Semantic Web modeling, offering a uniform and extensible framework for representing and reasoning over bitemporal knowledge. Its contribution lies in its expressive simplicity, formal precision, and potential for integration with both traditional RDF infrastructure and emerging temporal applications.