A Simple RDF Example

<rdf:Description rdf:about="http://www.ivan-herman.net">
    <foaf:name>Ivan</foaf:name>
    <abc:myCalendar rdf:resource="http://…/myCalendar"/>
    <foaf:surname>Herman</foaf:surname>
</rdf:Description>

Need for a Query Language

• Each data model needs its own “query language” to access large amount of data
  • relational databases have SQL, XML has XQuery…
• SPARQL is the query language for RDF
  • queries are expressed in forms of RDF triples with unknown variables
  • the query returns a list possible resources (i.e., URI-s or literal values) or full set of triples (depending on the query type)
• SPARQL is emerging as the primary way to access RDF data

How to Get to RDF Data?

• The simplest aproach: write your own RDF data in your preferred syntax
• Using URI-s in RDF binds you automatically to the real resources
• You may add RDF to XML directly (in its own namespace)
  • e.g., in SVG:

<svg ...>

  ...

  <metadata>

    <rdf:RDF xmlns:rdf="http://../rdf-syntax-ns#">

      ...

    </rdf:RDF>

  </metadata>

    ...

</svg>

• Works in some cases, but not satisfactory for a real deployement!

RDF is not Enough…

• Creating data and using it from a program works, provided the program knows what terms to use!
• We used terms like:
  • foaf:name, abc:myCalendar, foaf:surname, …
  • etc
• Are they all known? Are they all correct? (it is a bit like defining record types for a database)

Possible Issues to Handle

• What are the possible terms?
  • “is the set of data terms known to the program?”
• Are the properties used correctly?
  • “do they make sense for the resources?”
• Can a program reason about some terms? Eg:
  • “if «A» is left of «B» and «B» is left of «C», is «A» left of «C»?”
  • obviously true for humans, not obvious for a program …
  • … programs should be able to deduce such statements
• If somebody else defines a set of terms: are they the same?
  • clearly an issue in an international context

Ontologies

• The Semantic Web needs a support of ontologies:

“defines the concepts and relationships used to describe and represent an area of knowledge”

• We need a Web Ontologies Language to define:
  • the terminology used in a specific context
  • possible constraints on properties
  • the logical characteristics of properties
  • the equivalence of terms across ontologies
  • etc
• This is done by RDFS (RDF Schemas) and OWL (Web Ontology Language)

RDFS and OWL

• RDFS defines the basic principles
• OWL adds more complicated features to RDFS like:
  • constructions of classes using existing ones
  • characterize relationships (e.g., whether they are transitive, symmetric, functional, etc)

OWL: Additional Features

• Ontologies may be extremely a large:
  • their management requires special care
  • they may consist of several modules
  • come from different places and must be integrated
• Ontologies are on the Web. That means
  • applications may use several, different ontologies, or…
  • … same ontologies but in different languages
  • equivalence of, and relations among terms become an issue
• OWL includes possibilites for class/property equivalence, version and deprecation control, etc.

However: Ontologies are Hard!

• Hard to implement a full ontology management system
  • may be superfluous for some applications
• Hence the “onion” model of increasingly complex specs:
  • no property expressions or datatypes in RDF Schemas
  • not all set operators, restricted cardinality in OWL Lite
  • some restrictions, but a computational guarantee in OWL DL
  • full expressive power in OWL Full (but no computational guarantee)

I am sorry, you need to have an SVG enabled browser to see this slide...

Ontologies are Hard! (cont)

• “Lite” < “DL” < “Full”, but not completely true for RDFS
  • RDFS is “almost” a subcategory
  • not all RDFS statements are valid in DL…
  • …but they are for Full
• Applications may take what they really need!

The Work is Not Over

Rules

more general logical rules to the Semantic Web infrastructure; work has just begun at W3C

Evolution of the RDF model

e.g., add time information, probabilities, “measure of fuzziness” to statements (still in research phase)

Trust

a trust infrastructure for SW (for example: “can I trust the author of this set of assertions?”); on the future stack of W3C…

…

Lots of Tools

• (Graphical) Editors
  • IsaViz (Xerox Research/W3C), RDFAuthor (Univ. of Bristol), Protege 2000 (Stanford Univ.), SWOOP (Univ. of Maryland), Orient (IBM)
• Programming Environments
  • Jena (for Java, includes OWL reasoning and SPARQL queries), RDFLib (for Python), Redland (in C, with interfaces to Tcl, Java, PHP, Perl, Python, … and with SPARQL queries), SWI-Prolog, IBM’s Semantic Toolkit, …
• Databases (either based on an internal sql engine or fully triple based)
  • Kowari, Gateway, Sesame, 3Store, Jena’s Joseki, Oracle Database 10g, …
• RDF and OWL validators
  • W3C’s RDF Validator, BBN OWL Validator, Pellet OWL Reasoner, …
• RDB→RDF layers, converters
  • D2R Server, SquirrelRDF, SPASQL, R₂O, …

Further Information

These slides are at:

http://www.w3.org/People/Ivan/CorePresentations/SemanticWeb/

Semantic Web homepage

http://www.w3.org/2001/sw/

More information about W3C:

http://www.w3.org/Consortium/

Contact information:

http://www.w3.org//Consortium/Contact

Mail me:

ivan@w3.org