Capturing temporal dimension of linked data


The article provides an overview of the existing approaches for capturing temporal dimension of linked data within the limits of RDF data model. Best-of-breed techniques for representing temporally varying data are compared and both their advantages and disadvantages are summarized with a special respect to linked data. Common issues and requirements for the proposed data models are discussed. Modelling patterns based on named graphs and concepts drawn from four-dimensionalism are held to be well suited for the needs of linked data on the Web.

The world is in flux; models and datasets about the world have to co-evolve with it in order to retain their value. The nascent web of data can be thought of as a global model of the world, which, as such model, is a subject to change. The nature of the Web content is dynamic as both individual resources and links between them change frequently.

Facts are time-indexed and as such may cease to be valid, being superseded by newly acquired knowledge. Even though some knowledge of encyclopaedic nature might change infrequently, revolutions in scientific paradigms led us to doubt the existence of eternal truths. Many resources are temporal in nature, for example stock and news (Gutierrez, Hurtado and Vaisman, 2007), and a growing amount of data on the Web comes directly in timestamped streams from sensors. Moreover, data on the Web often starts as raw material that is refined over time, for example, when patches based on user feedback are incorporated. Datasets “are constantly evolving to reflect an updated community understanding of the domain or phenomena under investigation” (Papavasileiou et al., 2013).

At the same time people are recognizing the value of historical data, access to which proves to be essential for making better decisions about the present and for predicting the future. Consequently, access to both current and historical data is deemed vital. However, many data sources on the Web are not archived and disappear on a regular basis. Auer remarks that datasets often “evolve without any indication, subject to changes in the encoded facts, in their structure or the data collection process itself” (Auer et al., 2012). In many cases we fail to record when we get to know about things described in our data. Lack of provenance metadata and temporal annotations makes it difficult to understand how datasets develop with respect to the real world entities they describe. Rate of change in datasets is thus opaque unless they are provided with explicit metadata.1 Most changes are implicit and detecting them requires “reverse engineering” by comparing snapshots of the observed dataset; a crude way to tell what changed and in which way.

All these remarks highlight the temporal dimension of data on the Web. Being able to observe the nature of change in linked data proves important for many data consumption use cases. Knowing what the rate of change is may help to determine which queries can be safely run on cached data and which queries need to be executed on live data (Umbrich, Karnstedt and Land, 2010). Not knowing what changes makes data synchronization inefficient as it requires copying whole datasets. Temporal annotation may vastly benefit applications that combine linked data from the Web. It allows to cluster things that happened simultaneously and determine order of events that might have been spawned by each other. In the data fusion use case, applications may use temporal annotation to favour more recent data. Finally, “in some areas (like houses for sale) it is the new changed information which is of most interest, and in some areas (like currency rates) if you listen to a stream of changes you will in fact accumulate a working knowledge of the area” (Berners-Lee and Connolly, 2009).

Unfortunately, “for many important needs related to changing data, implementation patterns or best practices remain elusive,” (Sanderson and Van de Sompel, 2012) which results into the practice when “accommodating the time-varying nature of the enterprise is largely left to the developers of database applications, leading to ineffective and inefficient ad hoc solutions that must be reinvented each time a new application is developed” (Jensen, 2000). The lack of guidance on this topic is what this article attempts to remedy by contributing with an overview that summarizes the main data modelling patterns for temporal linked data. The article begins by going through preliminaries, including concepts and formalizations used in further sections. The main part provides a review of dominant modelling patterns for capturing temporal dimension of linked data. This overview is followed by a discussion of common issues in modelling temporal linked data. Concluding sections of the article provide pointers to related work and sum up the article’s contributions.


In order to set up the scene for the main body of this article, we will introduce the formalisms for modelling data (RDF) and representing time, along with description of key concepts in the domain.

Resource Description Framework

RDF (Resource Description Framework) is a generic data format for exchanging structured data on the Web. It expresses data as sets of atomic statements called triples, in which each triple is made of subject, predicate and object. There are three options that may be used as the constituent parts of triples. URIs (Uniform Resource Identifiers) identifying resources may be used at any position within a triple. Blank nodes, existentially quantified anonymous resources, may serve both as subjects and as objects. Finally, literals, textual values with optional data type or language tag, may be put only to the object position. Any set of RDF triples forms a directed labelled graph, in which vertices consist of subjects and objects and edges, oriented from subjects to objects, are labelled with predicates.

The deficiencies of RDF regarding the expression of temporal scope are mostly attributed to the fact that RDF is limited solely to binary predicates, while relations of higher arity have to be decomposed into binary ones. Since RDF predicates are binary, any relation that involves more than two resources can be expressed only indirectly (RDF 1.1 concepts, 2013). What follows from this restriction is that “temporal properties can only be attached to concepts or instances. Whenever a relation needs to be annotated with temporal validity information, workaround solutions such as relationship reification need to be introduced” (Tappolet and Bernstein, 2009). These indirect ways of introducing temporal dimension as an additional argument to binary relations captured by RDF are accounted for by the modelling patterns described further in the article.

In addition to mixing time in relations, temporal scope can be also treated as an annotation, which may be attached anything with an own identity that is valid subject of an RDF triple (i.e. URI, blank node). Although similarly indirect, annotations may be attached at several levels of granularity, including annotations of individual triples, resources or sets of triples grouped in sub-graphs. Since “there is nothing else but the constituents to determine the identity of the triple,” (Kiryakov and Ogyanov, 2002) RDF triples have no identity to refer to, which makes describing their context, such as temporal scope, unfeasible. To provide triples with identity of their own reification must be used. Reification is a way how to make statements into resources, so that they are within the reach of what may be described in RDF. Together with other approaches to annotation reification will be explored in the following data modelling patterns.

As mentioned above, all of the ways of capturing temporal dimension in RDF rely on indirection or convoluted patterns constrained by RDF limitations. Moving from synchronic to diachronic data representation runs up against the restraints of RDF. Design of the “RDF data model is atemporal” (RDF 1.1 concepts, 2013) and there no native support for incorporating time. The format’s specification leaves handling temporal data out of its scope and delegates the question of expressing such data to RDF vocabularies and ontologies. Current RDF specifications also evade the issue of semantics of temporally variant resources by recognizing that “to provide an adequate semantics which would be sensitive to temporal changes is a research problem which is beyond the scope of this document” (RDF semantics, 2004).

Indeed, much criticism was voiced over RDF’s atemporality. For instance, Tennison declares that “the biggest deficiency in RDF is how hard it is to associate metadata with statements,” (2009a) Mittelbach specifies that “there is no built-in way to describe the context in which a given fact is valid,” (2008) and Hickey concludes that “without a temporal notion or proper representation of retraction, RDF statements are insufficient for representing historical information” (2013).

Representation of time

Time can be represented as a “point-based, discrete and linearly ordered domain” (Rula et al., 2012). It is typically conceptualized as one-dimensional, so there is no branching time (Tappolet and Bernstein, 2009). Basic types of temporal entities are time points (instants) and time intervals (periods) delimited by starting and ending time point. If necessary, temporal primitives might be reduced to intervals since “it is generally safe to think of an instant as an interval with zero length, where the beginning and end are the same” (Time Ontology in OWL, 2006). Temporal scope of data may also span multiple periods, which can be represented as a union of disjoint time intervals (Lopes et al., 2009).

Temporal entities can be translated into RDF either as literals or resources. Literals specifying time may conform to one of the XML Schema datatypes,2 such as xsd:dateTime or xsd:duration, which are based on international standards, such as ISO 8601.3 These datatypes are well supported by the SPARQL RDF query language and other tools working with RDF that implement XPath functions for manipulating with such datatype values. Less common literal datatypes4 require custom parsers, so it is advisable to conform to standards and to decompose compound literals into structured values represented as RDF resources.

Complex values, such as intervals delimited with starting and ending timestamps, should be represented as resources. This is the way of modelling adopted by Time Ontology in OWL (2006), in which temporal entities are structured as instances of classes that are further described with datatype properties. Another application of this approach is in the work of Correndo et al., who offer a formalization of time that they held to be well-suited for annotation of RDF (2010). They present the “concept of Linked Timelines, knowledge bases about general instants and intervals that expose resolvable URIs” and provide “also temporal topological relationships inference to the managed discrete time entities.” The URIs generated for time instants and intervals adhere to syntax of ISO 8601 literals and are described with OWL Time Ontology, which the authors extended with better support for XML Schema datatypes.

An alternative option is to represent temporal relations as a hierarchy, for example a year interval may have narrower month intervals. This solution was proposed for the Neo4j graph store,5 although it can be also put into practice in RDF stores using, for example, SKOS6 hierarchical relationships such as skos:narrowerTransitive and skos:broaderTransitive.

In the examples contained in this article we will use the Time ontology in OWL combined with XML Schema datatypes to represent temporal entities.

Key concepts

Change in time is inextricably linked to several concepts, which influence the generic principles that guide data modelling. A fundamental concept that interacts with it is identity. There is no widely accepted definition of identity in database setting. It can be considered as continuity over a series of perceptions (Halloway, 2011). Another perspective views identity as the characteristics that make entity recognizable from others. It is the relation an entity has only to itself, exhibiting the characteristics of being both reflexive, transitive and symmetric.

Identity on the Web may be contemplated through the Leibniz’s ontological principle of identity of indiscernibles, which may be formulated as follows: “if, for every property F, object x has F if and only if object y has F, then x is identical to y” (Identity of indiscernibles, 2010). This rule does not hold on the Web since “resources are not determined extensionally. That is, A and B can have the same correspondences and coincidences, and still be distinct” (Rees, 2009). On the contrary, the reverse law of indiscernibility of identicals holds true since owl:sameAs asserts that identity entails isomorphism, or that if a = b, then all statements of a and b are shared by both” (McCusker and McGuinness, 2010.

When it comes to change in time, a key issue of identity is “the problem of diachronic identity: i.e., how do we logically account for the fact that the ‘same’ entity appears to be ‘different’ at different times?” (Welty and Fikes, 2006). Change is a result of actions over time, each of which produces a new observable state of the changed identity. State is a relationship of identity to value. In Representational State Transfer (REST) “resource R is a temporally varying membership function MR(t), which for time t maps to a set of entities, or values, which are equivalent” (Fielding, 2000). In linked data, which builds on REST, the state is the representation (perceived value) to which a resource URI dereferences, so that “dereferencing [the resource’s] URI at any specific moment yields a response that reflects the resource’s state at that moment” (Van de Sompel, Nelson and Sanderson, 2013). While the resource state may change, the resource URI should be persistent, as recommended by one of the principles of the architecture of World Wide Web:

“Resource state may evolve over time. Requiring a URI owner to publish a new URI for each change in resource state would lead to a significant number of broken references. For robustness, Web architecture promotes independence between an identifier and the state of the identified resource.” (Architecture of the World Wide Web, 2004)

State offers a perceivable value, which is, in contrast to resources, immutable. Values are made of facts, which are in the temporal database research regarded as “any statement that can meaningfully be assigned a truth value, i.e. that is either true or false” (Jensen, 2000). RDF regards individual triples as atomic facts, which are held to be true without respect to context by to sole nature of their existence. Although in fact, without context, such as temporal scope, it might not be feasible to assign truth value to RDF triples. RDF resources are by default persistent yet mutable, although “literals, by design, are constants and never change their value” (RDF 1.1 concepts, 2013). However, RDF triple may be considered immutable because “an RDF statement cannot be changed – it can only be added and removed.” (Kiryakov and Ogyanov, 2002). To the contrary “there is no way to add, remove, or update a resource or literal without changing at least one statement, whereas the opposite does not hold” (Auer and Herre, 2007).

The succession of resource states may spread across multiple temporal dimensions. A common conceptualization of time uses two temporal dimensions; valid time and transaction time, and thus it is referred to as bitemporal data model. It allows to distinguish between the situation when “the world changes” and when “the data about the world changes” (e.g., as a result of changes in the data collection process). Valid time (also “actual time”, “business time” or “application time”) captures when is the data valid in the modelled world. Value is current during valid time. This interpretation fits the dcterms:valid property from the Dublin Core Terms vocabulary.7 Transaction time (also “record time” or “system time”) reflects when data enters database. Value is perceived at transaction time. This dimension’s semantics may be expressed with dcterms:created property, also from Dublin Core Terms.

Modelling patterns

Having set the preliminaries we will now review and compare data modelling patterns for capturing temporal dimension of linked data. To limit our scope we selected only the patterns that can be implemented within RDF without extending it. That said, all the patterns can be expressed in RDF, even though they might not have a defined semantics. And in fact, the differences between some patterns are a matter of syntax, so that they can be transformed to each other. The overview features patterns based on reification, concept of four-dimensionalism, dated URIs and named graphs.

Throughout this section we will use the following data snippet serialized in RDF Turtle syntax8 to serve as a running example. It states the resource :Alice to be a member of the organization :ACME without any anchoring temporal information, the attachment of which will differ in each reviewed modelling pattern.

:Alice org:memberOf :ACME .

The examples use the Time Ontology (Time Ontology in OWL, 2006) to demarcate temporal scope of data, except in cases where the modelling pattern provides its own way to represent the scope. The temporal annotation in all examples asserts the data to be valid since 9 AM on January 1, 2000. The following examples use the RDF Turtle syntax (unless stated otherwise) with these namespaces prefixes:

@prefix :         <http://example.com/> .
@prefix cs:       <http://purl.org/vocab/changeset/schema#> .
@prefix dcterms:  <http://purl.org/dc/terms/> .
@prefix gen:      <http://www.w3.org/2006/gen/ont#> .
@prefix org:      <http://www.w3.org/ns/org#> .
@prefix owl:      <http://www.w3.org/2002/07/owl#> .
@prefix prov:     <http://www.w3.org/ns/prov#> .
@prefix prv:      <http://purl.org/ontology/prv/core#> .
@prefix rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs:     <http://www.w3.org/2000/01/rdf-schema#> .
@prefix sit: <http://www.ontologydesignpatterns.org/cp/owl/timeindexedsituation.owl#> .
@prefix ti: <http://www.ontologydesignpatterns.org/cp/owl/timeinterval.owl#> .
@prefix time:     <http://www.w3.org/2006/time#> .
@prefix xsd:      <http://www.w3.org/2001/XMLSchema#> .


In the first part of the reviewed data modelling patterns we will focus on those that use reification. In previous research these patterns were grouped in the category of fact-centric perspectives (Rula et al., 2012). Reification is a principle by which previously anonymous parts of the data model are given autonomous identity, so that they can be described within the data model. The patterns we go through in this section include statement reification, axiom annotation, changesets, n-ary relations and property localization.

Statement reification

Statement reification9 adopts a sentence-centric perspective (Rula et al., 2012) and attaches temporal annotation to individual triples (statements). It decomposes the reified binary predicate into three binary predicates asserting what the subject (rdf:subject), predicate (rdf:predicate) and object (rdf:object) of the original statement are.

This approach suffers from a number of issues, which is why it is commonly discouraged to use it. First, there is no formal correspondence between statement and its reified form. As RDF primer points out: “note that asserting the reification is not the same as asserting the original statement, and neither implies the other” (RDF primer). Even if “there needs to be some means of associating the subject of the reification triples with an individual triple in some document […] RDF provides no way to do this” (ibid.). At the same time, two reified statements with the same subject, predicate and object cannot be automatically inferred to be the same statement. Moreover, triple reification is inefficient in terms of data size as it requires at least three times more triples than non-reified statement. If statement reification is used, every temporally annotated statement has to be reified, as there is no grouping possible. Given these concerns triple reification is considered for deprecation, one reason for which is that the cases for which it is used are fulfilled by named graphs, which, unlike reification, make do without data transformation.

:Alice org:memberOf :ACME .

[] a rdf:Statement ;
  rdf:subject :Alice ;
  rdf:predicate org:memberOf ;
  rdf:object :ACME ;
  dcterms:valid [
    a time:Interval ;
    time:hasBeginning [
      time:inXSDDateTime "2000-01-01T09:00:00Z"^^xsd:dateTime
  ] .

Axiom annotation

OWL 2 offers a way for expressing annotations about axioms.10 OWL annotations are “pieces of extra-logical information describing the ontology or entity” (Grau, 2008) and they “carry no semantics in OWL 2 Direct Semantics” (OWL 2 Web Ontology Language, 2012). They can be considered functionally equivalent to triple reification and thus their issues are closely similar. Gangemi and Presutti add that the downsides include a need for “a lot of reification axioms to introduce a primary binary relation to be used as a pivot for axiom annotations, and that in OWL 2 (DL) reasoning is not supported for axiom annotations” (Gangemi and Presutti, 2013).

:Alice org:memberOf :ACME .

[] a owl:Axiom ;
  owl:annotatedSource :Alice ;
  owl:annotatedProperty org:memberOf ;
  owl:annotatedTarget :ACME ;
  dcterms:valid [
    a time:Interval ;
    time:hasBeginning [
      time:inXSDDateTime "2000-01-01T09:00:00Z"^^xsd:dateTime
  ] .


Changeset vocabulary11 captures changes as reified statements that are complemented with metadata, such as the type of changeset (addition, removal) or timestamp. Individual changesets comprise annotated reified statements, which represent atomic changes made to data. Changesets may be bundled together by using the Eventset vocabulary,12 which provides a higher level resource-centric view of changes.

[] a cs:ChangeSet ;
  cs:addition [
    a rdf:Statement ;
    rdf:subject :Alice ;
    rdf:predicate org:memberOf ;
    rdf:object :ACME
  ] ;
  cs:createdDate "2000-01-01T09:00:00Z"^^xsd:dateTime .

N-ary relation

A common pattern how to provide relation with an identity is by using a class instance instead of a property. By introducing a specific resource to name the relation this practice allows to escape the limitation of default binary predicates in RDF and instead express arbitrary n-ary relations13 decomposed into binary relations expressible in RDF. “The classes created in this way are often called ‘reified relations’” (Defining n-ary relations on the semantic web, 2006) and bear a resemblance to statement reification syntax. However, they are more concise since they subsume the semantics of rdf:predicate in an instantiation of a specific class. Moreover, whereas in statement reification additional triples characterize a “statement”, in n-ary relations they describe the “relation” itself, which is why this modelling pattern is categorized as relation-centric perspective (Rula et al., 2012).

However, some argue that time is “an additional semantic dimension of data. Therefore, it needs to be regarded as an element of the meta-model instead of being just part of the data model” (Tappolet and Bernstein, 2009). Indeed, ontological solution mixes time model into data model. Expressing temporal dimension in the data model requires per-property effort, which leads to ontology bloat and indirection because many properties exhibit potentially dynamic characteristics. Moreover, custom n-ary relations do not conform to any standard, so interpreting them automatically may be difficult.

Despite these disadvantages n-ary relations are regarded as the most flexible for incorporating temporal annotations (Gangemi, 2011), which is supported by the evidence of their widespread use in practice. For example, they are used in Freebase14 and Wikidata.15 Since n-ary relations are common, Organization Ontology, which offers the org:memberOf predicate used in the initial example, also provides a way to put the membership relation in temporal context using n-ary relationship org:Membership.16

[] a org:Membership ;
  org:member :Alice ;
  org:organization :ACME ;
  org:memberDuring [
    a time:Interval ;
    time:hasBeginning [
      time:inXSDDateTime "2000-01-01T09:00:00Z"^^xsd:dateTime
  ] .

N-ary relations may be further refined by “decorating” them with compound keys, using the owl:hasKey feature of OWL 2, which helps in merging identical relations (Gangemi, 2011).

org:Membership owl:hasKey (
) .

The pattern of converting properties to n-ary relations is documented in the Property Reification Vocabulary, (Procházka et al., 2011) which offers a way for establishing a connection between property (prv:shortcut) and its n-ary relations (prv:reification_class).

:memberOfReification a prv:PropertyReification ;
  prv:shortcut org:memberOf ;
  prv:reification_class org:Membership ;
  prv:subject_property org:member ;
  prv:object_property org:organization .

Property localization

A relatively convoluted technique for reifying properties is property localization, which is also known as “name nesting”. “To reduce the arity of a given relation instance” it might be replaced by a sub-property with “partial application” of time, thereby decreasing the number of its arguments (Krieger, 2008). However, in order to add more parameters another sub-property needs to be minted, which, coupled with relying on singletons for property domain and range, makes this pattern inflexible.

:AliceMemberOfACMESince2000-01-01 rdfs:subPropertyOf org:memberOf ;
  rdfs:domain [
    owl:oneOf ( :Alice )
  ] ;
  rdfs:range [
    owl:oneOf ( :ACME )
  ] ;
  dcterms:valid [
    a time:Interval ;
    time:hasBeginning [
      time:inXSDDateTime "2000-01-01T09:00:00Z"^^xsd:dateTime
  ] .

:Alice :AliceMemberOfACMESince2000-01-01 :ACME .


Four-dimensionalism is a school of thought hailing from a strong philosophical background that regards time as the fourth dimension. Traditional data modelling approaches ascribe fourth dimension only to processes (“perdurants”) whereas things (“endurants”) are held to extend solely in three dimensions. “Endurants are wholly present at all times during which they exist, while perdurants have temporal parts that exist during the times the entity exists” (Welty and Fikes, 2006). On the contrary, four-dimensionalism does not make this conceptual distinction and treats every entity as having temporals parts extended through time.

The temporal parts of individuals are referred to as time slices, which represent their time-indexed states. The properties used to describe time slices are called fluents. Fluents are “properties and relations which are understood to be time-dependent” (Hayes, 2004) and can be thought of as “instances of relations whose validity is a function of time,” (Hoffart et al., 2013) so that they are functions that map from objects and situations to truth values (Welty and Fikes, 2006).

Even though some authors hold 4D fluents to be the most expressive modelling pattern for temporal annotation with best support in current reasoners (Batsakis and Petrakis, 2011), this approach begets a number of issues as well. Perhaps the major one is that in 4D view we either have to treat instances of existing classes as time slices or we have to redefine domain and range of existing properties to instances of time slices. Krieger (2008) presents a attempt to solve this issue by reinterpreting existing properties as 4D fluents. He posits that such “interpretation has several advantages and requires no rewriting of an ontology that lacks a treatment of time.” Proliferation of identical time slices may be another potential problem of this pattern. Welty and Fikes argue that “there is no way in OWL to express the identity condition that two temporal parts of the same object with the same temporal extent are the same,” (2006) however, features added in OWL 2 more recently, such as keys, may be used for this purpose.

Unlike the previously mentioned approaches, modelling resource slices tracks changes on a higher level of granularity. Whereas in the above-mentioned examples changes are recorded on the level of individual relations or facts, this pattern captures changes on the level of resources. Consequently, if we use slices as resource’s snapshots, such modelling will likely be inefficient as most of the resource’s data remains unchanged in subsequent resource slices, but it has to be duplicated. A more economical approach is to treat resource slices as deltas that contain only data that changed, which are used, for example, in the work of Tappolet and Bernstein (2009).

In the following example, time slices of resources are expressed as instances of gen:TimeSpecificResource using the Ontology for Relating Generic and Specific Information Resources.17 The property org:memberOf is reinterpreted as if it was a fluent property.

:Alice a gen:TimeGenericResource ;
  gen:timeSpecific :Alice2000-01-01 .

:ACME a gen:TimeGenericResource ;
  gen:timeSpecific :ACME2000-01-01 .

:Alice2000-01-01 a gen:TimeSpecificResource ;
  org:memberOf :ACME2000-01-01 ; 
  dcterms:valid :membershipTime .

:ACME2000-01-01 a gen:TimeSpecificiResource ;
  dcterms:valid :membershipTime .

:membershipTime a ti:TimeInterval 
  ti:hasIntervalStartDate "2000-01-01T09:00:00Z"^^xsd:dateTime .

A variation of this modelling pattern was put forward by Welty as context slices (2010). Context slice is “a projection of the relation arguments in each context for which some binary relation holds between them” (ibid.). It constitutes a shared context (instance of :Context) in which time-indexed “projections” (instances of :ContextualProjection) of both subject and object participate.

:AliceMemberOfACMESince2000-01-01 a :Context ;
  dcterms:valid [
    a time:Interval ;
    time:hasBeginning [
      time:inXSDDateTime "2000-01-01T09:00:00Z"^^xsd:dateTime
  ] .

:Alice2000-01-01 a :ContextualProjection ;
  :hasContext :AliceMemberOfACMESince2000-01-01 .

:ACME2000-01-01 a :ContextualProjection ;
  :hasContext :AliceMemberOfACMESince2000-01-01 .

:Alice2000-01-01 org:memberOf :ACME2000-01-01 .

Dated URIs

Dated URIs allow to express temporal scope at identifier level. Resource identified with dated URI is time-indexed by a timestamp embedded directly into its URI. A formal version of this modelling pattern was proposed Masinter (2012), who drafted two URI schemes that employ embedding of original URI and its temporal scope into a single identifier. The first scheme, duri (“dated URI”) is used to identify resource as of specific time. The second, tdb (“thing described by”) serves the purpose of identifying temporally scoped state of resources that cannot be retrieved via the Web (i.e. “non-information resources”). Using dated URIs, the running example looks like this:

<tdb:2000-01-01T09:00:00Z:http://example.com/ACME> .

An alternative way how to use this pattern would be to instead index properties with time, since these are what changes.

:Alice <tdb:2000-01-01T09:00:00Z:http://www.w3.org/ns/org#memberOf> :ACME .

The principal downside to URIs in both of these schemes is that resolving them is not supported by existing HTTP clients. A more prevalent, yet not formalized technique sticks to regular HTTP URIs, in which temporal information is contained. For example, Tennison (2009b) builds on widespread pattern of dated URIs and proposes to mint URIs with temporal annotations (such as http://example.com/Alice/2000-01-01), to which generic URIs (such as http://example.com/Alice) redirect with HTTP 307 Temporal Redirect. However, all approaches that embed time into URIs interfere with the axiom of URI opacity,18 which discourages from inferring anything from URI’s string representation, since that would overload the function of identifiers to carry information belonging to the data model and would require additional custom parsers to extract temporal annotation from URIs. Since this approach operates on the identifier level, it may be used together with the previously covered modelling patterns. For example, resources identified by dated URIs might be interpreted as time slices presented in the above mentioned pattern.

Named graphs

In this section we discuss the deployment of named graphs as resource states and as data versions. Named graphs are merely syntactically paired names (URIs) with RDF graphs. “RDF does not place any formal restrictions on what resource the graph name may denote, nor on the relationship between that resource and the graph” (RDF 1.1 concepts, 2013) and semantics of named graphs is thus left undefined.

A substantial benefit of named graphs is that this approach does not interfere with the actual data model, since it is agnostic about what RDF vocabularies and ontologies are being used. This makes them compatible with existing atemporal data models, which may be used within temporally annotated named graphs. An advantage of named graphs is that they enable storing mutually contradicting data, since storing inconsistent data in temporally-scoped statements inside a single graph violates RDF’s entailment property, which asserts that from an RDF graph every sub-graph can be entailed (Mittelbach, 2008). Finally, although there is no standardized serialization syntax for named graphs,19 they are well-supported in tools based on SPARQL 1.1, since most current RDF stores are quad-stores. Although their handling in current reasoners is patchy, since named graphs are not a part of the OWL specification to which most reasoners conform to (Batsakis and Petrakis, 2011).

Despite favourable mentions named graphs received in literature about temporal RDF, there are several commonly raised issues when it comes to using this approach for temporal annotation. Even though named graphs have no standardized semantics, they are commonly used as containers of RDF datasets. Named graphs are frequently equated to “documents”, in which RDF data is published. Based on empirical evidence collected by Rula et al. (2012) temporal annotations of documents are relatively prevalent in practice. Grouping a set of related triples into a dataset identified with a named graph URI is recommended among the best practices for working with linked data.20 Since named graphs are already used to express a dataset to which resources belong, for temporal annotation “relying on named graphs is problematic because the statements may be embedded in other datasets which are already enclosed in named graphs” (McCusker and McGuinness, 2010. However, affiliation between RDF triples and datasets may be expressed explicitly in the RDF data model by using properties such as void:inDataset21 that connects named graph that encloses RDF with URI indicating a dataset.

A difficult task when using named graphs is to pick the best level of granularity on which to partition data into individual graphs. On this note, Tennison recommends that “to avoid repetition of data within multiple graphs, graphs should be split up at the level that updates are likely to occur within the source of the data” (2010). In the worst case the granularity amounts to single statement, in which case named graphs may serve as a more elegant syntax for reified statements. As Gangemi and Pressuti warn about named graphs, “this solution has the advantage of being able to talk about assertions, but the disadvantages of needing a lot of contexts (i.e. documents) that could make a model very sparse” (2013). Due to this respect, Rula et al. recommend using named graphs “only when it is possible to group a considerable number of triples into a single graph” (2012). However, when change impacts multiple facts at the same time, named graphs enable to group them and attach single temporal annotation, which is not possible with previously scrutinized modelling patterns.

Data modelling patterns for temporal data based on named graphs attribute special statuses to the default graph. Two basic ways of using default graph emerged. While some approaches employ named graphs to store changing data, default graph is used as a container for metadata about the changes, for example in Rula et al., 2012. Another way is to define default graph as a view of the current state of data (i.e. HEAD in terminology of versioning systems), which is the case for R&Wbase (Vander Sande et al., 2013). Of the different versions of data “the most useful […] is the current graph, which is the one that should be exposed as the default graph in the SPARQL endpoint offered by the triplestore” (Tennison, 2010), which helps to simplify querying via SPARQL as the current state of data is selected by default.

Named graphs were used for representing temporal scope in several research projects, though their use for this particular purpose is still not widespread at the moment. For example, Tappolet and Bernstein (2009) describe named graphs as instances of classes from Time Ontology (2006), which delimit temporal boundaries of data in graphs.

In the following examples we use the TriG syntax,22 which extends the Turtle serialization to represent named graphs. We will demonstrate interpreting named graphs as resource states and as commits.

Resource states

The concept of stateful resources was put forth by Richard Cyganiak.23 It reinterprets every resource as stateful resource and uses named graphs as individual states of the resource. It aligns well with the concepts of four-dimensionalism, using named graphs for temporal parts of stateful resources.

:Alice2000-01-01 {
  :Alice org:memberOf :ACME .
  :Alice2000-01-01 dcterms:valid [
    a time:Interval ;
    time:hasBeginning [
      time:inXSDDateTime "2000-01-01T09:00:00Z"^^xsd:dateTime
  ] .


An approach of using named graphs for capturing evolving RDF data was outlined in a proof of concept entitled R&Wbase (Vander Sande et al., 2013), which builds on concepts of distributed version control systems. Each change is represented as a commit, which captures delta between the previous and current state of data. Unlike snapshots, in this way data that persists through subsequent revisions does not need to be duplicated, which contributes to storage space efficiency. Much like transactions in relational databases, commits represent atomic units of data that allow fault recovery and rollback. Commits represent collection of metadata describing changes made to data, including their author, timestamp and link to parent commit. Commit are described via the means of the Provenance Ontology.24 In case of R&Wbase, individual revisions are exposed as virtual named graphs that enable to query database as of specific commit. This approach also allows to both branch and merge different versions of data. The following is an example :version named graph that was generated by the :commit:

:version {
  :commit a prov:InstantaneousEvent ;
    prov:atTime "2000-01-01T09:00:00Z"^^xsd:dateTime ; 
    prov:generated :version .
  :version a prov:Entity .

  :Alice org:memberOf :ACME .

Main issues

Having outlined the key characteristics of the main modelling patterns for temporal RDF, we summarize their suitability for linked data based on several criteria and requirements. However, before that we discuss a few guiding concerns that serve as a basis on which we decide how the reviewed modelling patterns fare on evaluation criteria.

Guiding concerns

This section draws attention to a few common concerns associated with modelling temporal data in RDF. We highlight the importance of avoiding updating data in place, the cost of identifying data with blank nodes and reasons given for preferring deltas instead of snapshots. The selection should by no means held to be comprehensive, but rather as a sample of more prominent concerns.

No update in place

Update must not affect existing data. Temporal databases eschew update in place and instead prefer immutable data structures, which collect changes instead of applying them directly by rewriting previous data. Hickey states that “since one can’t change the past, this implies that the database accumulates facts, rather than updates places, and that while the past may be forgotten, it is immutable” (2013). In this way, “when capturing the transaction time of data, deletion statements only have a logical effect” (Jensen, 2000), which means that “deleting an entity does not physically remove the entity from the database; rather, the entity remains in the database, but ceases to be part of the database’s current state” (ibid.). Changes or deletes thus do not have the physical effect of modifying or erasing data in place. Delete only marks an existing fact as no longer valid, instead of removing it from the database. Erroneous data may be marked with zero as its end of validity; i.e. data was never valid. On this account, Auer et al. remark that “in analogy with accounting practices, we never physically erase anything, but just add a correcting transaction” (2012). Nevertheless, storage space is limited and legal regulations in some countries might require physical deletion of problematic data. Similar to garbage collection in programming languages a value might be discarded once it is ceased to be used. Likewise, in order to make irreversible changes most temporal databases allow special procedures to be executed, such as “vacuuming” or “excision”.

Avoid blank nodes

Blank nodes are commonly reported to be a source of problems in versioning RDF. For instance, Tappolet and Bernstein (2009) write that blank nodes are “especially problematic as their validity is restricted to the node’s parent graph.” RDF 1.1 concepts (2013) makes that clear by saying that, in fact, blank nodes may be shared across multiple graphs in an RDF dataset, however, these graphs must have a parent-child relationship. “Since blank nodes cannot be identified, deleting them is not trivial” (Vander Sande et al., 2013) and they must be addressed with the context of a graph pattern that they are a part of. Given these downsides many tools working with blank nodes replace them internally with URIs. Moreover, use of blank nodes is frowned upon in general in the linked data community, so the recommendation is to avoid them if possible.

Prefer deltas to snapshots

Change in data may be represented either as a new snapshot, which contains new data as well as unaltered data, or as delta, which record incremental change. Snapshot is a view of data at a particular moment. By using named graphs for snapshots “different versions of data can be stored in different graphs, but this leads to a duplication of all triples” (Vander Sande et al., 2013). Storing only deltas in place of full snapshots has significant space benefits. “The temporal RDF approach vastly reduces the number of triples by eliminating redundancies resulting in an increased performance for processing and querying” (Tappolet and Bernstein).

Delta comprises only the difference between two consecutive snapshots of data, which makes it space efficient at the price of complex resolution of deltas back to snapshots. In particular, the advantages of employing this approach show when dealing with changes with a higher level of granularity (i.e. resource or entire graph). Deltas were introduced to RDF by Berners-Lee and Connolly (2009) and were covered since by many other research articles that highlighted several major issues when employing deltas in RDF. Auer et al. call for “LOD differences (deltas) and representing them as first class citizens with structural, semantic, temporal and provenance information” (2012). Deltas have to be easily applicable, so that resolving them to a snapshot of data as of certain time frame is feasible. Delta resolution depends on preservation of their application order, either via parent links to previous deltas or by inferring the order from deltas’ timestamp succession. An important concern about delta is that they are self-contained, so that they group updates in a way that allows to identify all data pertaining to a single delta and revert it to a previous state. Moreover, deltas should express changes in data that can be comprehended by humans. In that respect, Papavasileiou and her colleagues propose a “change language which allows the formulation of concise and intuitive deltas” (2013).


In this section we summarize how the reviewed data modelling patterns compare on criteria that we deem relevant for linked data. Below the table each criterion is described in detail together with explaning comments on assessment of inidividual patterns.



Statement reification N-ary relations Property localization Time slices Dated URIs Stateful resources Commits
Data size 3n 3n 9n 3n n n 2n
Data compatibility
Model compatibility
Sufficient TBox
Technological compatibility
Time-specific URIs


Data size

Data size represents the minimal number of triples needed to represent data as compared with atemporal triple count; without including temporal annotation and data that can be inferred.

Property localization is the least space efficient approach because it requires a lot of boilerplate triples in ungainly OWL constructs. On the contrary, using named graphs as stateful resource has the smallest footprint because it only requires wrapping annotated triples into a named graph. The same result is achieved by using dated URIs, which overload content of resource identifiers, so that no additional triples are created.

Data compatibility

This criterion reflects whether adding temporal annotation can be done without a transformation of existing data.

As binary relations of basic triples are inable to capture temporal scope, all approaches limited to RDF triples require existing atemporal data to be transformed (e.g., reified) in order to attach temporal annotations. Data compatibility is an advantage of named graphs that enable to contextualize RDF without requiring data pre-processing.

Model compatibility

Model compatibility determines if existing atemporal RDF vocabularies and ontologies may be used to represent temporally annotated data.

The ability to keep an atemporal domain model and only extend it with temporal annotation is an important advantage. N-ary relations do not provide this ability because every time-varying property has to be remodelled. Other modelling patterns make keeping existing models feasible, albeit patterns based on named graphs prohibit uses of named graphs for other purposes (e.g., as dataset containers).

Sufficient TBox

Building on the criterion of model compatibility this criterion indicates if a compared modelling pattern makes do without introducing additional TBox axioms25 into RDF vocabularies or ontologies used in temporally annotated data.

Of the reviewed approaches, both n-ary relations and property localization require their users to establish additional TBox axioms that cannot be reused from available RDF vocabularies or ontologies.

Technological compatibility

This aspect of compatibility tests the reviewed approaches whether they are backwards compatible with existing linked data technologies (RDF, HTTP) without requiring custom extensions.

In this comparison, only dated URIs are marked as incompatible because they use a custom protocol, rather than the typical HTTP URIs. All other patterns adhere to technological standards of linked data.

Time-specific URIs

This criterion shows whether external datasets may link to a resource as of particular time.

Referring to a resource’s status to date is widely used when citing online resources. By enabling time-specific URIs third parties may add more data to describe a resource state. Such valuable property is typical for modelling patterns that use the resource-centric perspective; i.e. time slices, dated URIs and stateful resources.


The criterion of bitemporality judges modelling patterns on the basis of their ability to capture both transaction and valid time.

Most of the examined patterns enable to use bitemporal data model, however, using it is not possible with dated URIs, which facitilate capturing only a single temporal dimension.


Extensibility is the criterion that shows if the approach in question permits other types of annotations to be expressed as well (e.g., provenance metadata).

All patterns that are deemed to be extensible enable bitemporality. However, in case of property localization, though it can provide bitemporal data model, it is not particularly extensible because describing more dimensions of data requires adding new sub-property for every dimension, which results in a plethora of newly minted TBox axioms.

The views presented in the comparison of data modelling patterns in this paper build on a large corpus of existing research literature on the topic. To highlight several of the notable works from this corpus this section introduces core ideas and solutions presented in them. As motivated in the introduction, the issues of temporal data in RDF are widely perceived as pressing. Even though not established as long as in SQL databases, the research of modelling patterns for RDF data varying in time produced a vast array of literature on the topic. An extensive bibliography of research on the subject of temporal aspects of semantic web was compiled by Grandi (2012).

Several comparisons of data modelling patterns for temporal annotation in RDF were conducted in the past. Similarly to this article, Davis went through the options for modelling temporal data in RDF in a series of blog posts (2009a), in which he compared conditions and time slices (2009b), named graphs (2009c), reified relations (2009d) and n-ary relations (2009e). Rula et al. presented a comparison based on empirical study of use of temporal properties in a large corpus crawled from the Web (2012). According to their analysis, the most common ways of representing temporal annotations is with n-ary relations and document metadata. Coming more from the perspective of ontological engineering, Gangemi and Presutti present seven RDF and OWL 2 logical patterns for modelling n-ary relations (2013), each of which is discussed in terms of its usability. In his account of the topic, Hayes presents a unification algorithm for automatical translation between different syntaxes used for representing temporally annotated information (2004). Temporal annotation may “trickle down” through the different levels of attachment, so that it indexes either whole statements, relationships, or individuals, which demonstrates incidental nature of syntax used for expressing temporal scope. In this way interoperability between datasets employing distinct modelling styles may be achieved.

The approaches to data modelling presented here work in any standards-compliant RDF store. However, additional features might be needed to make such data usable and its retrieval efficient. For example, additional dedicated indexes may be built to improve query performance and query rewriting might be employed to reduce complexity of query formulation. Foundational research in implementation of temporal RDF was laid out in publication of Gutierrez, Hurtado and Vaisman, 2005. Working in this direction, SPARQL was extended to function with temporally annotated data in T-SPARQL, which was inspired by the TSQL2 temporal query language in the domain of relational database management (Grandi, 2010). Several research papers proposed additional index structures and normalization of temporal annotations to speed up retrieval of temporal RDF (Pugliese, Udrea and Subrahmanian, 2008). Grandi (2009) proposed a multi-temporal database model with temporal query and update execution techniques, which were motivated by a focus on ontologies from the legal domain.

Support for some form of temporal RDF is already built-in in a few RDF stores and RDF-aware tools. For example, Parliament RDF store supports a dedicated temporal index.26 R&WBase (Vander Sande et al., 2013), which was mentioned previously as a database with versioning capabilities, is a work in progress. A versioning module is a part of the Apache Marmotta,27 an implementation of a linked data platform for publishing RDF data.

Looking into a wider context besides RDF proper, temporal dimension of data is supported in many other database solutions. Some approaches extend triples to n-tuples to surmount the limitations of RDF, such as Google Freebase, the query language of which allows to access historical versions of data.28 Hoffart et al. report that the data model used in YAGO2 extends RDF triples to quintuples with time and location (2013). The model uses statement reification internally and statements get de-reified for quering, so that they can be viewed as quintuples. Efficient query performance is supported by the use of PostgreSQL and additional indexes for all tuples’ permutations.

Research on the topic of temporal data is long-established in the field of relational databases. TSQL2 is a complete temporal query language designed as an extension of SQL-92. Furthermore ISO SQL:2011, the 7th revision of the SQL standard, incorporates temporal support. Temporal retrieval is built into several non-RDF databases, which include Datomic,29 Google’s Spanner30 or IBM’s DB2 (Saracco, Nicola and Gandhi, 2012).


In this overview we surveyed data modelling patterns for temporal linked data. Each pattern was evaluated on a set of generic criteria; omitting dataset-specific criteria, such as size of changes or change frequency. The criteria were designed on the basis of several guiding concerns regarded as relevant for linked data in particular. Giving the chosen criteria a priority was motivated by recognizing what is important for the things linked data is based on.

Backwards compatibility is a crucial virtue for the continual evolution of the Web. Therefore a new modelling style for temporal linked data must work with existing atemporal data and with available technologies. The resource-centric architecture of linked data is built on the core principles of REST. The fundamental concepts of REST map well to four-dimensionalism, in which resources may be treated as perdurants and their representations as their temporal parts. When it comes to the data format of linked data, RDF, it produced the limitations the presented modelling patterns try to circumvent. The version of RDF that was originally standardized proved to be too restrictive for temporal data. Approaches that transcend these limits turned out to be superior to those that hacked and twisted atemporal RDF. Named graphs, a de facto standard on its way to the next version of RDF specification, showed to be a viable option for modelling temporal data, which offers an elegant syntax that bypasses limits of binary relations inherent in RDF.

However, even though best practices for data modelling temporal RDF emerge and technologies supporting such data are being developed, the diachronic dimension of linked data is still missing. Given the large extent of research conducted on the topic, it is now a question of adoption of modelling patterns for temporal data by a broader audience. The research would yet have to be boiled down to concrete recommendations and guidance based on standards distilled from common consensus.


  • Architecture of the World Wide Web, volume 1. [online]. W3C Recommendation. December 15th, 2004 [cit. 2013-06-13]. Available from WWW: http://www.w3.org/TR/webarch/
  • AUER, Sören; HERRE, Heinrich. A versioning and evolution framework for RDF knowledge bases. In Proceedings of the 6th International Andrei Ershov Memorial Conference on Perspectives of Systems Informatics. Berlin; Heidelberg: Springer, 2007, p. 55 — 69. ISBN 978-3-540-70880-3.
  • AUER, Sören [et al.]. Diachronic linked data: towards long-term preservation of structured interrelated information. In Proceedings of the 1st International Workshop on Open Data, Nantes, France, May 25, 2012. New York (NY): ACM, 2012, p. 31 — 39. ISBN 978-1-4503-1404-6.
  • BATSAKIS, Sotiris; PETRAKIS, Euripides G. M. Representing temporal knowledge in the semantic web: the extended 4D fluents approach. In Combinations of Intelligent Methods and Applications: proceedings of the 2nd International Workshop, CIMA 2010, France, October 2010. Berlin; Heidelberg: Springer, 2011, p. 55 — 69. Smart innovation, systems and technologies, vol. 8. DOI 10.1007/978-3-642-19618-8_4.
  • BERNERS-LEE, Tim; CONNOLLY, Dan. Delta: an ontology for the distribution of differences between RDF graphs [online]. 2009-08-27 [cit. 2013-06-15]. Available from WWW: http://www.w3.org/DesignIssues/Diff
  • CORRENDO, Gianluca [et al.]. Linked Timelines: temporal representation and management in linked data. In First International Workshop on Consuming Linked Data (COLD 2010), Shanghai, China [online]. Aachen: RWTH Aachen University, 2010 [cit. 2013-06-15]. CEUR workshop proceedings, vol. 665. Available from WWW: http://ceur-ws.org/Vol-665/CorrendoEtAl_COLD2010.pdf
  • COX, Simon. DCMI Period Encoding Scheme: specification of the limits of a time interval, and methods for encoding this in a text string [online]. 2006-04-10 [cit. 2013-06-13]. Available from WWW: http://dublincore.org/documents/dcmi-period/
  • DAVIS, Ian. Representing time in RDF part 1 [online]. August 10, 2009 [cit. 2013-06-15]. Available from WWW: http://blog.iandavis.com/2009/08/10/representing-time-in-rdf-part-1/
  • DAVIS, Ian. Representing time in RDF part 2 [online]. August 10, 2009 [cit. 2013-06-15]. Available from WWW: http://blog.iandavis.com/2009/08/10/representing-time-in-rdf-part-2/
  • DAVIS, Ian. Representing time in RDF part 3 [online]. August 10, 2009 [cit. 2013-06-15]. Available from WWW: http://blog.iandavis.com/2009/08/10/representing-time-in-rdf-part-3/
  • DAVIS, Ian. Representing time in RDF part 4 [online]. August 10, 2009 [cit. 2013-06-15]. Available from WWW: http://blog.iandavis.com/2009/08/10/representing-time-in-rdf-part-4/
  • DAVIS, Ian. Representing time in RDF part 5 [online]. August 10, 2009 [cit. 2013-06-15]. Available from WWW: http://blog.iandavis.com/2009/08/10/representing-time-in-rdf-part-5/
  • Defining n-ary relations on the semantic web” [online]. NOY, Natasha; RECTOR, Alan (eds.). April 12, 2006 [cit. 2013-06-13]. Available from WWW: http://www.w3.org/TR/swbp-n-aryRelations/
  • FIELDING, Roy Thomas. Architectural styles and the design of network-based software architectures. Irvine (CA), 2000. 162 p. Dissertation (PhD.). University of California, Irvine.
  • GANGEMI, Aldo. Super-duper schema: an owl2+rif dns pattern. In CHAUDRY, V. (ed.). Proceedings of DeepKR Challenge Workshop at KCAP 2011. 2011. Also available from WWW: http://www.ai.sri.com/halo/public/dkrckcap2011/Gangemi.pdf
  • GANGEMI, Aldo; PRESUTTI, Valentina. A multi-dimensional comparison of ontology design patterns for representing n-ary relations. In SOFSEM 2013: Theory and Practice of Computer Science. Berlin; Heidelberg: Springer, 2013, p. 86 — 105. Lecture notes in computer science, vol. 7741. DOI 10.1007/978-3-642-35843-2_8.
  • GRANDI, Fabio. Multi-temporal RDF ontology versioning. In Proceedings of the 3rd International Workshop on Ontology Dynamics, collocated with the 8th International Semantic Web Conference, Washington DC, USA, October 26, 2009 [online]. Aachen: RWTH Aachen University, 2009 [cit. 2013-06-11]. CEUR workshop proceedings, vol. 519. Available from WWW: http://ceur-ws.org/Vol-519/grandi.pdf
  • GRANDI, Fabio. T-SPARQL: A TSQL2-like temporal query language for RDF. In Local Proceedings of the 14th East-European Conference on Advances in Databases and Information Systems, Novi Sad, Serbia, September 20-24, 2010. [online]. Aachen: RWTH Aachen University, 2010 [cit. 2013-06-11]. CEUR workshop proceedings, vol. 639. Available from WWW: http://ceur-ws.org/Vol-639/021-grandi.pdf
  • GRANDI, Fabio. Introducing an annotated bibliography on temporal and evolution aspects in the semantic web. ACM SIGMOD Record. December 2012, vol. 41, iss. 4, p. 18 — 21. DOI 10.1145/2430456.2430460.
  • GRAU, Bernardo Cuenca [et al.]. OWL 2: the next step for OWL. Journal of Web Semantics. November 2008, vol. 6, iss. 4, p. 309 — 322. DOI 10.1016/j.websem.2008.05.001.
  • GUTIERREZ, Claudio; HURTADO, Carlos A.; VAISMAN, Alejandro. Temporal RDF. In The semantic web: research and applications: proceedings of the 2nd European Semantic Web Conference, Heraklion, Crete, Greece. Berlin; Heidelberg: Springer, 2005, p. 93 — 107. Lecture Notes in Computer Science, vol. 3532. DOI 10.1007/11431053_7.
  • GUTIERREZ, Claudio; HURTADO, Carlos A.; VAISMAN, Alejandro. Introducing time into RDF. IEEE Transactions on Knowledge and Data Engineering. February 2007, vol. 19, no. 2, p. 207 — 218. Also available from WWW: http://www.spatial.cs.umn.edu/Courses/Fall11/8715/papers/time-rdf.pdf
  • HALLOWAY, Stuart. Perception and action: an introduction to Clojure’s time model [online]. April 15, 2011 [cit. 2013-06-15]. Available from WWW: http://www.infoq.com/presentations/An-Introduction-to-Clojure-Time-Model
  • HAYES, Pat. Formal unifying standards for the representation of spatiotemporal knowledge [online]. Pensacola (FL): IHMC, 2004 [cit. 2013-06-15]. Available from WWW: http://www.ihmc.us/users/phayes/arlada2004final.pdf
  • HICKEY, Rich. The Datomic information model [online]. February 1, 2013 [cit. 2013-06-11]. Available from WWW: http://www.infoq.com/articles/Datomic-Information-Model
  • HOFFART, Johannes [et al.]. YAGO2: a spatially and temporally enhanced knowledge base from Wikipedia. Artificial Intelligence. January 2013, vol. 194, p. 28 — 61. DOI 10.1016/j.artint.2012.06.001.
  • The identity of indiscernibles. In Stanford encyclopedia of philosophy [online]. August 15, 2010 [cit. 2013-06-15]. Available from WWW: http://plato.stanford.edu/entries/identity-indiscernible/
  • JENSEN, Christian S. Introduction to temporal database research. In Temporal database management. Aalborg, 2000. Dissertation thesis. Aalborg University. Also available from WWW: http://people.cs.aau.dk/~csj/Thesis/
  • KIRYAKOV, Atanas; OGNYANOV, Damyan. Tracking changes in RDF(S) repositories. In Proceedings of the 13th International Conference on Knowledge Engineering and Knowledge Management: Ontologies and the Semantic Web. London (UK): Springer, 2002, p. 373 — 378. Also available from WWW: http://www.ontotext.com/sites/default/files/publications/TrackingKTSW02.pdf. ISBN 3-540-44268-5.
  • KRIEGER, Hans-Ulrich. Where temporal description logics fail: representing temporally-changing relationships. In Advances in artificial intelligence: proceedings of the 31st Annual German Conference on AI, KI 2008, Kaiserslautern, Germany, September 23 — 26, 2008. Berlin; Heidelberg: Springer, 2008, p. 249 — 257. Lecture notes in computer science, vol. 5243. DOI 10.1007/978-3-540-85845-4_31.
  • LOPES, Nuno [et al.]. RDF needs annotations. In RDF Next Steps: W3C workshop, June 26 — 27, 2010 [online]. 2009 [cit. 2013-06-13]. Available from WWW: http://www.w3.org/2009/12/rdf-ws/papers/ws09
  • MASINTER, Larry. The ‘tdb’ and ‘duri’ URI schemes, based on dated URIs [online]. 2012 [cit. 2013-06-10]. Available from WWW: http://tools.ietf.org/html/draft-masinter-dated-uri-10
  • MCCUSKER, James P.; MCGUINNESS, Deborah L. Towards identity in linked data. In Proceedings of the 7th International Workshop on OWL: Experiences and Directions. San Francisco, California, USA, June 21 — 22, 2010 [online]. Aachen: RWTH Aachen University, 2010 [cit. 2013-06-09]. CEUR workshop proceedings, vol. 614. Available from WWW: http://ceur-ws.org/Vol-614/owled2010_submission_12.pdf
  • MITTELBACH, Arno. RDF and the time dimension, part 1 [online]. 2008-11-28 [cit. 2013-06-16]. Available from WWW: http://oxforderewhon.wordpress.com/2008/11/28/rdf-and-the-time-dimension-part-1/
  • OWL 2 Web Ontology Language: new features and rationale [online]. GOLBREICH, Christine; WALLACE, Evan K. (eds.). 2nd ed. W3C, 2012 [cit. 2013-06-11]. Available from WWW: http://www.w3.org/TR/owl2-new-features
  • PAPAVASILEIOU, Vicky [et al.]. High-level change detection in RDF(S) KBs. ACM Transations on Database Systems. April 2013, vol. 38, iss. 1. DOI 10.1145/2445583.2445584.
  • PROCHÁZKA, Jiří [et al.]. The Property Reification Vocabulary 0.11 [online]. February 19, 2011 [cit. 2013-06-10]. Available from WWW: http://smiy.sourceforge.net/prv/spec/propertyreification.html
  • PUGLIESE, Andrea; UDREA, Octavian; SUBRAHMANIAN, V. S. Scaling RDF with time. In Proceedings of the 17th international conference on World Wide Web. New York (NY): ACM, 2008, p. 605 — 614. Also available from WWW: http://wwwconference.org/www2008/papers/pdf/p605-puglieseA.pdf. DOI 10.1145/1367497.1367579.
  • RDF semantics [online]. HAYES, Patrick (ed.). 2004 [cit. 2013-06-13]. Available from WWW: http://www.w3.org/TR/rdf-mt/
  • RDF 1.1 concepts and abstract syntax: W3C Working Draft [online]. CYGANIAK, Richard; WOOD, David (eds.). January 15, 2013 [cit. 2013-06-12]. Available from WWW: http://www.w3.org/TR/rdf11-concepts/
  • RDF primer” [online]. MANOLA, Frank; MILLER, Eric (eds.). February 10, 2004 [cit. 2013-06-15]. Available from WWW: http://www.w3.org/TR/rdf-primer/
  • REES, Jonathan; BOOTH, David; HAUSENBLAS, Michael. Towards formal HTTP semantics: AWWSW report to the TAG [online]. December 4, 2009 [cit. 2013-06-12]. Available from WWW: http://www.w3.org/2001/tag/awwsw/http-semantics-report.html
  • RULA, Anisa [et al.]. On the diversity and availability of temporal information in linked open data. In Proceedings of the 11th International Semantic Web Conference, Boston, MA, USA, November 11-15, 2012, part I. Berlin; Heidelberg: Springer, 2012, p. 492 — 507. Lecture notes in computer science, vol. 7649. DOI 10.1007/978-3-642-35176-1_31.
  • SANDERSON, Robert D.; VAN DE SOMPEL, Herbert. Cool URIs and dynamic data. IEEE Internet Computing. 2012, vol. 16, no. 4, p. 76 — 79. Also available from WWW: http://public.lanl.gov/herbertv/papers/Papers/2012/CoolURIsDynamicData.pdf. DOI 10.1109/MIC.2012.78. SARACCO, Cynthia M.; NICOLA, Matthias; GANDHI, Lenisha. A matter of time: Temporal data management in DB2 10 [online]. April 3, 2012 [cit. 2013-06-11]. Available from WWW: http://www.ibm.com/developerworks/data/library/techarticle/dm-1204db2temporaldata/
  • TAPPOLET, Jonas; BERNSTEIN, Abraham. Applied temporal RDF: efficient temporal querying of RDF data with SPARQL. In Proceedings of the 6th European Semantic Web Conference. Berlin; Heidelberg: Springer, 2009, p. 308 — 322. DOI 10.1007/978-3-642-02121-3_25.
  • TENNISON, Jeni. Temporal scope for RDF triples [online]. 2009-02-15 [cit. 2013-06-13]. Available from WWW: http://www.jenitennison.com/blog/node/101
  • TENNISON, Jeni. Linked open data in a changing world [online]. 2009-07-10 [cit. 2013-06-12]. Available from WWW: http://www.jenitennison.com/blog/node/108
  • TENNISON, Jeni. Versioning (UK government) linked data [online]. 2010-02-27 [cit. 2013-06-15]. Available from WWW: http://www.jenitennison.com/blog/node/141
  • Time Ontology in OWL: W3C Working Draft 27 September 2006. HOBBS, Jerry R.; PAN, Feng (eds.). W3C, 2006 [cit. 2013-06-09]. Available from WWW: http://www.w3.org/TR/owl-time/
  • UMBRICH, Jörgen; KARNSTEDT, Marcel; LAND, Sebastian. Towards understanding the changing web: mining the dynamics of linked-data sources and entities. In Proceedings of the LWO 2010 Workshop, October 4-6, 2010, Kassel, Germany [online]. Kassel: Universität Kassel, 2010 [cit. 2013-06-09]. Available from WWW: http://www.kde.cs.uni-kassel.de/conf/lwa10/papers/kdml22.pdf
  • VANDER SANDE, Miel [et al.]. R&Wbase: Git for triples. In Proceedings of the WWW2013 Workshop on Linked Data on the Web 2013, May 14, 2013, Rio de Janeiro, Brazil [online]. Aachen: RWTH Aachen University, 2013 [cit. 2013-06-09]. CEUR workshop proceedings, vol. 996. Available from WWW: http://events.linkeddata.org/ldow2013/papers/ldow2013-paper-01.pdf. ISSN 1613-0073.
  • VAN DE SOMPEL, Herbert; NELSON, Michael L.; SANDERSON, Robert D. HTTP framework for time-based access to resource states: Memento [online]. March 29, 2013 [cit. 2013-06-11]. Available from WWW: http://tools.ietf.org/html/draft-vandesompel-memento-07
  • WELTY, Christopher A.; FIKES, Richard. A reusable ontology for fluents in OWL. Formal Ontology in Information Systems: Proceedings of the Fourth International Conference (FOIS 2006). Amsterdam: IOS, 2006, p. 226 — 236. Frontiers in artificial intelligence and applications, vol. 150. ISBN 978-1-58603-685-0.
  • WELTY, Christopher A. Context slices: representing contexts in OWL. In Proceedings of the 2nd International Workshop on Ontology Patterns - WOP2010 [online]. Aachen: RWTH Aachen University, 2010 [cit. 2013-06-16]. CEUR workshop proceedings, vol. 671. Available from WWW: http://ceur-ws.org/Vol-671/pat01.pdf. ISSN 1613-0073.


  1. For example, Semantic Sitemap with <changefreq> element.

  2. http://www.w3.org/TR/xmlschema-2/

  3. http://en.wikipedia.org/wiki/ISO_8601

  4. For example, Dublin Core initiative proposed a way for encoding time intervals into typed literals (Cox, 2006).

  5. https://github.com/ccattuto/neo4j-dynagraph/wiki/Representing-time-dependent-graphs-in-Neo4j

  6. http://www.w3.org/TR/skos-reference/

  7. http://dublincore.org/documents/dcmi-terms/

  8. http://www.w3.org/TR/turtle/

  9. http://www.w3.org/TR/rdf-mt/#Reif

  10. http://www.w3.org/TR/owl2-mapping-to-rdf/#a_Annotation

  11. http://docs.api.talis.com/getting-started/changesets

  12. http://www.cibiv.at/~niko/dsnotify/vocab/eventset/v0.1/dsnotify-eventset.html

  13. There is a convention of using the term “n-ary relation” for relation with arity higher than 2, even though unary and binary relations are n-ary relations as well.

  14. http://www.freebase.com/

  15. http://www.wikidata.org/wiki/Wikidata:Main_Page

  16. http://www.w3.org/TR/vocab-org/#membership-n-ary-relationship

  17. http://www.w3.org/DesignIssues/Generic

  18. http://www.w3.org/DesignIssues/Axioms.html#opaque

  19. There are several proposed serialization formats (e.g., TriG or TriX), none of which reached the status of an official recommendation.

  20. http://patterns.dataincubator.org/book/named-graphs.html

  21. A property from Vocabulary of Interlinked Datasets (VoID). http://www.w3.org/TR/void/

  22. http://www.w3.org/2010/01/Turtle/Trig

  23. http://www.w3.org/2011/rdf-wg/wiki/User:Rcygania2/RDF_Datasets_and_Stateful_Resources

  24. http://www.w3.org/TR/prov-o/

  25. TBox constitutes the terminology used in RDF assertions.

  26. http://parliament.semwebcentral.org/

  27. http://marmotta.incubator.apache.org/kiwi/versioning.html

  28. Metaweb Query Language. http://mql.freebaseapps.com/ch03.html#history

  29. http://docs.datomic.com/architecture.html

  30. http://research.google.com/archive/spanner.html

No comments:

Post a Comment