Motivation

The development of RDF has been motivated by the following uses, among others:

• Web metadata: providing information about Web resources and the systems that use them (e.g. content rating, capability descriptions, privacy preferences, etc.)
• Applications that require open rather than constrained information models (e.g. scheduling activities, describing organizational processes, annotation of Web resources, etc.)
• To do for machine processable information (application data) what the World Wide Web has done for hypertext: to allow data to be processed outside the particular environment in which it was created, in a fashion that can work at Internet scale.
• Interworking among applications: combining data from several applications to arrive at new information.
• Automated processing of Web information by software agents: the Web is moving from having just human-readable information to being a world-wide network of cooperating processes. RDF provides a world-wide lingua franca for these processes.

RDF is designed to represent information in a minimally constraining, flexible way. It can be used in isolated applications, where individually designed formats might be more direct and easily understood, but RDF's generality offers greater value from sharing. The value of information thus increases as it becomes accessible to more applications across the entire Internet.

Design Goals

The design of RDF is intended to meet the following goals:

• having a simple data model
• having formal semantics and provable inference
• using an extensible IRI-based vocabulary
• using an XML-based syntax
• supporting use of XML schema datatypes
• allowing anyone to make statements about any resource

Graph Data Model

The underlying structure of any expression in RDF is a collection of triples, each consisting of a subject, a predicate and an object. A set of such triples is called an RDF graph (defined more formally in section 6). This can be illustrated by a node and directed-arc diagram, in which each triple is represented as a node-arc-node link (hence the term “graph”).

Each triple represents a statement of a relationship between the things denoted by the nodes that it links. Each triple has three parts:

1. a subject,
2. an object, and
3. a predicate (also called a property) that denotes a relationship.

The direction of the arc is significant: it always points toward the object.

The nodes of an RDF graph are its subjects and objects.

The assertion of an RDF triple says that some relationship, indicated by the predicate, holds between the things denoted by subject and object of the triple. The assertion of an RDF graph amounts to asserting all the triples in it, so the meaning of an RDF graph is the conjunction (logical AND) of the statements corresponding to all the triples it contains. A formal account of the meaning of RDF graphs is given in [[!RDF-MT]].

IRI-based Vocabulary and Node Identification

A node may be an IRI, a literal, or blank (having no separate form of identification). Properties are IRIs.

An IRI or literal used as a node identifies what that node represents. An IRI used as a predicate identifies a relationship between the things represented by the nodes it connects. A predicate IRI may also be a node in the graph.

A blank node is a node that is not an IRI or a literal. In the RDF abstract syntax, a blank node is just a unique node that can be used in one or more RDF statements.

A convention used by some linear representations of an RDF graph to allow several statements to use the same blank node is to use a blank node identifier, which is a local identifier that can be distinguished from all IRIs and literals. When graphs are merged, their blank nodes must be kept distinct if meaning is to be preserved; this may call for re-allocation of blank node identifiers. Note that such blank node identifiers are not part of the RDF abstract syntax, and the representation of triples containing blank nodes is entirely dependent on the particular concrete syntax used.

Datatypes

Datatypes are used by RDF in the representation of values such as integers, floating point numbers and dates.

A datatype consists of a lexical space, a value space and a lexical-to-value mapping, see section 5.

For example, the lexical-to-value mapping for the XML Schema datatype xsd:boolean, where each member of the value space (represented here as 'T' and 'F') has two lexical representations, is as follows:

RDF predefines just one datatype rdf:XMLLiteral, used for embedding XML in RDF (see section 5.1).

There is no built-in concept of numbers or dates or other common values. Rather, RDF defers to datatypes that are defined separately, and identified with IRIs. The predefined XML Schema datatypes [[!XMLSCHEMA-2]] are expected to be widely used for this purpose.

RDF provides no mechanism for defining new datatypes. XML Schema Datatypes [[!XMLSCHEMA-2]] provides an extensibility framework suitable for defining new datatypes for use in RDF.

Literals

Literals are used to identify values such as numbers and dates by means of a lexical representation. Anything represented by a literal could also be represented by an IRI, but it is often more convenient or intuitive to use literals.

A literal may be the object of an RDF statement, but not the subject or the predicate.

Literals may be plain or typed :

• A plain literal is a string combined with an optional language tag. This may be used for plain text in a natural language. As recommended in the RDF formal semantics [[!RDF-MT]], these plain literals are self-denoting.
• A typed literal is a string combined with a datatype IRI. It denotes the member of the identified datatype's value space obtained by applying the lexical-to-value mapping to the literal string.

Continuing the example from section 3.3, the typed literals that can be defined using the XML Schema datatype xsd:boolean are:

For text that may contain markup, use typed literals with type rdf:XMLLiteral. If language annotation is required, it must be explicitly included as markup, usually by means of an xml:lang attribute. [[XHTML10]] may be included within RDF in this way. Sometimes, in this latter case, an additional span or div element is needed to carry an xml:lang or lang attribute.

The string in both plain and typed literals is recommended to be in Unicode Normal Form C [[!NFC]]. This is motivated by [[CHARMOD]] particularly section 4 Early Uniform Normalization.

RDF Expression of Simple Facts

Some simple facts indicate a relationship between two things. Such a fact may be represented as an RDF triple in which the predicate names the relationship, and the subject and object denote the two things. A familiar representation of such a fact might be as a row in a table in a relational database. The table has two columns, corresponding to the subject and the object of the RDF triple. The name of the table corresponds to the predicate of the RDF triple. A further familiar representation may be as a two place predicate in first order logic.

Relational databases permit a table to have an arbitrary number of columns, a row of which expresses information corresponding to a predicate in first order logic with an arbitrary number of places. Such a row, or predicate, has to be decomposed for representation as RDF triples. A simple form of decomposition introduces a new blank node, corresponding to the row, and a new triple is introduced for each cell in the row. The subject of each triple is the new blank node, the predicate corresponds to the column name, and object corresponds to the value in the cell. The new blank node may also have an rdf:type property whose value corresponds to the table name.

As an example, consider Figure 6 from the [[RDF-PRIMER]]:

RDF Primer Figure 6: Using a Blank Node

This information might correspond to a row in a table "STAFFADDRESSES", with a primary key STAFFID, and additional columns STREET, STATE, CITY and POSTALCODE.

Thus, a more complex fact is expressed in RDF using a conjunction (logical-AND) of simple binary relationships. RDF does not provide means to express negation (NOT) or disjunction (OR).

Through its use of extensible IRI-based vocabularies, RDF provides for expression of facts about arbitrary subjects; i.e. assertions of named properties about specific named things. An IRI can be constructed for any thing that can be named, so RDF facts can be about any such things.

Entailment

The ideas on meaning and inference in RDF are underpinned by the formal concept of entailment, as discussed in the RDF semantics document [[!RDF-MT]]. In brief, an RDF expression A is said to entail another RDF expression B if every possible arrangement of things in the world that makes A true also makes B true. On this basis, if the truth of A is presumed or demonstrated then the truth of B can be inferred .

XML Content within an RDF Graph

The canonicalization rules required for XML literals are quite complicated. Increasingly, RDF is produced and consumed in environments where no XML parser and canonicalization engine is available. A possible change to relax the requirements for the lexical space, while retaining the value space, is under discussion. This is ISSUE-13.

RDF provides for XML content as a possible literal value. This typically originates from the use of rdf:parseType="Literal" in the RDF/XML Syntax [[!RDF-SYNTAX-GRAMMAR]].

Such content is indicated in an RDF graph using a typed literal whose datatype is a special built-in datatype rdf:XMLLiteral, defined as follows.

An IRI for identifying this datatype

is http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral.

The lexical space

is the set of all strings:

• which are well-balanced, self-contained XML content [[!XML10]];
• for which encoding as UTF-8 [[!RFC2279]] yields exclusive Canonical XML (with comments, with empty InclusiveNamespaces PrefixList ) [[!XML-EXC-C14N]];
• for which embedding between an arbitrary XML start tag and an end tag yields a document conforming to XML Namespaces [[!XML-NAMES]]

The value space

is a set of entities, called XML values, which is:

• disjoint from the lexical space;
• disjoint from the value space of any other datatype that is not explicitly defined as a sub- or supertype of this datatype;
• disjoint from the set of Unicode character strings [[!UNICODE]];
• and in 1:1 correspondence with the lexical space.

The lexical-to-value mapping

is a one-one mapping from the lexical space onto the value space, i.e. it is both injective and surjective.

Not all values of this datatype are compliant with XML 1.1 [[XML11]]. If compliance with XML 1.1 is desired, then only those values that are fully normalized according to XML 1.1 should be used.

XML values can be thought of as the [[XML-INFOSET]] or the [[XPATH]] nodeset corresponding to the lexical form, with an appropriate equality function.

RDF applications may use additional equivalence relations, such as that which relates an xsd:string with an rdf:XMLLiteral corresponding to a single text node of the same string.

RDF Triples

An RDF triple contains three components:

• the subject, which is an IRI or a blank node
• the predicate, which is an IRI
• the object, which is an IRI, a literal or a blank node

An RDF triple is conventionally written in the order subject, predicate, object.

The predicate is also known as the property of the triple.

RDF Graph

An RDF graph is a set of RDF triples.

The set of nodes of an RDF graph is the set of subjects and objects of triples in the graph.

Graph Equivalence

Two RDF graphs G and G' are equivalent if there is a bijection M between the sets of nodes of the two graphs, such that:

1. M maps blank nodes to blank nodes.
2. M(lit)=lit for all RDF literals lit which are nodes of G.
3. M(uri)=uri for all IRIs uri which are nodes of G.
4. The triple ( s, p, o ) is in G if and only if the triple ( M(s), p, M(o) ) is in G'

With this definition, M shows how each blank node in G can be replaced with a new blank node to give G'.

IRIs

An IRI (Internationalized Resource Identifier) within an RDF graph is a Unicode string [[!UNICODE]] that conforms to the syntax defined in RFC 3987 [[!IRI]]. IRIs are a generalization of URIs [[URI]]. Every absolute URI and URL is an IRI.

IRIs in the RDF abstract syntax MUST be absolute, and MAY contain a fragment identifier.

Two IRIs are equal if and only if they are equivalent under Simple String Comparison according to section 5.1 of [[!IRI]]. Further normalization MUST NOT be performed when comparing IRIs for equality.

When IRIs are used in operations that are only defined for URIs, they must first be converted according to the mapping defined in section 3.1 of [[!IRI]]. A notable example is retrieval over the HTTP protocol. The mapping involves UTF-8 encoding of non-ASCII characters, %-encoding of octets not allowed in URIs, and Punycode-encoding of domain names.

Some concrete syntaxes permit relative IRIs as a shorthand for absolute IRIs, and define how to resolve the relative IRIs against a base IRI.

Previous versions of RDF used the term “RDF URI Reference” instead of “IRI” and allowed additional characters: “<”, “>”, “{”, “}”, “|”, “\”, “^”, “`”, ‘“’ (double quote), and “ ” (space). In IRIs, these characters must be percent-encoded as described in section 2.1 of [[URI]].

RDF Literals

Currently, there are three different kinds of literals for expressing strings: plain literals, rdf:PlainLiteral [[RDF-PLAINLITERAL]], and xsd:string. Some consolidation of these forms is under consideration. This is ISSUE-12.

A literal in an RDF graph contains one or two named components.

All literals have a lexical form being a Unicode [[!UNICODE]] string, which SHOULD be in Normal Form C [[!NFC]].

Plain literals have a lexical form and optionally a language tag as defined by [[!RFC3066]], normalized to lowercase.

Typed literals have a lexical form and a datatype IRI being an IRI.

Literals in which the lexical form begins with a composing character (as defined by [[CHARMOD]]) are allowed however they may cause interoperability problems, particularly with XML version 1.1 [[XML11]].

When using the language tag, care must be taken not to confuse language with locale. The language tag relates only to human language text. Presentational issues should be addressed in end-user applications.

The case normalization of language tags is part of the description of the abstract syntax, and consequently the abstract behaviour of RDF applications. It does not constrain an RDF implementation to actually normalize the case. Crucially, the result of comparing two language tags should not be sensitive to the case of the original input.

Blank Nodes

The blank nodes in an RDF graph are drawn from an infinite set. This set of blank nodes, the set of all IRIs and the set of all literals are pairwise disjoint.

Otherwise, this set of blank nodes is arbitrary.

RDF makes no reference to any internal structure of blank nodes. Given two blank nodes, it is possible to determine whether or not they are the same.

http://example.com/.well-known/genid/d26a2d0e98334696f4ad70a677abc1f6

Abstract Syntax for Working with Multiple Graphs