An Introduction to RDF

Ian Davis, <ian.davis@talis.com>

Technical Lead, Research Group

Talis Information Ltd.

(Note: click background or use left/right cursors to navigate this presentation. Home and End keys take you to the start/end)

What is RDF?

• Resource Description Framework
• http://www.w3.org/RDF/
• In essence a simple data model
• It's about writing down relations
• Part of the semantic web layer cake...

Layer Cake?

Layer Cake

Some History

• Mid 90's: MCF by R. Guha
• Late 90's: MCF/XML by Tim Bray and Guha
• 1998: RDF born from W3C
• 2004: specifications completely overhauled

Motivations

• The web is a global, universal information space for documents
• Can we do same for data?
• Make the web into a database?
• RDF is the data format for that database

Goal

To allow anyone to say anything about anything

The Relational Model

A typical relational database table for books

The Relational Model

The rows represent the things you are storing information about

The Relational Model

The columns represent the properties or attributes of those things

The Relational Model

The intersection gives the value of that property for that thing

The Relational Model

the book has a title with value "Javascript"

The Relational Model

the book has a title with value "Javascript"

The Relational Model

subject has a property with value "value" (s,p,v)

Triples

This is the essence of RDF: the (s,p,v) triple

More Properties

What about showing more properties

More Properties

Equivilent to...

Relations Between Entities

Publishers table: publisherID is primary key and exists as foreign key in Books table

Relations Between Entities

RDF Is A Graph

• An (s,p,v) triple can be viewed as a labelled edge in a graph
• The formal semantics of RDF is also described using graphs
• Think in terms of graphs, not XML or documents
• Nodes in graph are things, arcs are relationship between things

Global Naming

• For a web-scale database, need to be able to identify things globally and uniquely
• URLs already provide those capabilities
• RDF names things with URLs
• URLs ground RDF into the Web - existing tools work

Enough Names?

• There are an infinite number of possible URLs
• URLs name only one thing
• Create different URLs to name different things
• Don't use my names for your things...
• ...unless you intend to refer to exactly the same thing...
• ...then go ahead :)

Graph Components

Graphs can have named things - resources...

Graph Components

...and text values (literals)

Graph Components

...and numeric values (also literals)

Graph Components

...and named relations

Graph Components

...and unnamed things

Graph Components

...that can also be related to other things

Merging

• Graphs from different sources can be merged
• Nodes with the same URL are considered identical
• Unlabelled nodes are kept separate (for now...)
• No limitations on graphs that can be merged
• Any RDF can be merged with any other RDF
• Remixing anyone?

Merging Example

Merging Example

Merging Example

Merging Is Safe By Design

• Adding triples never changes the meaning of a graph
• i.e. you can't unsay things by adding triples
• and you can't invalidate earlier conclusions
• Formally this means that RDF is monotonic
• It's a key part of the design for scalability

Scaling The Web

• TBL made simplifications in the web's design to enable huge scalability
• Pre-web: all links were two-way
• Simplification: back-links are optional; most links work, some break
• Benefits: scalability; can link from my site to google without a link back

Partial Understanding

• In RDF, analagous simplification is that of partial understanding:
• Pre-web: require all data to be available before making decisions
• Simplification: enable partial understanding via monotonic property
• Benefits: scalability; can process data as it becomes available
• "Missing Isn't Broken"

URLs For Lookup

• This is the web - URLs can be retrieved
• Fetch any URL from a graph to lookup more RDF about it
• Which can be safely merged into the graph
• And may have other URLs which can be looked up.
• What RDF might be provided at http://ex.org/thing/book?
• title, author, isbn, publisher... anything

RDF Schemas

• Lookup a property - what kind of RDF should be provided?
• e.g.http://purl.org/dc/elements/1.1/title
• RDF Schemas provide additional info about properties...
• ... and classes which describe the type of a resource
• e.g. "Book", "Person" or "Publisher"

RDF Schemas

• RDF Schemas are not like XML Schemas
• RDF Schemas are descriptive not prescriptive
• i.e. they don't give rules of what is allowed
• but enrich the descriptions of what you already have
• Validation makes no sense

Schema Uses

• Define some URLs for naming properties
• And some URLs for naming classes
• Classes can be marked as being subclasses of other classes
• Properties can be marked as being subproperties of other properties
• Terms can be related to terms from other schemas

Subclass Example

Suppose you have a simple piece of information

Subclass Example

Fetching the URL of the class returns RDF

Subclass Example

If every thing that is a book is an artistic work then...

Which Means...?

• Your application doesn't need to know that a book is an artistic work up front
• It has a strategy for discovering it at runtime
• So is decoupled from detailed data model
• And has a chance for operating with unknown data types
• If it can relate it to something it does understand

Domains And Ranges

• Properties can have domains
• Which tell you the class of the subject of the property
• And ranges
• Which tell you the class of the value of the property

Domain/Range Example

Another tiny piece of information

Domain/Range Example

Fetching the URL of the property returns RDF

Domain/Range Example

So we can infer the types of the subject and object

Which Means...?

• Your data doesn't need to contain explicit types everywhere
• Applications can look them up
• "Duck Typing"
• If it walks like a duck and quacks like a duck...
• Classes are determined based on the properties of the thing
• e.g. Authors are all things that have written something

Popular Schemas

• RSS 1.0
• FOAF
• FRBR
• Creative Commons
• SKOS
• Geo
• See http://www.schemaweb.info/

RSS 1.0

• Describes lightweight syndication channels
• Properties: title, link, description
• Classes: channel, item, image
• http://purl.org/rss/1.0/

FOAF

• Describes people and their social networks
• Properties: name, homepage, knows, weblog, interest
• Classes: Person, Document, Project, Group
• http://xmlns.com/foaf/0.1/

FRBR

• Describes bibliographic records
• Properties: creator, part, embodiment, successor, subject
• Classes: Work, Expression, Manifestation, Item
• http://purl.org/vocab/frbr/core

Creative Commons

• Describes licenses for creative works
• Properties: license, permits, requires, prohibits
• Classes: Work, Agent, License, Permission
• http://creativecommons.org/technology/metadata/schema.rdf

SKOS

• Describes thesauruses and taxonomies
• Properties: broader,narrower, subject, related
• Classes: Concept, Collection
• http://www.w3.org/2004/02/skos/core/

Geo

• Describes geographic positions of things
• Properties: lat, long, alt
• Classes: SpatialThing, Point
• http://www.w3.org/2003/01/geo/

Standardise To Scale

• A standard data model: the graph
• A standard naming system: URLs
• A standard discovery mechanism: lookup
• A standard composition mechanism: merging

Remember Containerisation?

Decouple Through Standards

• Negotiating formats limits scalability
• Businesses decouple by exchanging goods using the same container dimensions
• Applications can decouple by exchanging data using the same model

Decentralise To Scale

• Two people can describe the same thing if they use the same name (URL)
• These descriptions can be safely merged
• Allows descriptions to be authored independently and in parallel
• Many more people can get involved

Reduce Coordination Costs

• XML thinks about the world in terms of tags
• What tags can appear inside <rss>?
• Doesn't scale because of level of coordination between parties needed
• In RDF you don't need permission to invent new tags
• Or to put your tags inside someone else's
• Just do it - data model will ensure it's understood

What Else?

What Else?

• Moving up the stack
• OWL - Ontology descriptions - complete
• SPARQL - Query language - almost complete
• Rules - just starting

Issues

• Not all rosy
• XML format for RDF doesn't play well with XML tools like XSLT
• The URI crisis: does http://www.talis.com/ identify the company, the web page or something else?
• The RDF Tax: added complexity not needed for 90% of applications

End of Part 1

This is the end of the high level stuff...

Graph Rules

• Remember three types of node: URL, blank or literal
• In a triple...
• Subjects can be URLs or blank
• Properties can be URLs
• Values can be URLs, blank or literals
• (More formally use URI not just URL)

Writing Down Graphs

• A few options
• Turtle - a text based format, easy to scribble, easy to read
• RDF/XML - an XML based format, hard to read/write
• Fundamental problem in XML: representing a graph with a tree

Turtle - Basic Syntax

• Triples are terminated with a full stop
• URIs are enclosed in angle brackets ( < and >)
• Literals are enclosed by double quotes
• <http://example.com/thing> <http://example.com/relation> "Some Text" .

Turtle - Prefixes

• Use @PREFIX to shorten URIs
• @PREFIX ex: <http://example.com/> .
• Which enables us to write:
• ex:thing ex:relation "Some Text" .
• ex:thing means concatenate http://example.com/ with thing to give http://example.com/thing

Turtle - Triples About Same Subject

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Some Text" .
ex:thing ex:otherrelation ex:otherthing .

can be written as:

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Some Text" ;
         ex:otherrelation ex:otherthing .

Semicolon separates statements that differ in property and value

Turtle - Same Properties

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Some Text" .
ex:thing ex:relation ex:otherthing .

can be written as:

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Some Text" ,
                     ex:otherthing .

Comma separates statements that differ in value only

Turtle - Eliminate Redundant Triples

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Some Text" .
ex:thing ex:relation "Some Text" .

has same meaning as:

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Some Text" .

Turtle - Blank Nodes

@PREFIX ex: <http://example.com/> .
_:a ex:relation "Some Text" .

'a' is the label - valid only within a single document

if above triple appeared in another document it would refer to different node

Turtle - Unlabelled Blank Nodes

@PREFIX ex: <http://example.com/> .
  ex:thing ex:relation _:a .
  _:a ex:property "foo" .
  _:a ex:property "bar"

is same as

ex:thing ex:relation [
    ex:property "foo" ;
    ex:property "bar" 
  ] .

Turtle - Literals With Language

In RDF, literals can have a language

Written in Turtle as:

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "Hello"@en .
ex:thing ex:relation "Bonjour"@fr .

Turtle - Literals With Datatypes

In RDF, literals can have a datatype

Written in Turtle as:

@PREFIX ex: <http://example.com/> .
ex:thing ex:relation "49"^^<http://example.com/datatype> .

Can't have both a datatype and a language

Turtle - Longer Example

@PREFIX dc: <http://purl.org/dc/elements/1.1/> .
@PREFIX foaf: <http://xmlns.com/foaf/0.1/ .
<http://www.talis.com/> 
  dc:title "Talis Information Ltd." ;
  dc:description "The home page of Talis" ;
  dc:publisher [
    foaf:name "Talis"
  ] ;
  dc:date "2005-08-01" .

Interpreted as... the resource denoted by the URI http://www.talis.com/ has a title ..., a description ..., was published by ...

Turtle - Longer Example

Turtle - Types

'a' keyword is shorthand for the URI http://www.w3.org/1999/02/22-rdf-syntax-ns#type

@PREFIX dct: <http://purl.org/dc/terms/> .
_:x
  a dct:Collection .

Same as

@PREFIX dct: <http://purl.org/dc/terms/> .
@PREFIX rdf:  .
_:x
  rdf:type dct:Collection .

More On Schemas

• By convention properties are named using camel case: theProperty
• Classes are named using title case: TheClass
• Not universal, just a convention

Schema Example

Suppose we have this RDF schema:

@PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@PREFIX ex: <http://example.com/schema#> .

ex:Person a rdfs:Class .
ex:spouse a rdfs:Property .

Schema Example

We could use it like this:

@PREFIX ex: <http://example.com/schema#> .

_:fred
  a ex:Person ;
  ex:spouse _:wilma .

A query for all things with type ex:Person would return fred

Adding A Range

ex:Person a rdfs:Class .
ex:spouse a rdfs:Property ;
          rdfs:range ex:Person .

Now whenever we use the property ex:spouse we can infer that the value is a ex:Person

A query against the data will now return wilma as well.

Adding A Domain

We can simplify by adding a domain for the property

ex:Person a rdfs:Class .
ex:spouse a rdfs:Property ;
          rdfs:range ex:Person .
          rdfs:domain ex:Person .

Which lets us omit the type from our data - we can infer it instead

@PREFIX ex: <http://example.com/schema#> .
_:fred
  ex:spouse _:wilma .

More On Domains and Ranges

• Properties can have any number of domains and ranges
• They all apply
• Resources can have multiple types:
• Person... Father... Employee... Goalkeeper... Lover...
• Remember RDF schemas add information not restrict what you can say.

OWL

• Web Ontology Language
• Provides rich set of concepts for defining classes and properties
• Primary Keys
• Cardinality restrictions
• Class Equivilence, Intersections and Unions

OWL

• Like RDF schemas it's not prescriptive
• But adds concept of inconsistency
• If you say two classes are disjoint, i.e. no Person is a Chair
• And find a resource that typed as both a Person and a Chair
• Graph is said to be inconsistent

Primary Keys

• owl:InverseFunctionalProperty (IFP)
• If a property is inverse functional then the value of that property identifies the subject
• e.g. The isbn relation is inverse functional.
• ...for any ISBN, there is only one book that has that ISBN.

IFP Example

IFP Example

Smushing

• Smushing is a special type of merging
• Given IFPs it's possible to merge blank nodes as shown
• This means it's possible to merge descriptions of things without needing to agree on URIs
• Which can be hard for things like people...

I Am Not A Number

Smushing

• FOAF defines the folllowing IFPs
• foaf:aimChatID, foaf:homepage, foaf:icqChatID, foaf:isPrimaryTopicOf, foaf:jabberID, foaf:mbox, foaf:msnChatID, foaf:yahooChatID
• So you can refer to people indirectly, e.g. Shakespeare

• _:person 
    foaf:isPrimaryTopicOf <http://en.wikipedia.org/wiki/Shakespeare> .

• This uniquely identifies the person as being the one that is the primary topic of that Wikipedia page.

Cardinality

• For something to be a member of the class it must have the specified number of relations
• owl:cardinality (humans have exactly 2 parents)
• owl:minCardinality (cars have at least 3 wheels)
• owl:maxCardinality (silver support contracts allow a max of 5 calls)

The Open World Assumption

• RDF and OWL assume an Open World
• Closed world - everything we don't know is false
• Open world - everything we don't know is undefined
• Open World Assumption can be counter-intuitive

The Open World Assumption

• _:fred ex:spouse _:wilma .
• Is _:fred married to _:betty?
• Closed world - no
• Open world - maybe

The Open World Assumption

• _:fred ex:spouse _:wilma .
• _:fred ex:spouse _:betty .
• Not inconsistent given our knowledge

The Open World Assumption

• Suppose cardinality of ex:spouse was one
• i.e. things can only have one spouse
• Are our triples inconsistent now?
• No - reasoner must assume that there is only one spouse - therefore _:wilma and _:betty are the same individual
• Must explicitly be told otherwise

A Riddle

• Two sons and two fathers went to a pizza restaurant. They ordered three pizzas. When they arrived, everyone had a whole pizza. How can that be?
• In OWL those individuals are not assumed to be distinct - so this riddle is easily satisfied
• OWL has no Unique Name Assumption - unlike most humans

RDF/XML

• RDF can be expressed in XML - called RDF/XML
• Subjects of triples are written as as <rdf:Description rdf:about="URI">
• Properties are written as child elements
• Literal values are written as text content
• URI value is written as rdf:resource="xxx" attribute

RDF/XML Example

This Turtle...

@PREFIX ex: <http://example.com/schema#> .

<http://example.com/house>
  ex:title "a house" ;
  ex:owner _:owner .

_:owner 
  a ex:Person ;
  ex:name "Fred" .

RDF/XML Example

Corresponds to this RDF/XML...

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

  <rdf:Description rdf:about="http://example.com/house">
   <ex:title>a house</ex:title>
   <ex:owner rdf:nodeID="owner"/>
  </rdf:Description>

  <rdf:Description rdf:nodeID="owner">
   <rdf:type rdf:resource="http://example.com/schema#Person"/>
   <ex:name>Fred</ex:name>
  </rdf:Description>
</rdf:RDF>

RDF/XML Example

Class names can be used explicitly as xml elements.

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

  <rdf:Description rdf:about="http://example.com/house">
   <ex:title>a house</ex:title>
   <ex:owner rdf:nodeID="owner"/>
  </rdf:Description>

  <ex:Person rdf:nodeID="owner">
   <ex:name>Fred</ex:name>
  </ex:Person>
</rdf:RDF>

RDF/XML Example

Without blank node labels:

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

  <rdf:Description rdf:about="http://example.com/house">
   <ex:title>a house</ex:title>
   <ex:owner>
     <ex:Person>
       <ex:name>Fred</ex:name>
     </ex:Person>
   </ex:owner>
  </rdf:Description>
</rdf:RDF>

Striping

• when reading RDF/XML all children of rdf:RDF element are nodes
• all children of nodes are properties
• all children of properties are nodes

• <rdf:RDF 
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:ex="http://example.com/schema#" >
  
    <NODE rdf:about="http://example.com/house">
     <PROPERTY>
       <NODE>
         <PROPERTY>Fred</PROPERTY>
       </NODE>
     </PROPERTY>
    </NODE>
  </rdf:RDF>

Datatypes and Languages

languages use xml:lang, datatypes use rdf:datatype

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

  <rdf:Description rdf:about="http://example.com/house">
   <ex:title xml:lang="en">a house</ex:title>
   <ex:owner>
     <ex:Person>
       <ex:name
        rdf:datatype="http://www.w3.org/2000/10/XMLSchema#string">Fred</ex:name>
     </ex:Person>
   </ex:owner>
  </rdf:Description>
</rdf:RDF>

Complications

There are (too) many ways to write a single graph as RDF/XML - literals as attributes is one variation

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

  <rdf:Description rdf:about="http://example.com/house" ex:title="a house">
   <ex:owner>
     <ex:Person ex:name="Fred" />
   </ex:owner>
  </rdf:Description>
</rdf:RDF>

Searching

• Basically a classification task
• Determine which things belong in which classes
• Define a class with the characteristics you are seeking and ask which resources are members
• Find all Talis staff: define a class consisting of all things with a workplace homepage of http://www.talis.com/

Simple Inferencing

• OWL enables simple inferencing
• Drawing conclusions based on the restrictions and descriptions

OWL Inferencing 1

First of all a robbery takes place. The robber drops his gun while fleeing. A report is filed by the investigating officers:

<RobberyEvent>
  <date>14th June 2005</date>
  <description>Armed robbery at Kwik-e-Mart</description>
  <evidence>
    <Gun>
      <serial>983GTE-H5TF</serial>
    </Gun>
  </evidence>
  <robber>
    <Person /> <!-- an unknown person -->
  </robber>
</RobberyEvent>

OWL Inferencing 2

Subsequently a car is pulled over for speeding. The traffic officer files a report electronically while issuing a ticket:

<SpeedingOffence>
  <date>26 October 2005</date>
  <description>Car observed driving at speed along M42</description>
  <speeder>
    <Person>
      <name>John Doe</name>
      <driversLicenseNumber>7431224667</driversLicenseNumber>
    </Person>
  </speeder>
</SpeedingOffence>

OWL Inferencing 3

At police HQ, the computer analyses each report as it is filed. The following OWL description tells the computer that a driversLicenseNumber is unique to a Person:

<owl:InverseFunctionalProperty rdf:ID="driversLicenseNumber">
  <rdfs:domain rdf:resource="Person" />
  <rdfs:range  rdf:resource="&rdf;Literal" />
</owl:FunctionalProperty>

OWL Inferencing 4

The computer uses this information to look up any other records it has about that person and finds a gun license:

<GunLicense>
  <registeredGun>
    <Gun>
      <serial>983GTE-H5TF</serial>
    </Gun>
  </registeredGun>
  <holder>
    <Person>
      <name>John Doe</name>
      <driversLicenseNumber>7431224667</driversLicenseNumber>
    </Person>
  </holder>
</GunLicense>

OWL Inferencing 5

The next OWL description tells the computer that the registeredGun property uniquely identifies a GunLicense. i.e. each gun is associated with only a single GunLicense

<owl:InverseFunctionalProperty rdf:ID="registeredGun">
  <rdfs:domain rdf:resource="GunLicense" />
  <rdfs:range  rdf:resource="Gun" />
</owl:FunctionalProperty>

OWL Inferencing 6

The computer now knows that the person stopped for speeding owns a gun. The next description tells the computer that each gun is uniquely identified by its serial.

<owl:InverseFunctionalProperty rdf:ID="serial">
  <rdfs:domain rdf:resource="Gun" />
  <rdfs:range  rdf:resource="&rdf;Literal" />
</owl:FunctionalProperty>

OWL Inferencing 7

The computer uses this to determine that the gun on the license is the same gun used in the robbery. This final description, seals the speeder's fate. It tells the computer that each GunLicense applies to only one gun and one person, so there is no doubt that the speeder is the person who owns the gun:

<owl:Class rdf:ID="GunLicense">
  <owl:intersectionOf rdf:parseType="Collection">
    <owl:Restriction>
      <owl:onProperty rdf:resource="#registeredGun"/>
      <owl:cardinality>1</owl:cardinality>
    </owl:Restriction>
    <owl:Restriction>
      <owl:onProperty rdf:resource="#holder"/>
      <owl:cardinality>1</owl:cardinality>
    </owl:Restriction>
  </owl:intersectionOf>
</owl:Class>

OWL Inferencing 8

The computer reports back to the traffic cop who duly arrests the speeder on suspicion of armed robbery.

The End!

• That's enough for now...
• 
• Find out more at: http://www.w3.org/RDF/
• And subscribe to http://www.planetrdf.com/