What is Resource Description Framework (RDF) for?

The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web.
by generalizing the concept of a "Web resource", RDF can also be used to represent information about things that can be identified on the Web, even when they cannot be directly retrieved on the Web.
RDF is intended for situations in which this information needs to be processed by applications, rather than being only displayed to people.
RDF provides a common framework for expressing this information so it can be exchanged between applications without loss of meaning..

The Main Idea of RDF

RDF is based on the idea of identifying things using Web identifiers (called Uniform Resource Identifiers, or URIs), and describing resources in terms of simple properties and property values.
This enables RDF to represent simple statements about resources as a graph of nodes and arcs representing the resources, and their properties and values.
Example: "there is a Person identified by http://www.w3.org/People/EM/contact#me, whose name is Eric Miller, whose email address is em@w3.org, and whose title is Dr.".

RDF Graph

The example: "there is a Person identified by http://www.w3.org/People/EM/contact#me, whose name is Eric Miller, whose email address is em@w3.org, and whose title is Dr.".
A RDF Graph for the example:

RDF/XML: RDF in XML-based Syntax

The RDF Graph:

A RDF/XML representation for the graph:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
             xmlns:contact="http://www.w3.org/2000/10/swap/pim/contact#">

  <contact:Person rdf:about="http://www.w3.org/People/EM/contact#me">
    <contact:fullName>Eric Miller</contact:fullName>
    <contact:mailbox rdf:resource="mailto:em@w3.org"/>
    <contact:personalTitle>Dr.</contact:personalTitle> 
  </contact:Person>

</rdf:RDF>

RDF: Making Statements about Resources

A statement:

http://www.example.org/index.html has a creator whose value is John Smith
When making a statement, we need ways to identify "things":
- the thing the statement describes (the Web page, in this case)
- a specific property (creator, in this case) of the thing the statement describes
- the thing the statement says is the value of this property (who the creator is), for the thing the statement describes
RDF is based on the idea that the things being described have properties which have values, and that resources can be described by making statements that specify those properties and values.

RDF Terminology for Making Statements

In an RDF statement:
- A subject refers to the part that identifies the thing the statement is about (the Web page in this example).
- A predicate refers to the part that identifies the property of the subject that the statement specifies (creator).
- An object refers to the part that identifies the value of that property.
A statement:

http://www.example.org/index.html has a creator whose value is John Smith
The RDF terms for the various parts of the statement are:
- the subject is the URL http://www.example.org/index.html
- the predicate is the word "creator"
- the object is the phrase "John Smith"

RDF: Making Machine-processable Statements

To make statements suitable for processing by machines, two things are needed:
- a system of machine-processable identifiers for identifying a subject, predicate, or object in a statement without any possibility of confusion.
- a machine-processable language for representing these statements and exchanging them between machines.
RDF uses URI reference as the basis of its mechanism for identifying the subjects, predicates, and objects in statements.
RDF uses XML to represent statements in a machine-processable way.
- Uniform Resource Locator (URL): A URL is a character string that identifies a Web resource by representing its primary access mechanism (i.e., its network "location").
- Uniform Resource Identifier (URI): URLs are a particular kind of URI. URIs are not limited to identifying things that have network locations. A URI can be created to refer to anything that needs to be referred to in a statement.
- URI Reference (URIref): A URI reference is a URI, together with an optional fragment identifier at the end. For example, the URI reference http://www.example.org/index.html#section2 consists of the URI http://www.example.org/index.html and (separated by the "#" character) the fragment identifier Section2.

The RDF Model

RDF models statements as nodes and arcs in a graph. In this notation, a statement is represented by:
- a node for the subject
- a node for the object
- an arc for the predicate, directed from the subject node to the object node.
Three statements:

http://www.example.org/index.html has a creator whose value is John Smith

http://www.example.org/index.html has a creation-date whose value is August 16, 1999

http://www.example.org/index.html has a language whose value is English
The corresponding RDF graph (using suitable URIrefs to name the properties "creator", "creation-date", and "language"):

The Triple Notation for RDF Graphs

A RDF graph:

The triples for the RDF graph:

<http://www.example.org/index.html> <http://purl.org/dc/elements/1.1/creator> <http://www.example.org/staffid/85740> .

<http://www.example.org/index.html> <http://www.example.org/terms/creation-date> "August 16, 1999" .

<http://www.example.org/index.html> <http://purl.org/dc/elements/1.1/language> "en" .

Triples can be abbreviated by using prefixes (which denote namespace URIs):

ex:index.html  dc:creator             exstaff:85740 .
ex:index.html  exterms:creation-date  "August 16, 1999" .
ex:index.html  dc:language            "en" .

Frequently used prefixes:

prefix rdf:, namespace URI: http://www.w3.org/1999/02/22-rdf-syntax-ns#
prefix rdfs:, namespace URI: http://www.w3.org/2000/01/rdf-schema#
prefix dc:, namespace URI: http://purl.org/dc/elements/1.1/
prefix owl:, namespace URI: http://www.w3.org/2002/07/owl#
prefix xsd:, namespace URI: http://www.w3.org/2001/XMLSchema#

prefix ex:, namespace URI: http://www.example.org/
prefix exterms:, namespace URI: http://www.example.org/terms/
prefix exstaff:, namespace URI: http://www.example.org/staffid/

Vocabulary in RDF

As RDF uses URIrefs instead of words to name things in statements, RDF refers to a set of URIrefs (intended for a specific purpose) as a vocabulary.
Often, the URIrefs in a vocabulary are organized in such a way where a common namespace URIref is chosen for all terms in a vocabulary; URIrefs that are contained in the vocabulary are formed by appending individual local names to the end of the common URIref (hence, forming XML qualified names; QName).This forms a set of URIrefs with a common prefix.
Often an organization will use a vocabulary's namespace URIref as the URL of a Web resource that provides further information about that vocabulary.
For example, the QName prefix dc: is associated with the namespace URIref http://purl.org/dc/elements/1.1/. This again refers to the Dublin Core vocabulary: Accessing this namespace URIref in a Web browser will retrieve additional information about the Dublin Core vocabulary (in this case, an RDF schema).
URIrefs from different vocabularies can be freely mixed in RDF graphs.

More on URIrefs and Vocabularies

Advantages of using URIrefs as RDF's basic way of identifying things (using the following RDF graph as an example):

The identification can be more precise. For example, the creator of the web page is not the character string "John Smith", or any people named John Smith, but the particular John Smith associated with URIref http://www.example.org/staffid/85740.
Since there is a URIref to refer to John Smith, additional information can be recorded about him by simply adding additional RDF statements with John's URIref as the subject.

Note that RDF uses URIrefs as predicates in RDF statements. That is, rather than using character strings such as "creator" or "name" to identify properties, RDF uses URIrefs. Using URIrefs to identify properties has several advantages:

It distinguishes the properties one person may use from different properties someone else may use that would otherwise be identified by the same character string (e.g., what kind of "name"?)
It enables the properties to be treated as resources themselves.

Using URIrefs as subjects, predicates, and objects in RDF statements supports the development and use of shared vocabularies on the Web.

For this reason, it is a good idea to try to use terms from existing vocabularies (such as the Dublin Core) where possible, rather than making up new terms that might overlap with those of some other vocabulary.

Structured Property Values

A person's whole address could be written out as a plain literal, as in the following triple:

exstaff:85740   exterms:address   "1501 Grant Avenue, Bedford, Massachusetts 01730" .

What if the address needed to be recorded as a structure consisting of separate street, city, state, and postal code values? This is solved in RDF by the following:

exstaff:85740       exterms:address        exaddressid:85740 .
exaddressid:85740   exterms:street         "1501 Grant Avenue" .
exaddressid:85740   exterms:city           "Bedford" .
exaddressid:85740   exterms:state          "Massachusetts" .
exaddressid:85740   exterms:postalCode     "01730" .

Blank Nodes

exstaff:85740   exterms:address         _:johnaddress .
_:johnaddress   exterms:street          "1501 Grant Avenue" .
_:johnaddress   exterms:city            "Bedford" .
_:johnaddress   exterms:state           "Massachusetts" .
_:johnaddress   exterms:postalCode      "01730" .

Typed Literals

An RDF typed literal is formed by pairing a string with a URIref that identifies a particular datatype. The value represented by the typed literal is the value that the specified datatype associates with the specified string. The datatypes used in typed literals are defined externally to RDF, and identified by their datatype URIs.

Example:

Triple notation:

<http://www.example.org/staffid/85740>  <http://www.example.org/terms/age> "27"^^<http://www.w3.org/2001/XMLSchema#integer> .

Or, using the QName abbreviation:

exstaff:85740  exterms:age  "27"^^xsd:integer .

RDF/XML: An XML Syntax for RDF

A RDF graph:

Several Statements About the Same Resource

Its RDF/XML presentation:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:dc="http://purl.org/dc/elements/1.1/"
            xmlns:exterms="http://www.example.org/terms/">

  <rdf:Description rdf:about="http://www.example.org/index.html">

      <exterms:creation-date>August 16, 1999</exterms:creation-date>
  </rdf:Description>

  <rdf:Description rdf:about="http://www.example.org/index.html">
      <dc:language>en</dc:language>

  </rdf:Description>

  <rdf:Description rdf:about="http://www.example.org/index.html">
      <dc:creator rdf:resource="http://www.example.org/staffid/85740"/>
  </rdf:Description>

</rdf:RDF>

An abbreviation:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:dc="http://purl.org/dc/elements/1.1/"
            xmlns:exterms="http://www.example.org/terms/">

  <rdf:Description rdf:about="http://www.example.org/index.html">

       <exterms:creation-date>August 16, 1999</exterms:creation-date>
       <dc:language>en</dc:language>
       <dc:creator rdf:resource="http://www.example.org/staffid/85740"/>
  </rdf:Description>

</rdf:RDF>

Blank Nodes in RDF/XML

A RDF graph:

Its RDF/XML presentation:

<?xml version="1.0"?>

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:dc="http://purl.org/dc/elements/1.1/"
            xmlns:exterms="http://example.org/stuff/1.0/">

   <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar">
     <dc:title>RDF/XML Syntax Specification (Revised)</dc:title>
     <exterms:editor rdf:nodeID="abc"/>
   </rdf:Description>

   <rdf:Description rdf:nodeID="abc">
       <exterms:fullName>Dave Beckett</exterms:fullName>
       <exterms:homePage rdf:resource="http://purl.org/net/dajobe/"/>
   </rdf:Description>

</rdf:RDF>

Typed Literals in RDF/XML

A triple with typed literal:

ex:index.html   exterms:creation-date   "1999-08-16"^^xsd:date .

Its RDF/XML presentation:

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:exterms="http://www.example.org/terms/">

 <rdf:Description rdf:about="http://www.example.org/index.html">
   <exterms:creation-date rdf:datatype=
     "http://www.w3.org/2001/XMLSchema#date">1999-08-16
   </exterms:creation-date>
 </rdf:Description>

</rdf:RDF>

Abbreviation using internal DTD subset:

<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>

<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:exterms="http://www.example.org/terms/">

  <rdf:Description rdf:about="http://www.example.org/index.html">
    <exterms:creation-date rdf:datatype="&xsd;date">1999-08-16
    </exterms:creation-date>

  </rdf:Description>

</rdf:RDF>

Use Fragment Identifiers and Base URIs in RDF/XML

An Example:

<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:exterms="http://www.example.com/terms/"
            xml:base="http://www.example.com/2002/04/products">

  <rdf:Description rdf:ID="item10245">
       <exterms:model rdf:datatype="&xsd;string">Overnighter</exterms:model>
       <exterms:sleeps rdf:datatype="&xsd;integer">2</exterms:sleeps>
       <exterms:weight rdf:datatype="&xsd;decimal">2.4</exterms:weight>
       <exterms:packedSize rdf:datatype="&xsd;integer">784</exterms:packedSize>
  </rdf:Description>

</rdf:RDF>

The above statement (the rdf:Description element) talks about the resource located at http://www.example.com/2002/04/products#item10245.

Class in RDF

What a RDF resource is described with a predefined rdf:type property, the value of that property is considered to be a resource that represents a category or class of things, and the subject of that property is considered to be an instance of that category or class.

An example:

<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:exterms="http://www.example.com/terms/"
            xml:base="http://www.example.com/2002/04/products">

  <rdf:Description rdf:ID="item10245">
       <rdf:type rdf:resource="http://www.example.com/terms/Tent"/>
       <exterms:model rdf:datatype="&xsd;string">Overnighter</exterms:model>
       <exterms:sleeps rdf:datatype="&xsd;integer">2</exterms:sleeps>
       <exterms:weight rdf:datatype="&xsd;decimal">2.4</exterms:weight>
       <exterms:packedSize rdf:datatype="&xsd;integer">784</exterms:packedSize>
  </rdf:Description>
</rdf:RDF>

Resource http://www.example.com/2002/04/products#item10245 is an instance of the class http://www.example.com/terms/Tent. Note that a class is in itself a resource.

Typed Node in RDF

It is fairly common in RDF for resources to have rdf:type properties that describe the resources as instances of specific types or classes. Such resources are called typed nodes in the graph, or typed node elements in the RDF/XML.

RDF/XML provides a special abbreviation for describing these typed nodes. In this abbreviation, the rdf:type property and its value are removed, and the rdf:Description element for the node is replaced by an element whose name is the QName corresponding to the value of the removed rdf:type property (a URIref that names a class).

The previous example, in abbreviation :

<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:exterms="http://www.example.com/terms/"
            xml:base="http://www.example.com/2002/04/products">

  <exterms:Tent rdf:ID="item10245">
       <exterms:model rdf:datatype="&xsd;string">Overnighter</exterms:model>
       <exterms:sleeps rdf:datatype="&xsd;integer">2</exterms:sleeps>
       <exterms:weight rdf:datatype="&xsd;decimal">2.4</exterms:weight>
       <exterms:packedSize rdf:datatype="&xsd;integer">784</exterms:packedSize>
  </exterms:Tent>
</rdf:RDF>

RDF Containers

RDF provides a container vocabulary for describing things in groups. A container is a resource that contains other things (called members). The members of a container may be resources or literals.

RDF defines three types of containers:

rdf:Bag — A Bag represents a group of resources or literals, possibly including duplicate members, where there is no significance in the order of the members.
rdf:Seq — A Sequence represents a group of resources or literals, possibly including duplicate members, where the order of the members is significant.
rdf:Alt — An Alternative a group of resources or literals that are alternatives (typically for a single value of a property).

RDF Containers: An Example

"Course 6.001 has the students Amy, Mohamed, Johann, Maria, and Phuong":

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:s="http://example.org/students/vocab#">

   <rdf:Description rdf:about="http://example.org/courses/6.001">
      <s:students>
         <rdf:Bag>
            <rdf:li rdf:resource="http://example.org/students/Amy"/>
            <rdf:li rdf:resource="http://example.org/students/Mohamed"/>
            <rdf:li rdf:resource="http://example.org/students/Johann"/>
            <rdf:li rdf:resource="http://example.org/students/Maria"/>
            <rdf:li rdf:resource="http://example.org/students/Phuong"/>
         </rdf:Bag>
      </s:students>
   </rdf:Description>
</rdf:RDF>

Note that, in forming the corresponding graph, the the numbered properties rdf:_1, rdf:_2, and so on are generated from the rdf:li elements:

RDF Schema

RDF Schema provides the facilities needed to describe application-specific classes and properties, and to indicate which classes and properties are expected to be used together.

RDF Schema provides a type system for RDF. The RDF Schema type system is similar in some respects to the type systems of object-oriented programming languages. That is, it allows resources to be defined as instances of one or more classes. In addition, it allows classes to be organized in a hierarchical fashion.

The RDF Schema facilities are themselves provided in the form of an RDF vocabulary; that is, as a specialized set of predefined RDF resources with their own special meanings. The resources in the RDF Schema vocabulary have URIrefs with the prefix http://www.w3.org/2000/01/rdf-schema# (conventionally associated with the QName prefix rdfs:).

Describing Classes

In RDF Schema, a class is any resource having an rdf:type property whose value is the resource rdfs:Class.

Often a class to be described is a specialization of an existing class. This kind of relationship between the two classes is described using the predefined rdfs:subClassOf property.

An example (in triple notation):

ex:MotorVehicle       rdf:type          rdfs:Class .
ex:PassengerVehicle   rdf:type          rdfs:Class .
ex:Van                rdf:type          rdfs:Class .
ex:Truck              rdf:type          rdfs:Class .
ex:MiniVan            rdf:type          rdfs:Class .

ex:PassengerVehicle   rdfs:subClassOf   ex:MotorVehicle .
ex:Van                rdfs:subClassOf   ex:MotorVehicle .
ex:Truck              rdfs:subClassOf   ex:MotorVehicle .

ex:MiniVan            rdfs:subClassOf   ex:Van .
ex:MiniVan            rdfs:subClassOf   ex:PassengerVehicle .

The RDF model:

Describing Properties

In RDF Schema, properties are described using the RDF class rdf:Property, and the RDF Schema properties rdfs:domain, rdfs:range, and rdfs:subPropertyOf.

All properties in RDF are described as instances of class rdf:Property.

The rdfs:range property is used to indicate that the values of a particular property are instances of a designated class.

The rdfs:domain property is used to indicate that a particular property applies to a designated class.

RDF Schema provides a way to specialize properties as well as classes. This specialization relationship between two properties is described using the predefined rdfs:subPropertyOf property.

RDF Schema Document: An Example

<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
<rdf:RDF   
  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  
  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
  xml:base="http://example.org/schemas/vehicles">

<rdfs:Class rdf:ID="MotorVehicle"/>

<rdfs:Class rdf:ID="PassengerVehicle">

  <rdfs:subClassOf rdf:resource="#MotorVehicle"/>
</rdfs:Class>

<rdfs:Class rdf:ID="Truck">
  <rdfs:subClassOf rdf:resource="#MotorVehicle"/>
</rdfs:Class>

<rdfs:Class rdf:ID="Van">
  <rdfs:subClassOf rdf:resource="#MotorVehicle"/>

</rdfs:Class>

<rdfs:Class rdf:ID="MiniVan">
  <rdfs:subClassOf rdf:resource="#Van"/>
  <rdfs:subClassOf rdf:resource="#PassengerVehicle"/>
</rdfs:Class>

<rdfs:Class rdf:ID="Person"/>

<rdfs:Datatype rdf:about="&xsd;integer"/>

<rdf:Property rdf:ID="registeredTo">
  <rdfs:domain rdf:resource="#MotorVehicle"/>
  <rdfs:range rdf:resource="#Person"/>
</rdf:Property>

<rdf:Property rdf:ID="rearSeatLegRoom">

  <rdfs:domain rdf:resource="#PassengerVehicle"/> 
  <rdfs:range rdf:resource="&xsd;integer"/>
</rdf:Property>

<rdf:Property rdf:ID="driver">
  <rdfs:domain rdf:resource="#MotorVehicle"/>
</rdf:Property>

<rdf:Property rdf:ID="primaryDriver">
  <rdfs:subPropertyOf rdf:resource="#driver"/>
</rdf:Property>

</rdf:RDF>

An Instance

<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:ex="http://example.org/schemas/vehicles#"
            xml:base="http://example.org/things">

  <ex:PassengerVehicle rdf:ID="johnSmithsCar">
       <ex:registeredTo rdf:resource="http://www.example.org/staffid/85740"/>
       <ex:rearSeatLegRoom 
           rdf:datatype="&xsd;integer">127</ex:rearSeatLegRoom>
       <ex:primaryDriver rdf:resource="http://www.example.org/staffid/85740"/>
  </ex:PassengerVehicle>

</rdf:RDF>