Tools & Frameworksfor the Semantic Web

Semantic Web - Fall 2005

Computer Engineering Department

Sharif University of Technology

Outline Jena

A Semantic Web framework Sesame

An architecture for storing and querying RDF data.

Protégé An environment for creating and editing

ontologies and knowledge bases.

Jena

Introduction Jena is a Java framework for building

Semantic Web applications. Jena is open source software developed in

HP Labs. The Jena framework includes:

A RDF API Reading and writing RDF in RDF/XML, N3 and N-

Triples An OWL API In-memory and persistent storage RDQL support

Jena Versions Two versions:

Jena 1 Expressive support for RDF Limited reasoning facilities (RDQL)

Jena 2 Ontology API included Support for OWL included

RDF Model

Resource: Anything that can be described with an RDF

expression. Property:

Trait, attribute or relation used to describe a resource.

Literal: Simple data type (String, Integer, etc).

Statement: Resource, united with the property and its associated

value. An RDF Model is a set of statements.

RDF API of Jena

Allows creating and manipulating RDF Models from Java applications.

Provides Java classes to represent: Models. Resources. Properties. Literals. Statements.

Example: vcards

Create an RDF ModelString personURI = "http://somewhere/JohnSmith";

String givenName = "John";

String familyName = "Smith";

String fullName = givenName + " " + familyName;

// create an empty model

Model model = ModelFactory.createDefaultModel();

Resource johnSmith = model.createResource(personURI);

johnSmith.addProperty(VCARD.FN, fullName);

johnSmith.addProperty(VCARD.N, model.createResource()

.addProperty(VCARD.Given, givenName)

.addProperty(VCARD.Family, familyName));

Writing and Reading the Model

To serialize the model in XML:

model.write(System.out);

To load a model in the memory:

Model model = ModelFactory.createDefaultModel();

model.read(“file:c:/example.owl”);

Navigating the Model Getting information via the URI of the

resource:

// retrieve the resource John SmithString johnSmithURI = "http://somewhere/JohnSmith";Resource jSmith = model.getResource(johnSmithURI);

// retrieve the value of the property NResource name = (Resource) jSmith.getProperty(VCARD.N) .getObject();

// retrieve the value of the property FNString fullName = (String) jSmith.getProperty(VCARD.FN) .getObject();

Referring to a Model Searching information in a model:

// retrieve all the resources of the type vcard // (assuming that all such resources have a property FN)ResIterator it = model.listSubjectsWithProperty(VCARD.FN);while (it.hasNext()) { Resource r = it.nextResource(); System.out.println(r);}

More advanced querying: Use of construction listStatements(Selector s). Use of RDQL.

Operations on Models A model is a set of statements. Support of the following operations:

Union. Intersection. Difference.

// reading the RDF models

model1.read(new InputStreamReader(in1), "");

model2.read(new InputStreamReader(in2), "");

// unifying RDF models

Model model = model1.union(model2);

Ontology API of Jena Supports RDF Schema, DAML, DAML+OIL

and OWL. Language independent.

Example: Camera Ontology

Creation of an Ontology Model Use of method createOntologyModel(). Possible to specify:

Used language. Associated reasoning.

String fileName = "c:/ejemplo.owl";

String baseURI = "file:///" + fileName;

OntModel model =

ModelFactory.createOntologyModel(ProfileRegistry.OWL_DL_LANG);

model.read(new FileReader(schemaFileName), baseURI);

Classes Classes are basic construction blocks. Represented as OntClass.

Example: Obtain subclasses of class Camera.

OntClass camera = model.getOntClass(camNS + "Camera");

for (Iterator i = camera.listSubClasses(); i.hasNext();) {

OntClass c = (OntClass) i.next();

System.out.println(c.getLocalName());

}

Properties Represented via OntProperty.

OntModel m = ModelFactory.createOntologyModel();

OntClass Camera = m.createClass(camNS + "Camera");

OntClass Body = m.createClass(camNS + "Body");

ObjectProperty part = m.createObjectProperty(camNS + "part");

ObjectProperty body = m.createObjectProperty(camNS + "body");

body.addSuperProperty(part);

body.addDomain(Camera);

body.addRange(Body);

Complex Classes It is possible to define classes by means of

operations for union, intersection, difference.

Example:<owl:Class rdf:ID="SLR"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#Camera"/> <owl:Restriction> <owl:onProperty rdf:resource="#viewFinder"/> <owl:hasValue rdf:resource="#ThroughTheLens"/> </owl:Restriction> </owl:intersectionOf></owl:Class>

// create instance throughTheLensOntClass Window = m.createClass(camNS + "Window");Individual throughTheLens =

m.createIndividual(camNS + "ThroughTheLens", Window);

// create property viewfinderObjectProperty viewfinder =

m.createObjectProperty(camNS + "viewfinder");

// create restriction hasValueHasValueRestriction viewThroughLens =

m.createHasValueRestriction(null, viewfinder, throughTheLens);

// create class CameraOntClass Camera = m.createClass(camNS + "Camera");

// create intersection for defining class SLRIntersectionClass SLR = m.createIntersectionClass(camNS + "SLR", m.createList(new RDFNode[] {viewThroughLens, Camera}));

Schema vs Instance Data Schema

Possible to define: Classes Properties (DataTypeProperty, ObjectProperty) Restrictions

Types of Data Cardinality

Instance Data Defining instances (individuals) of the Schema

elements.

<owl:Class rdf:ID="Camera"> <rdfs:subClassOf rdf:resource="#Item"/> </owl:Class><owl:DatatypeProperty rdf:ID="name"> <rdfs:domain rdf:resource="#Camera"/> <rdfs:range rdf:resource=“xsd:string"/></owl:DatatypeProperty>

<camera:Camera rdf:ID="camera1"><camera:name>Kodak</

camera:name> </camera:Camera>

Managing Instance Data

URI = http://test/camera/#CameraOntClass c = model.getOntClass(URI +#Camera")OntProperty p = model.getOntProperty(URI +#name")

Individual ind = model.getIndividual(URI +#camera1")if (ind.hasProperty(p))

Statement st = ind.getProperty(p);Object l = (Object)st.getObject();

Managing Instance Data Other operations:

model.listIndividuals() Returns all instances of the model

individual.hasProperty(Property p,Object o) Returns True if there is an individual having property p

with value o ontClass.listInstances();

Returns all instances of the class

Jena Inference Support Inference Deduce additional information

The task of inferencing is carried out by reasoners

Jena comprises a set of basic reasoners OWL Reasoner DAML Reasoner RDF Rule Reasoner Generic Rule Reasoner

There is a way to include new reasoners For example:

(?A rdfs:subClassOf ?B) (?B rdfs:subClassOf ?C)

(?A rdfs:subClassOf ?C)

Jena Inference Support

To reason, an Inference Model should be created

Example:Reasoner reasoner = ReasonerRegistry.getOWLReasoner();reasoner = reasoner.bindSchema(schema);InfModel modelInf = ModelFactory.createInfModel(reasoner,data);

Ontology Validation in JenaModel schema = ModelLoader.loadModel("file:c:/Schema.owl");Model data = ModelLoader.loadModel("file:c:/example.owl");Reasoner reasoner = ReasonerRegistry.getOWLReasoner();reasoner = reasoner.bindSchema(schema);InfModel modelInf = ModelFactory.createInfModel(reasoner, data);

ValidityReport vrp1 = modelInf.validate();if (vrp1.isValid()){

System.out.println(“Valid OWL");}else {

System.out.println(“Not valid OWL");for (Iterator i = vrp1.getReports(); i.hasNext();){

System.out.println(" - " + i.next()); }

<camera:Camera rdf:ID="camera1"><camera:name>KODAK</camera:name>

</camera:Camera><owl:DatatypeProperty rdf:ID="name"> <rdfs:domain rdf:resource="#Camera"/>

<rdfs:range rdf:resource=“xsd:integer"/></owl:DatatypeProperty>

Error (range check): Incorrectly typed literal due to range (prop, value)

Culprit = http://www.xfront.com/owl/ontologies/camera/#camera1

Implicated node: http://www.xfront.com/owl/ontologies/camera/#name

Implicated node: 'KODAK‘

<owl:Class rdf:ID="Camera"><rdfs:subClassOf> <owl:Restriction>

<owl:onProperty rdf:resource="#name" /> <owl:maxCardinality rdf:datatype=“xsd:nonNegativeInteger">1</owl:maxCardinality>

</owl:Restriction> </rdfs:subClassOf></owl:Class><camera:Camera rdf:ID="camera1">

<camera:name>KODAK</camera:name><camera:name>OLIMPUS</camera:name>

</camera:Camera>

Error (too many values): Too many values on max-N property (prop, class)Culprit = http://www.xfront.com/owl/ontologies/camera/#camera1Implicated node: http://www.xfront.com/owl/ontologies/camera/#nameImplicated node: http://www.xfront.com/owl/ontologies/camera/#Camera

RDQL q1 contains a query:

SELECT ?x

WHERE (?x <http://www.w3.org/2001/vcard-rdf/3.0#FN> "John Smith")

For executing q1 with a model m1.rdf:

java jena.rdfquery --data m1.rdf --query q1

The outcome is:

x

=============================

<http://somewhere/JohnSmith/>

Using RDQL from Java Code It is possible to run RDQL queries from the

Java application. The following classes are to be used for

this: Query QueryExecution QueryEngine QueryResults ResultBinding

RDQL ExampleSELECT ?x, ?fname

WHERE (?x <http://www.w3.org/2001/vcard-rdf/3.0#FN> ?fname)

Query query = new Query("SELECT...") ;

query.setSource(model);

QueryExecution qe = new QueryEngine(query) ;

QueryResults results = qe.exec();

for (Iterator iter = results; iter.hasNext();)

{

ResultBinding res = (ResultBinding) iter.next();

Resource x = (Resource) res.get("x");

Literal fname = (Literal) res.get("fname");

System.out.println("x: " + x + " fname: " + fname);

}

Persistent Models Jena permits to create persistent models:

such as with relational databases. Jena 2 supports:

MySQL Oracle PostgreSQL

To create a persistent model: ModelFactory.createModelRDBMaker(conn).createModel()

Example// Create a connection to DB

DBConnection c = new DBConnection(DB_URL, DB_USER, DB_PASS, DB_TYPE);

// Create a ModelMaker for persistent models

ModelMaker maker = ModelFactory.createModelRDBMaker(c);

// Create a new model

Model model = maker.createModel("modelo_1");

// Start transaction

model.begin();

// Read a model from an XML archive

model.read(in, null);

// Commit a transaction

model.commit();

Sesame

When they were out of sight Ali Baba came down, and, going up to the rock, said, "Open, Sesame.“

--Tales of 1001 Nights

Querying Levels RDF documents can be considered at three

different levels of abstraction:1. At the syntactic level they are XML documents.2. At the structure level they consist of a set of triples.3. At the semantic level they constitute one or more

graphs with partially predefined semantics.

Querying at what level is the best?

Querying at the Syntactic Level In this level we just have an XML document. So we can Query RDF using an XML query

language. (e.g. XQuery) But RDF is not just an XML dialect.

XML: Has a tree structure data model. Only nodes are labeled.

RDF: Has a graph structure data model. Both edges (properties) and nodes (subjects/objects) are

labeled. Different ways of encoding the same information

in XML are possible.

Querying at the Structure Level In this level RDF document represents a

set of triples: (type, Book, Class) (subClassOf, FamousWriter, Writer) (hasWritten, twain/mark, ISBN00023423442) (type, twain/mark, FamousWriter)

Advantage: Independent of the specific XML syntax.

A successful query: SELECT ?x FROM … WHERE (type ?x FamousWriter)

An unsuccessful query: SELECT ?x FROM … WHERE (type ?x Writer)

Querying at the Semantic Level We need a query language that is sensitive to the

RDF Schema primitives: e.g. Class, subClassOf, Property, …

RQL RDF Query Language The first proposal for a declarative query language for

RDF and RDF Schema. Output of queries is again legal RDF schema code, which

can be used as input of another query. A sample query:

SELECT Y FROM FamousWriter {X}. hasWritten {Y}

Sesame – Introduction & History Sesame: An Architecture for Storing and

Querying RDF Data and Schema Information. The European On-To-Knowledge project kicked

off in Feb. 2000: This project aims at developing ontology-driven

knowledge management tools. In this project Sesame fulfills the role of storage and

retrieval middleware for ontologies and metadata expressed in RDF and RDF Schema.

On-To-Knowledge Project Sesame is positioned as a central tool in this project. OntoExtract: extracts ontological conceptual structures

from natural-language documents. OntoEdit: An ontology editor. RDF Ferret: A user front-end, that provides search and

query.

RDF Ferret

OntoExtract

Sesame OntoEdit

What is Sesame? Sesame is an open source Java framework for

storing, querying and reasoning with RDF and RDF Schema.

It can be used as: Standalone Server: A database for RDF and RDF

Schema. Java Library: For applications that need to work with

RDF internally.

Sesame’s Architecture

Repository

Repository Abstraction Layer (RAL)

Admin Module Export ModuleQuery Module

HTTP Protocol Handler SOAP Protocol Handler

Sesa

me

SO

AP

HTTP

The Repository DBMSs

Currently, Sesame is able to use PostgreSQL MySQL Oracle (9i or newer) SQL Server

Existing RDF stores RDF flat files RDF network services

Using multiple sesame server to retrieve results for queries.

This opens up the possibility of a highly distributed architecture for RDF(S) storing and querying.

Repository Abstraction Layer (RAL) RAL offers stable, high-level interface for talking

to repositories. It is defined by an API that offers these

functionalities: Add data Retrieve data Delete data

Data is returned in streams. (Scalability) Only small amount of data is kept in memory. Suitable for use in highly constrained environments such

as portable devices. Caching data (Performance)

E.g. caching RDF schema data which is needed very frequently.

Stacking Abstraction Layers

Admin Module Allows incrementally inserting or deleting RDF data in/from

repository. Retrieves its information form an RDF(S) source Parses it using an RDF parser Checks each (S, P, O) statement it gets from the parser for

consistency with the information already present in the repository and infers implied information if necessary for instance: If P equals type, it infers that O must be a class. If P equals subClassOf, it infers that S and O must be classes. If P equals subPropertyOf, then it infers that both S and O

must be properties. If P equals domain or range, then it infers that S must be a

property and O must be a class.

Query Module Evaluates RQL queries posed by the user It is independent of the underlying repository. So

it can not use optimizations and query evaluations offered by specific DBMSs.

RQL queries are translated into a set of calls to the RAL. e.g. when a query contains a join operation over two

subqueries, each of the subqueries is evaluated, and the join operation is then executed by the query engine on the results.

RDF Export Module This module allows for the extraction of the

complete schema and/or data from a model in RDF format.

It supplies the basis for using Sesame with other RDF tools.

Important Features of Sesame Powerful query language Portability

It is written completely in Java. Repository independence Extensibility

Other functional modules can be created and be plugged in it.

Flexible communication by using protocol handlers The architecture separates the communication details

from the actual functionality through the use of protocol handlers.

SeRQL (Sesame RDF Query Language) It combined the best features of other

query languages: RQL, RDQL, N-Triples, N3 Some of the built-in predicates:

{X} serql:directSubClassOf {Y} {X} serql:directSubPropertyOf {Y} {X} serql:directType {Y}

Using PostgreSQL as Repository PostgreSQL is an open-source object-relational

DBMS. It supports subtable relations between its tables. Subtable relations are also transitive. These relations can be used to model the

subsumption reasoning of RDF schema.

Example RDF Schema & Data

Writer

FamousWriter

…/ISBN00023423442…/twain/mark

BookhasWritten

Schema

type

hasWritten

type

subClassOf

rangedomain

Data

Storing Schema (in an RDBMS)

uri

ResourceWriterFamousWriterBook

uri

hasWritten

source target

WriterFamousWriterBook

ResourceWriterResource

source target

hasWritten Writer

source target

hasWritten Book

source target

Class SubClassOf SubPropertyOf

Property Domain Range

uri

uri uri

…/ISBN00023423442

uri

…/twain/mark source target

…/twain/mark …/ISBN00023423442

FamousWriter

WriterBook

Resource

hasWritten

Storing Data (PostgreSQL)

In order to decrease the database size another table, called resources, is added to database which maps resource descriptions to unique IDs.

There are many ambiguities in RDFS: RDF Schema is defined in natural language. No formal description of its semantic is given. E.g. about subClassOf it only says that it is a property with

class as its domain and range. RDF Schema is self-describing:

The definition of its terms is itself done in RDF schema. As a result it consists some inconsistencies. Circular dependencies in terms definitions:

Class is both a subclass of and an instance of Resource. Resource is an instance of Class.

RDF Schema Ambiguities

Scalability Issues An experiment using Sesame:

Uploading and querying a collection of nouns from Wordnet (http://www.semanticweb.org/library)

Consisting of about 400,000 RDF statements. Using a desktop computer (Sun UltraSPARC 5

workstation, 256MB RAM) Uploading the Wordnet nouns took 94 minutes. Querying was quite slow.

Because data is distributed over multiple tables, and retrieving data needs doing many joins on tables.

Protégé

Protégé - Introduction Protégé is an extensible, platform-

independent environment for creating and editing ontologies and knowledge bases.

Current version is 3.1.1 but the tutorial in the next slides is based on version 2.1.1

Tutorial Scenario Semantic Web for Tourism/Traveling Goal: Find matching holiday destinations

for a customer

I am looking for a comfortable destination

with beach access

Tourism Web

Tourism Semantic Web

OWLMetadata

(Individuals)

OWLMetadata

(Individuals)

OWLMetadata

(Individuals)

OWLMetadata

(Individuals)

Tourism Ontology

Web Services

Destination

AccomodationActivity

OWL (in Protégé)

Individuals (e.g., “FourSeasons”) Properties

ObjectProperties (references) DatatypeProperties (simple values)

Classes (e.g., “Hotel”)

Individuals Represent objects in the domain Specific things Two names could represent the same

“real-world” individual

SydneysOlympicBeachBondiBeach

Sydney

ObjectProperties Link two individuals together Relationships (0..n, n..m)

Sydney

BondiBeachhasPart

FourSeasonshasAccomodation

Inverse Properties Represent bidirectional relationships Adding a value to one property also adds a

value to the inverse property

Sydney

BondiBeachhasPart

isPartOf

Transitive Properties If A is related to B and B is related to C

then A is also related to C Often used for part-of relationships

Sydney

BondiBeach

hasPart

NewSouthWales

hasPart

hasPart (derived)

DatatypeProperties Link individuals to primitive values

(integers, floats, strings, booleans etc) Often: AnnotationProperties without formal

“meaning”

Sydney

hasSize = 4,500,000isCapital = truerdfs:comment = “Don’t miss the opera house”

Classes Sets of individuals with common

characteristics Individuals are instances of at least one

class

City

Sydney

Beach

Cairns

BondiBeach

CurrawongBeach

Range and Domain Property characteristics

Domain: “left side of relation” (Destination) Range: “right side” (Accomodation)

Sydney

BestWestern

FourSeasonshasAccomodation

DestinationAccomodation

hasAccomodation

Domains Individuals can only take values of

properties that have matching domain “Only Destinations can have Accomodations”

Domain can contain multiple classes Domain can be undefined:

Property can be used everywhere

Superclass Relationships Classes can be organized in a hierarchy Direct instances of subclass are also

(indirect) instances of superclasses

Cairns

Sydney

Canberra

Coonabarabran

Class Relationships Classes can overlap arbitrarily

City

Sydney

CairnsBondiBeach

RetireeDestination

Class Disjointness All classes could potentially overlap In many cases we want to make sure they

don’t share instances

Sydney

UrbanArea RuralArea

SydneyWoomera

CapeYork

disjointWith

City Destination

Creating a new OWL project

Creating simple classes

Creating class hierarchy and set disjoints

Creating Contact class with datatype properties

Editing details of datatype properties

Createing an object property hasContact

Creating an object property with inverse

Creating the remaining classes and properties

Class Descriptions Classes can be described by their logical

characteristics Descriptions are “anonymous classes”

Things with three star accomodation

Things with sightseeing opportunities

RetireeDestination

SydneySanJose

BlueMountains

Class Descriptions Define the “meaning” of classes Anonymous class expressions are used

“All national parks have campgrounds.” “A backpackers destination is a destination

that has budget accomodation and offers sports or adventure activities.”

Expressions mostly restrict property values (OWL Restrictions)

Class Descriptions: Why? Based on OWL’s Description Logic support Formalize intentions and modeling

decisions (comparable to test cases) Make sure that individuals fulfill conditions Tool-supported reasoning

Reasoning with Classes Tool support for three types of reasoning

exists: Consistency checking:

Can a class have any instances? Classification:

Is A a subclass of B? Instance classification:

Which classes does an individual belong to? For Protégé we recommend RACER.

Restrictions (Overview) Define a condition for property values

allValuesFrom someValuesFrom hasValue minCardinality maxCardinality cardinality

An anonymous class consisting of all individuals that fulfill the condition

Cardinality Restrictions Meaning: The property must have at least/at

most/exactly x values is the shortcut for and

Example: A FamilyDestination is a Destination that has at least one Accomodation and at least 2 Activities

allValuesFrom Restrictions Meaning: All values of the property must be

of a certain type Warning: Also individuals with no values

fulfill this condition (trivial satisfaction) Example: Hiking is a Sport that is only

possible in NationalParks

someValuesFrom Restrictions Meaning: At least one value of the property must be

of a certain type Others may exist as well Example: A NationalPark is a RuralArea that has at

least one Campground and offers at least one Hiking opportunity

hasValue Restrictions Meaning: At least one of the values of the property

is a certain value Similar to someValuesFrom but with Individuals

and primitive values. Example: A PartOfSydney is a Destination where

one of the values of the isPartOf property is Sydney

Enumerated Classes Consist of exactly the listed individuals

OneStarRating

TwoStarRatingThreeStarRating

BudgetAccomodation

Logical Class Definitions Define classes out of other classes

unionOf (or) intersectionOf (and)

complementOf (not)

Allow arbitrary nesting of class descriptions (A and (B or C) and not D)

unionOf The class of individuals that belong to class A

or class B (or both) Example: Adventure or Sports activities

Adventure Sports

intersectionOf The class of individuals that belong to both

class A and class B Example: A BudgetHotelDestination is a

destination with accomodation that is a budget accomodation and a hotel

BudgetAccomodation

Hotel

Implicit intersectionOf When a class is defined by more than one class

description, then it consists of the intersection of the descriptions

Example: A luxury hotel is a hotel that is also an accomodation with 3 stars

AccomodationWith3StarsHotel

LuxuryHotel

complementOf The class of all individuals that do not belong to a

certain class Example: A quiet destination is a destination that

is not a family destination

DestinationFamilyDestination

QuietDestination (grayed)

Class Conditions Necessary Conditions:

(Primitive / partial classes)“If we know that something is a X,then it must fulfill the conditions...”

Necessary & Sufficient Conditions:(Defined / complete classes)“If something fulfills the conditions...,then it is an X.”

Class Conditions (2)

QuietDestination

NationalPark

(not everything that fulfills these conditions is a NationalPark)

(everything that fulfills these conditions is a QuietDestination)

ClassificationNationalPark

BackpackersDestination

A RuralArea is a Destination

A Campground is BudgetAccomodation

Hiking is a Sport Therefore:

Every NationalPark is a Backpackers-Destiantion

Classification (2) Input: Asserted class definitions Output: Inferred subclass relationships

Creating an enumerated class out of individuals

Creating a hasValue restriction

Creating a hasValue restriction

Creating a defined class

Classifying Campground

Adding restrictions to City and Capital

Creating defined class BackpackersDestination

Creating defined class FamilyDestination

Creating defined class QuietDestination

Creating defined class RetireeDestination

Classification

Consistency Checking

Visualization with OWLViz

OWL Wizards

Ontology Import Adds all classes, properties and individuals

from an external OWL ontology into your project

Allows to create individuals, subclasses, or to further restrict imported classes

Can be used to instantiate an ontology for the Semantic Web

Tourism Semantic Web (2)

OWLMetadata

(Individuals)Tourism Ontology

Web Services

Destination

AccomodationActivity

Ontology Import with Protégé On the Metadata tab:

Add namespace, define prefix Check “Imported” and reload your project

Individuals

Individuals

Generated OWL File<?xml version="1.0"?>\<rdf:RDF xmlns="http://protege.stanford.edu/plugins/owl/owl-library/heli-bunjee.owl#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:travel="http://protege.stanford.edu/plugins/owl/owl-library/travel.owl#" xml:base="http://protege.stanford.edu/plugins/owl/owl-library/heli-bunjee.owl">

<owl:Ontology rdf:about=""> <owl:imports rdf:resource="http://protege.stanford.edu/plugins/owl/owl-library/travel.owl"/> </owl:Ontology>

<owl:Class rdf:ID="HeliBunjeeJumping"> <rdfs:subClassOf rdf:resource="http://protege.stanford.edu/plugins/owl/owl-library/travel.owl#BunjeeJumping"/> </owl:Class>

<HeliBunjeeJumping rdf:ID="ManicSuperBunjee"> <travel:isPossibleIn> <rdf:Description rdf:about="http://protege.stanford.edu/plugins/owl/owl-library/travel.owl#Sydney"> <travel:hasActivity rdf:resource="#ManicSuperBunjee"/> </rdf:Description> </travel:isPossibleIn> <travel:hasContact> <travel:Contact rdf:ID="MSBInc"> <travel:hasEmail rdf:datatype="http://www.w3.org/2001/XMLSchema#string">msb@manicsuperbunjee.com </travel:hasEmail> <travel:hasCity rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Sydney</travel:hasCity> <travel:hasStreet rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Queen Victoria St</travel:hasStreet> <travel:hasZipCode rdf:datatype="http://www.w3.org/2001/XMLSchema#int">1240</travel:hasZipCode> </travel:Contact> </travel:hasContact> <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Manic super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed.</rdfs:comment> </HeliBunjeeJumping>

</rdf:RDF>

Lots of other tools RDFStore

RDF framework for Perl Raptor

RDF parser library Kowari, Gateway

triple based database systems RAP

RDF framework for PHP Validators

For RDF W3C RDF

For OWL WonderWeb Pellet

References Sesame

User Guide for Sesame http://www.openrdf.org/doc/sesame/users/us

erguide.html Broekstra J., Sesame: A Generic Architecture for

Storing and Querying RDF and RDF Schema, ISWC’02 http://sesame.aidministrator.nl http://www.openRDF.org

Protégé http://protege.stanford.edu/ http://www.co-ode.org

References Jena

Official site of Jena 2 http://jena.sourceforge.net/

Jena 2 Ontology API http://jena.sourceforge.net/ontology/

An Introduction to RDF and the Jena RDF API http://jena.sourceforge.net/tutorial/RDF_API/

A Programmer's Introduction to RDQL http://jena.sourceforge.net/tutorial/RDQL/

Jena 2 Database Interface http://jena.sourceforge.net/DB/

Jena 2 Inference support http://jena.sourceforge.net/inference/

Other tools http://www.daml.org/tools/

The End