1. OWL

2. What is OWL? W3C Recommendation, February 2004. Web Ontology Language
web standard
Web Ontology Language
built on top of RDF
for processing information on the web
designed to be interpreted by computers, not for being read by people
OWL is written in XML
OWL became a W3C (World Wide Web Consortium) Recommendation in February 2004.
A W3C Recommendation is understood by the industry and the web community as a web standard. A W3C Recommendation is a stable specification developed by a W3C Working Group and reviewed by the W3C Membership.
Q. What does the acronym "OWL" stand for?
A. Actually, OWL is not a real acronym. The language started out as the "Web Ontology Language" but the Working Group disliked the acronym "WOL." They decided to call it OWL. The Working Group became more comfortable with this decision when one of the members pointed out the following justification for this decision from the noted ontologist A.A. Milne who, in his influential book "Winnie the Pooh" stated of the wise character OWL:
"He could spell his own name WOL, and he could spell Tuesday so that you knew it wasn't Wednesday...“
See for more:

3. Why OWL? OWL is a part of the "Semantic Web Vision" - a future where:
Web information has exact meaning
Web information can be processed by computers
Computers can integrate information from the web
OWL was designed to
provide a common way to process the content of web information (instead of displaying it).
be read by computer applications (instead of humans).

4. OWL is Different from RDF
OWL , RDF similar
but OWL
stronger language
greater machine interpretability
larger vocabulary
stronger syntax.
OWL and RDF are much of the same thing, but OWL is a stronger language with greater machine interpretability than RDF.
OWL comes with a larger vocabulary and stronger syntax than RDF.
Q. What does OWL add that RDF-schema doesn't?
A. Owl extends RDFS to allow for the expression of complex relationships between different RDFS classes and of more precise constraints on specific classes and properties. Example of these include: - the means to limit the properties of classes with respect to number and type, - the means to infer that items with various properties are members of a particular class - the means to determine if all members of a class will have a particular property, or if only some of them might - the means to distinguish one-to-one from many-to-one or one-to-many relationships, allowing the "foreign keys" of a database to be represented in an ontology - the means to express relationships between classes defined in different documents across the web, - the means to construct new classes out of the unions, intersections and complements of other classes, and - the means to constrain range and domain to specific class/property combinations.

5. What is an Ontology? formal specification of a certain domain
machine manipulable model
Ontology is about the exact description of things and their relationships and an inference mechanism for it.
For the web, ontology is about
the exact description of web information and
relationships between web information and
reasoning with it.
dictionary  taxonomy  ontology
Before we look at learning more about OWL, we need to do a few steps back and understand what this is all based on: ontologies, semantic web, Tim Berners-Lee’s ideas, etc.
Ontology is about the exact description of things and their relationships.
For the web, ontology is about the exact description of web information and relationships between web information and the inference mechanisms for it.
What an ontology is not:
a dictionary (there should be one, but the links are missing)
a taxonomy (this has the hierarchical links, but misses the reasoning)
So: dictionary  taxonomy  ontology
See also:
An ontology is an engineering artifact:
It is constituted by a specific vocabulary used to describe a certain reality, plus
a set of explicit assumptions regarding the intended meaning of the vocabulary.
Thus, an ontology describes a formal specification of a certain domain:
Shared understanding of a domain of interest
Formal and machine manipulable model of a domain of interest

6. OWL Sublanguages OWL has three sublanguages: OWL Lite
hierarchy + simple constraints + cardinality {0,1}
OWL DL (includes OWL Lite)
complete, decidable (part of FOL)
Type separations (class <> property <> individual)
OWL DL is the subset of OWL (Full) that is optimized for reasoning and knowledge modeling
OWL Full (includes OWL DL)
aug. meaning RDF..
OWL Lite supports those users primarily needing a classification hierarchy and simple constraint features. For example, while OWL Lite supports cardinality constraints, it only permits cardinality values of 0 or 1. It should be simpler to provide tool support for OWL Lite than its more expressive relatives, and provide a quick migration path for thesauri and other taxonomies.
OWL DL supports those users who want the maximum expressiveness without losing computational completeness (all entailments are guaranteed to be computed) and decidability (all computations will finish in finite time) of reasoning systems. OWL DL includes all OWL language constructs with restrictions such as type separation (a class can not also be an individual or property, a property can not also be an individual or class). OWL DL is so named due to its correspondence with description logics [Description Logics], a field of research that has studied a particular decidable fragment of first order logic. OWL DL was designed to support the existing Description Logic business segment and has desirable computational properties for reasoning systems.
OWL Full is meant for users who want maximum expressiveness and the syntactic freedom of RDF with no computational guarantees. For example, in OWL Full a class can be treated simultaneously as a collection of individuals and as an individual in its own right. Another significant difference from OWL DL is that a owl:DatatypeProperty can be marked as an owl:InverseFunctionalProperty. OWL Full allows an ontology to augment the meaning of the pre-defined (RDF or OWL) vocabulary. It is unlikely that any reasoning software will be able to support every feature of OWL Full.
See more at:

7. OWL is Written in XML
By using XML, OWL information can easily be exchanged between different types of computers using different types of operating system and application languages.
Install Protégé from:
A Protégé tutorial is at:
By using XML, OWL information can easily be exchanged between different types of computers using different types of operating system and application languages.

8. (more on) OWL Based on predecessors (DAML+OIL)
A Web Language: Based on RDF(S)
An Ontology Language: Based on logic

9. OWL Ontologies What’s inside an OWL ontology
Classes + class-hierarchy
Properties (Slots) / values
Relations between classes (inheritance, disjoints, equivalents)
Restrictions on properties (type, cardinality)
Characteristics of properties (transitive, …)
Annotations
Individuals
Reasoning tasks: classification, consistency checking

10. OWL Use Cases At least two different user groups
OWL used as data exchange language (define interfaces of services and agents)
OWL used for terminologies or knowledge models

11. OWL Example (Airport)
Example:
Find the error in the OWL Resource:
Validators are:
For RDF:
For OWL:
For a tutorial on XML, RDF, SPARQL, OWL see:
Semantic web search engine:
Validators are:
For RDF:
For OWL:
For a tutorial on XML, RDF, SPARQL, OWL see:

12. I am looking for a comfortable destination with beach access
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

13. Scenario Architecture
A search problem: Match customer’s expectations with potential destinations
Required: Web Service that exploits formal information about the available destinations
Accommodation (Hotels, Camping, ...)
Activities (Sightseeing, Sports, ...)

14. Tourism Semantic Web Open World:
New hotels are being added
New activities are offered
Providers publish their services dynamically
Standard format / grounding is needed → Tourism Ontology

15. Tourism Semantic Web Web Services Tourism Ontology Destination
OWL
Metadata
(Individuals)
OWL
Metadata
(Individuals)
Tourism Ontology
Destination
Activity
Accomodation
OWL
Metadata
(Individuals)
OWL
Metadata
(Individuals)
Web Services

16. OWL Individuals (e.g., “FourSeasons”) Properties
ObjectProperties (references)
DatatypeProperties (simple values)
Classes (e.g., “Hotel”)
The visualisation here is from the Protégé software. Protégé is a freeware ontology editor from Stanford:
‘Individuals’ is another word for instances of a class (or schema).
Validators are:
For RDF:
For OWL:

17. Individuals (Instances)
Represent objects in the domain
Specific things
Two names could represent the same “real-world” individual
Sydney
SydneysOlympicBeach
BondiBeach

18. Example of Individuals
<Region rdf:ID="CentralCoastRegion" />
equivalent to:
<owl:Thing rdf:ID="CentralCoastRegion" />
<owl:Thing rdf:about="#CentralCoastRegion"> <rdf:type rdf:resource="#Region"/>
</owl:Thing>
In addition to classes, we want to be able to describe their members. We normally think of these as individuals in our universe of things. An individual is minimally introduced by declaring it to be a member of a class.
The two definitions above are equivalent.
Please note: writing rdf:resource = “#Something” means that ‘Something’ has been defined before, e.g., as a class. Otherwise, we need to write complete URIs.
Here, Region is a pre-existing class in both examples.
* individual objects in a class:
<Person rdf:ID="Adam">
<rdfs:label>Adam</rdfs:label>
<rdfs:comment>Adam is a person.</rdfs:comment>
<age><xsd:integer rdf:value="13"/></age>
<shoesize><xsd:decimal rdf:value="9.5"/></shoesize>
</Person>
* Adam is a Person.
Please note: On the slide, we use rdf:ID to refer to the existance of the CentralCoastRegion resource, and then we use rdf:about to describe it. Sometimes, the rdf:ID definition is in a different document, that gets included in the one using the rdf:about definition. Read on for more explanations and examples on this.
The most basic concepts in a domain should correspond to classes that are the roots of various taxonomic trees. Every individual in the OWL world is a member of the class owl:Thing. Thus each user-defined class is implicitly a subclass of owl:Thing. Domain specific root classes are defined by simply declaring a named class. OWL also defines the empty class, owl:Nothing.
For example, we can create three root classes: Winery, Region, and ConsumableThing.
<owl:Class rdf:ID="Winery"/>
<owl:Class rdf:ID="Region"/>
<owl:Class rdf:ID="ConsumableThing"/>
Note that now we have only said that there exist classes that have been given these names, indicated by the 'rdf:ID=' syntax. Formally, we know almost nothing about these classes other than their existence, despite the use of familiar English terms as labels. And while the classes exist, they may have no members. For all we know at the moment, these classes might as well have been called Thing1, Thing2, and Thing3.
It is important to remember that definitions may be incremental and distributed. In particular, we will have more to say about Winery later.
The syntax rdf:ID="Region" is used to introduce a name, as part of its definition. This is the rdf:ID attribute ([RDF], ) that is like the familiar ID attribute defined by XML. Within this document, the Region class can now be referred to using #Region, e.g. rdf:resource="#Region". Other ontologies may reference this name using its complete form, "
Another form of reference uses the syntax rdf:about="#Region" to extend the definition of a resource. This use of the rdf:about="&ont;#x" syntax is a critical element in the creation of a distributed ontology. It permits the extension of the imported definition of x without modifying the original document and supports the incremental construction of a larger ontology.
It is now possible to refer to the classes we defined in other OWL constructs using their given identifier.

19. ObjectProperties Link two individuals together
Relationships (0..n, n..m)
BondiBeach
hasPart
Sydney
hasAccomodation
FourSeasons

20. Example Property
<owl:ObjectProperty rdf:ID=“hasPart"> <rdfs:domain rdf:resource="#Destination" /> <rdfs:range rdf:resource="#Beaches" />
</owl:ObjectProperty>
Another example below:
<owl:ObjectProperty rdf:ID="course">
<rdfs:domain rdf:resource="#Meal" />
<rdfs:range rdf:resource="#MealCourse" />
</owl:ObjectProperty>

21. Property Domain & Range
If a relation is: subject_individual  hasProperty  object_individual
The domain is the class of the subject individual
The range is the class of the object individual (or a datatype if hasProperty is a Datatype Property)
hasProperty
DomainClass
RangeClass
hasProperty
hasProperty

22. Properties, Range and Domain
Property characteristics
Domain: “left side of relation” (Destination)
Range: “right side” (Accomodation)
Accomodation
Destination
hasAccomodation
BestWestern
Sydney
* An OWL property connects two items.
* They are datatype properties
(owl:DatatypeProperty) if they are relations
between instances of classes and RDF literals and XML Schema
datatypes.
* object properties
(owl:ObjectProperty)if they are relations between
instances of two classes.
<owl:ObjectProperty rdf:ID="hasParent">
<rdfs:domain rdf:resource="#Animal"/>
<rdfs:range rdf:resource="#Animal"/>
</owl:ObjectProperty>
* An Animal can have a parent which must be an Animal.
<owl:ObjectProperty rdf:ID="hasFather">
<rdfs:subPropertyOf rdf:resource="#hasParent"/>
<rdfs:range rdf:resource="#Male"/>
* hasFather is a property that is a kind of hasParent property, i.e., x's father is
also x's parent.
FourSeasons
hasAccomodation

23. Domains
Individuals can only take values of properties that have matching domain
“Only Destinations can have Accommodations”
Domain can contain multiple classes
Domain can be undefined: Property can be used everywhere
More examples: Propery, Domain & Range
<owl:ObjectProperty rdf:ID="madeFromGrape">
<rdfs:domain rdf:resource="#Wine"/>
<rdfs:range rdf:resource="#WineGrape"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="course">
<rdfs:domain rdf:resource="#Meal" />
<rdfs:range rdf:resource="#MealCourse" />
In OWL, a sequence of elements without an explicit operator represents an implicit conjunction. The property madeFromGrape has a domain of Wine and a range of WineGrape. That is, it relates instances of the class Wine to instances of the class WineGrape. Multiple domains mean that the domain of the property is the intersection of the identified classes (and similarly for range).
Similarly, the property course ties a Meal to a MealCourse.
Note that the use of range and domain information in OWL is different from type information in a programming language. Among other things, types are used to check consistency in a programming language. In OWL, a range may be used to infer a type. For example, given:
<owl:Thing rdf:ID="LindemansBin65Chardonnay">
<madeFromGrape rdf:resource="#ChardonnayGrape" />
</owl:Thing>  
we can infer that LindemansBin65Chardonnay is a wine because the domain of madeFromGrape is Wine.

24. Property Restriction: Example Cardinality
<owl:Class rdf:ID="Wine">
<rdfs:subClassOf rdf:resource="&food;PotableLiquid"/> <rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#madeFromGrape"/>
<owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
</owl:Restriction>
</rdfs:subClassOf> ...
</owl:Class>
<owl:Restriction>
<owl:onProperty rdf:resource="#madeFromGrape"/>
<owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality>
</owl:Restriction>
We could expand the definition of Wine to include the notion that a wine is made from at least one WineGrape. As with property definitions, class definitions have multiple subparts that are implicitly conjoined.
The highlighted subclass restriction above
<owl:Restriction> <owl:onProperty rdf:resource="#madeFromGrape"/> <owl:minCardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:minCardinality> </owl:Restriction>
defines an unnamed class that represents the set of things with at least one madeFromGrape property. We call these anonymous classes. Including this restriction in the Wine class definition body states that things that are wines are also members of this anonymous class. That is, every individual wine must participate in at least one madeFromGrape relation.
&xsd stands for: XSD (XML Schema Definition) (thus the datatype nonNegativeInteger is defined by the XML Schema)
* We define a restricted class Person
<owl:Class rdf:ID="Person">
<rdfs:subClassOf rdf:resource="#Animal"/>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasParent"/>
<owl:toClass rdf:resource="#Person"/>
</owl:Restriction>
</rdfs:subClassOf>
* A Person is an Animal. The parent of a Person is also a Person.
<owl:Restriction owl:cardinality="1">
<owl:onProperty rdf:resource="#hasFather"/>
<owl:onProperty rdf:resource="#shoesize"/>
<owl:minCardinality>1</owl:minCardinality>
</owl:Class>
* Any person must have exactly 1 father and at least one shoe size.

25. OWL Extends Other Ontologies
extend existing ontology by saying things about terms in it:
<owl:Class rdf:about="#Animal">
<rdfs:comment>
Animals have exactly two parents, ie: If x is an animal, it has exactly 2 parents (but NOT anything that has 2 parents is an animal).
</rdfs:comment>
<rdfs:subClassOf>
<owl:Restriction owl:cardinality="2">
<owl:onProperty rdf:resource="#hasParent"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
If ontology is already published, you use the full URL.
<owl:Class rdf:about="
From:
* You can extend an existing ontology by simply saying things about the terms in it.
<owl:Class rdf:about="#Animal">
<rdfs:comment>
Animals have exactly two parents, ie:
If x is an animal, then it has exactly 2 parents
(but it is NOT the case that anything that has 2
parents is an animal).
</rdfs:comment>
<rdfs:subClassOf>
<owl:Restriction owl:cardinality="2">
<owl:onProperty rdf:resource="#hasParent"/>
</owl:Restriction>
</rdfs:subClassOf>
</owl:Class>
* If the ontology is already published, you would instead use the full URL.
<owl:Class
rdf:about="

26. Inverse Properties Represent bidirectional relationships
Adding a value to one property also adds a value to the inverse property (!)
BondiBeach
hasPart
Sydney
isPartOf

27. Inverse Property Example
<owl:ObjectProperty rdf:ID="hasPart">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID=“isPartOf"> <owl:inverseOf rdf:resource="#hasPart" />
Another example:
<owl:ObjectProperty rdf:ID="hasMaker">
<rdf:type rdf:resource="&owl;FunctionalProperty" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="producesWine"> <owl:inverseOf rdf:resource="#hasMaker" />

28. 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
NewSouthWales
hasPart
Sydney
hasPart
BondiBeach
hasPart (derived)

29. Transitive Property Example
<owl:ObjectProperty rdf:ID="locatedIn">
<rdf:type rdf:resource="&owl;TransitiveProperty" />
<rdfs:domain rdf:resource="&owl;Thing" />
<rdfs:range rdf:resource="#Region" />
</owl:ObjectProperty>
<Region rdf:ID="SantaCruzMountainsRegion">
<locatedIn rdf:resource="#CaliforniaRegion" />
</Region>
<Region rdf:ID="CaliforniaRegion">
<locatedIn rdf:resource="#USRegion" />
Because the SantaCruzMountainsRegion is locatedIn the CaliforniaRegion, then it must also be locatedIn the USRegion, since locatedIn is transitive.
&owl; shows the ontology where TransitiveProperty is defined.

30. Sub-properties Example
<owl:ObjectProperty rdf:ID="hasWineDescriptor"> <rdfs:domain rdf:resource="#Wine" />
<rdfs:range rdf:resource="#WineDescriptor" />
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="hasColor"> <rdfs:subPropertyOf rdf:resource="#hasWineDescriptor" />
<rdfs:range rdf:resource="#WineColor" /> ...
Properties, like classes, can be arranged in a hierarchy.
WineDescriptor properties relate wines to their color and components of their taste, including sweetness, body, and flavor. hasColor is a subproperty of the hasWineDescriptor property, with its range further restricted to WineColor. The rdfs:subPropertyOf relation in this case means that anything with a hasColor property with value X also has a hasWineDescriptor property with value X.

31. DatatypeProperties
Link individuals to primitive values (integers, floats, strings, Booleans etc)
Often: AnnotationProperties without formal “meaning”
Sydney
rdfs:comment is an annotation property; read on to find out more about them:
OWL Full does not put any constraints on annotations in an ontology. OWL DL allows annotations on classes, properties, individuals and ontology headers, but only under the following conditions:
The sets of object properties, datatype properties, annotation properties and ontology properties must be mutually disjoint. Thus, in OWL DL dc:creator cannot be at the same time a datatype property and an annotation property.
Annotation properties must have an explicit typing triple of the form: AnnotationPropertyID rdf:type owl:AnnotationProperty .
Annotation properties must not be used in property axioms. Thus, in OWL DL one cannot define subproperties or domain/range constraints for annotation properties.
The object of an annotation property must be either a data literal, a URI reference, or an individual.
Five annotation properties are predefined by OWL, namely:
owl:versionInfo
rdfs:label
rdfs:comment
rdfs:seeAlso
rdfs:isDefinedBy
Here is an example of legal use of an annotation property in OWL DL:
<owl:AnnotationProperty rdf:about="&dc;creator"/> <owl:Class rdf:about="#MusicalWork"> <rdfs:label>Musical work</rdfs:label> <dc:creator>N.N.</dc:creator> </owl:Class>
hasSize = 4,500,000
isCapital = true
rdfs:comment = “Don’t miss the opera house”

32. Classes Sets of individuals with common characteristics
Individuals are instances of at least one class
Beach
City
Sydney
BondiBeach
Cairns
CurrawongBeach

33. Examples of Classes in OWL
<owl:Class rdf:ID="Winery"/>
<owl:Class rdf:ID="Region"/>
<owl:Class rdf:ID="ConsumableThing"/>
It is important to remember that definitions may be incremental and distributed. In particular, we can have more to say about Winery later.
See:
* classes which are subsets that contain all objects of that type.
<?xml version='1.0' encoding='ISO '?>
<rdf:RDF
xmlns:owl ="
xmlns:rdf ="
xmlns:rdfs ="
xmlns:xsd ="
xmlns =""
>
<owl:Ontology rdf:about="">
<owl:versionInfo>$Id$</owl:versionInfo>
<rdfs:comment>
</rdfs:comment>
</owl:Ontology>
<owl:Class rdf:ID="Animal">
<rdfs:label>Animal</rdfs:label>
Not vegetable or mineral.
<owl:Class rdf:ID="Male">
<rdfs:label>Male</rdfs:label>
<rdfs:subClassOf rdf:resource="#Animal"/>
</owl:Class>
<owl:Class rdf:ID="Female">
<rdfs:label>Female</rdfs:label>
<rdfs:subClassOf rdf:resource="Animal"/>
<owl:disjointWith rdf:resource="Male"/>
</rdf:RDF>
* This is the definition of an Animal class, with a label of Animal and two subclasses: Male and Female.

34. Superclass Relationships
Classes can be organized in a hierarchy
Direct instances of subclass are also (indirect) instances of superclasses
Cairns
Sydney
Canberra
Coonabarabran

35. Example Subclasses <owl:Class rdf:ID="PotableLiquid">
<rdfs:subClassOf rdf:resource="#ConsumableThing" /> …
</owl:Class>
<owl:Class rdf:ID="Wine">
<rdfs:subClassOf rdf:resource="&food;PotableLiquid"/>
<rdfs:label xml:lang="en">wine</rdfs:label>
<rdfs:label xml:lang="fr">vin</rdfs:label> ...

36. Class Relationships Classes can overlap arbitrarily RetireeDestination
City
Cairns
BondiBeach
Sydney

37. Class Disjointness All classes could potentially overlap
In many cases we want to make sure they don’t share instances
disjointWith
UrbanArea
RuralArea
Woomera
Sydney
Sydney
CapeYork
City
Destination

38. Example disjoint
<owl:Class rdf:about="#Man"> <owl:disjointWith rdf:resource="#Woman"/>
</owl:Class>
only in OWL full !

39. Class versus Individual (Instance)
Levels of representation:
In certain contexts a class can be considered an instance of something else.
Grape, set of all grape varietals. CabernetSauvingonGrape is an instance of this class, but could be considered a class, the set of all actual Cabernet Sauvignon grapes.
Subclass vs. instance: easy to confuse instance-of relationship with subclass relationship!
CabernetSauvignonGrape as individual & instance of Grape, or subclass of Grape.
But: Grape class is the set of all grape varietals, any subclass should be a subset.
CabernetSauvignonGrape is an instance of Grape, It does not describe a subset of Grape varietals, it is a grape varietal.
Levels of representation: In certain contexts something that is obviously a class can itself be considered an instance of something else. For example, in the wine ontology we have the notion of a Grape, which is intended to denote the set of all grape varietals. CabernetSauvingonGrape is an example instance of this class, as it denotes the actual grape varietal called Cabernet Sauvignon. However, CabernetSauvignonGrape could itself be considered a class, the set of all actual Cabernet Sauvignon grapes.
Subclass vs. instance: It is very easy to confuse the instance-of relationship with the subclass relationship. For example, it may seem arbitrary to choose to make CabernetSauvignonGrape an individual that is an instance of Grape, as opposed to a subclass of Grape. This is not an arbitrary decision. The Grape class denotes the set of all grape varietals, and therefore any subclass of Grape should denote a subset of these varietals. Thus, CabernetSauvignonGrape should be considered an instance of Grape, and not a subclass. It does not describe a subset of Grape varietals, it is a grape varietal.

40. Class Descriptions
Classes can be described by their logical characteristics
Descriptions are “anonymous classes”
Things with three star accommodation
RetireeDestination
SanJose
Sydney
BlueMountains
Things with sightseeing opportunities

41. 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 accommodation 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

42. Reasoning with Classes
Tool support for 3 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é they recommend RACER.
See for some reasoning examples:

43. 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
See also:

44. 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

45. 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

46. Value constraints <owl:Restriction>
<owl:onProperty rdf:resource="#hasParent" /> <owl:allValuesFrom rdf:resource="#Human" />
</owl:Restriction>
This example describes an anonymous OWL class of all individuals for which the hasParent property only has values of class Human. Note that this class description does not state that the property always has values of this class; just that this is true for individuals that belong to the class extension of the anonymous restriction class.
NOTE: In OWL Lite the only type of class description allowed as object of owl:allValuesFrom is a class name.
An owl:allValuesFrom constraint is analogous to the universal (for-all) quantifier of Predicate logic - for each instance of the class that is being described, every value for P must fulfill the constraint. Also notice that the correspondence of owl:allValuesFrom with the universal quantifier means that an owl:allValuesFrom constraint for a property P is trivially satisfied for an individual that has no value for property P at all. To see why this is so, observe that the owl:allValuesFrom constraint demands that all values of P should be of type T, and if no such values exist, the constraint is trivially true.

47. 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

48. 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

49. Enumerated Classes Consist of exactly the listed individuals
OneStarRating
ThreeStarRating
TwoStarRating
BudgetAccomodation

50. Example Description: Enumeration
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<owl:Thing rdf:about="#Eurasia"/>
<owl:Thing rdf:about="#Africa"/>
<owl:Thing rdf:about="#NorthAmerica"/>
<owl:Thing rdf:about="#SouthAmerica"/>
<owl:Thing rdf:about="#Australia"/>
<owl:Thing rdf:about="#Antarctica"/> </owl:oneOf>
</owl:Class>
The RDF/XML syntax <owl:Thing rdf:about="..."/> refers to some individual (remember: all individuals are by definition instances of owl:Thing).
NOTE: Enumeration is not part of OWL Lite

51. 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)
>>> OWL DL
OWL provides additional constructors with which to form classes. These constructors can be used to create so-called class expressions. OWL supports the basic set operations, namely union, intersection and complement. These are named owl:unionOf, owl:intersectionOf, and owl:complementOf, respectively. Additionally, classes can be enumerated. Class extensions can be stated explicitly by means of the oneOf constructor.

52. unionOf
The class of individuals that belong to class A or class B (or both)
Example: Adventure or Sports activities
Adventure
Sports

53. 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

54. 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 accommodation with 3 stars
Hotel
AccomodationWith3Stars
LuxuryHotel

55. 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
QuietDestination (grayed)
Destination
FamilyDestination

56. 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.”

57. Class Conditions (2) NationalPark QuietDestination
(not everything that fulfills these conditions is a NationalPark)
QuietDestination
(everything that fulfills these conditions is a QuietDestination)

58. Classification NationalPark BackpackersDestination
A RuralArea is a Destination
A Campground is BudgetAccomodation
Hiking is a Sport
Therefore: Every NationalPark is a Backpackers-Destination
BackpackersDestination
(Other BackpackerDestinations)

59. Reasoning with Propery, Domain & Range
<owl:ObjectProperty rdf:ID="madeFromGrape">
<rdfs:domain rdf:resource="#Wine"/>
<rdfs:range rdf:resource="#WineGrape"/>
</owl:ObjectProperty>
<owl:Thing rdf:ID="LindemansBin65Chardonnay"> <madeFromGrape rdf:resource="#ChardonnayGrape" />
</owl:Thing>  
=> LindemansBin65Chardonnay is a wine
In OWL, a sequence of elements without an explicit operator represents an implicit conjunction. The property madeFromGrape has a domain of Wine and a range of WineGrape. That is, it relates instances of the class Wine to instances of the class WineGrape. Multiple domains mean that the domain of the property is the intersection of the identified classes (and similarly for range).
Similarly, the property course ties a Meal to a MealCourse.
Note that the use of range and domain information in OWL is different from type information in a programming language. Among other things, types are used to check consistency in a programming language. In OWL, a range may be used to infer a type. For example, given:
<owl:Thing rdf:ID="LindemansBin65Chardonnay"> <madeFromGrape rdf:resource="#ChardonnayGrape" /> </owl:Thing>  
we can infer that LindemansBin65Chardonnay is a wine because the domain of madeFromGrape is Wine.

60. Visualization with OWLViz
Download OWLViz from:

61. Putting it All Together
Ontology has been developed
Published on a dedicated web address
Ontology provides standard terminology
Other ontologies can extend it
Users can instantiate the ontology to provide instances
specific hotels
specific activities

62. 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

63. Tourism Semantic Web (2)
OWL
Metadata
(Individuals)
Tourism Ontology
Destination
Activity
Accommodation
Web Services

64. OWL File & import xmlns:travel="http://protege.stanford.edu/plugins/
<?xml version="1.0"?>
<rdf:RDF
xmlns:rdf="
xmlns:rdfs="
xmlns:owl="
xmlns:dc="
xmlns:travel="
owl/owl-library/travel.owl#"
xml:base=" library/heli-bunjee.owl">
[. . .]
</rdf:RDF>
Remember, validators are:
For RDF:
For OWL:
<?xml version="1.0"?>
<rdf:RDF
xmlns:rdf="
xmlns:rdfs="
xmlns:owl="
xmlns:dc="
xmlns:travel="
xml:base="
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="
</owl:Ontology>
<owl:Class rdf:ID="HeliBunjeeJumping">
<rdfs:subClassOf rdf:resource="
</owl:Class>
<HeliBunjeeJumping rdf:ID="ManicSuperBunjee">
<travel:isPossibleIn>
<rdf:Description rdf:about="
<travel:hasActivity rdf:resource="#ManicSuperBunjee"/>
</rdf:Description>
</travel:isPossibleIn>
<travel:hasContact>
<travel:Contact rdf:ID="MSBInc">
<travel:has </travel:has >
<travel:hasCity rdf:datatype="
<travel:hasStreet rdf:datatype=" Victoria St</travel:hasStreet>
<travel:hasZipCode rdf:datatype="
</travel:Contact>
</travel:hasContact>
<rdfs:comment rdf:datatype=" super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed.</rdfs:comment>
</HeliBunjeeJumping>
</rdf:RDF>

65. OWL File: [. . .] OWL body in RDF wrap
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="
plugins/owl/owl-library/travel.owl"/>
</owl:Ontology>
<owl:Class rdf:ID="HeliBunjeeJumping">
<rdfs:subClassOf rdf:resource="
edu/plugins/owl/owl-library/travel.owl#BunjeeJumping"/>
</owl:Class>
<HeliBunjeeJumping rdf:ID="ManicSuperBunjee">
[***]
</HeliBunjeeJumping>
<?xml version="1.0"?>
<rdf:RDF
xmlns="
xmlns:rdf="
xmlns:rdfs="
xmlns:owl="
xmlns:dc="
xmlns:travel="
xml:base="
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="
</owl:Ontology>
<owl:Class rdf:ID="HeliBunjeeJumping">
<rdfs:subClassOf rdf:resource="
</owl:Class>
<HeliBunjeeJumping rdf:ID="ManicSuperBunjee">
<travel:isPossibleIn>
<rdf:Description rdf:about="
<travel:hasActivity rdf:resource="#ManicSuperBunjee"/>
</rdf:Description>
</travel:isPossibleIn>
<travel:hasContact>
<travel:Contact rdf:ID="MSBInc">
<travel:has </travel:has >
<travel:hasCity rdf:datatype="
<travel:hasStreet rdf:datatype=" Victoria St</travel:hasStreet>
<travel:hasZipCode rdf:datatype="
</travel:Contact>
</travel:hasContact>
<rdfs:comment rdf:datatype=" super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed.</rdfs:comment>
</HeliBunjeeJumping>
</rdf:RDF>

66. OWL File [***] in HeliBunjeeJumping
<travel:isPossibleIn>
<rdf:Description rdf:about=" library/travel.owl#Sydney">
<travel:hasActivity rdf:resource="#ManicSuperBunjee"/>
</rdf:Description>
</travel:isPossibleIn>
<travel:hasContact>
[ +++ ]
</travel:hasContact>
<rdfs:comment rdf:datatype=" super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed.</rdfs:comment>
<?xml version="1.0"?>
<rdf:RDF
xmlns="
xmlns:rdf="
xmlns:rdfs="
xmlns:owl="
xmlns:dc="
xmlns:travel="
xml:base="
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="
</owl:Ontology>
<owl:Class rdf:ID="HeliBunjeeJumping">
<rdfs:subClassOf rdf:resource="
</owl:Class>
<HeliBunjeeJumping rdf:ID="ManicSuperBunjee">
<travel:isPossibleIn>
<rdf:Description rdf:about="
<travel:hasActivity rdf:resource="#ManicSuperBunjee"/>
</rdf:Description>
</travel:isPossibleIn>
<travel:hasContact>
<travel:Contact rdf:ID="MSBInc">
<travel:has </travel:has >
<travel:hasCity rdf:datatype="
<travel:hasStreet rdf:datatype=" Victoria St</travel:hasStreet>
<travel:hasZipCode rdf:datatype="
</travel:Contact>
</travel:hasContact>
<rdfs:comment rdf:datatype=" super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed.</rdfs:comment>
</HeliBunjeeJumping>
</rdf:RDF>

67. OWL File [+++] in travel:hasContact
<travel:Contact rdf:ID="MSBInc">
<travel:has </travel:has >
<travel:hasCity rdf:datatype="
<travel:hasStreet rdf:datatype=" Victoria St</travel:hasStreet>
<travel:hasZipCode rdf:datatype="
</travel:Contact>
<?xml version="1.0"?>\
<rdf:RDF
xmlns="
xmlns:rdf="
xmlns:rdfs="
xmlns:owl="
xmlns:dc="
xmlns:travel="
xml:base="
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="
</owl:Ontology>
<owl:Class rdf:ID="HeliBunjeeJumping">
<rdfs:subClassOf rdf:resource="
</owl:Class>
<HeliBunjeeJumping rdf:ID="ManicSuperBunjee">
<travel:isPossibleIn>
<rdf:Description rdf:about="
<travel:hasActivity rdf:resource="#ManicSuperBunjee"/>
</rdf:Description>
</travel:isPossibleIn>
<travel:hasContact>
<travel:Contact rdf:ID="MSBInc">
<travel:has </travel:has >
<travel:hasCity rdf:datatype="
<travel:hasStreet rdf:datatype=" Victoria St</travel:hasStreet>
<travel:hasZipCode rdf:datatype="
</travel:Contact>
</travel:hasContact>
<rdfs:comment rdf:datatype=" super bunjee now offers nerve wrecking jumps from 300 feet right out of a helicopter. Satisfaction guaranteed.</rdfs:comment>
</HeliBunjeeJumping>
</rdf:RDF>

68. OWL Lite Synopsis Header Information: Ontology imports
Class Intersection:
intersectionOf
Versioning:
versionInfo
priorVersion
backwardCompatibleWith
incompatibleWith
DeprecatedClass
DeprecatedProperty
Annotation Properties:
rdfs:label
rdfs:comment
rdfs:seeAlso
rdfs:isDefinedBy
AnnotationProperty
OntologyProperty
Datatypes
xsd datatypes
Property Characteristics:
ObjectProperty
DatatypeProperty
inverseOf
TransitiveProperty
SymmetricProperty
FunctionalProperty
InverseFunctionalProperty
Property Restrictions:
Restriction
onProperty
allValuesFrom
someValuesFrom
Restricted Cardinality:
minCardinality (only 0 or 1)
maxCardinality (only 0 or 1)
cardinality (only 0 or 1)
RDF Schema Features:
Class (Thing, Nothing)
rdfs:subClassOf
rdf:Property
rdfs:subPropertyOf
rdfs:domain
rdfs:range
Individual
(In)Equality:
equivalentClass
equivalentProperty
sameAs
differentFrom
AllDifferent
distinctMembers

69. OWL DL + Full Class Axioms: oneOf, dataRange disjointWith
equivalentClass (applied to class expressions)
rdfs:subClassOf (applied to class expressions)
Boolean Combinations of Class Expressions:
unionOf
complementOf
intersectionOf
Arbitrary Cardinality:
minCardinality
maxCardinality
cardinality
Filler Information:
hasValue

70. Problems with RDFS
RDFS too weak to describe resources in sufficient detail
No localised range and domain constraints
Can’t say that the range of hasChild is person when applied to persons and elephant when applied to elephants
No existence/cardinality constraints
Can’t say that all instances of person have a mother that is also a person, or that persons have exactly 2 parents
No transitive, inverse or symmetrical properties
Can’t say that isPartOf is a transitive property, that hasPart is the inverse of isPartOf or that touches is symmetrical
Difficult to provide reasoning support
No “native” reasoners for non-standard semantics
May be possible to reason via FO axiomatisation

71. Web Ontology Language Requirements
Desirable features identified for Web Ontology Language:
Extends existing Web standards
Such as XML, RDF, RDFS
Easy to understand and use
Should be based on familiar KR idioms
Formally specified
Of “adequate” expressive power
Possible to provide automated reasoning support
KR = knowledge reasoning

72. From RDF to OWL Two languages developed to satisfy above requirements
OIL: developed by group of (largely) European researchers (several from EU OntoKnowledge project)
DAML-ONT: developed by group of (largely) US researchers (in DARPA DAML programme)
Efforts merged to produce DAML+OIL
Development was carried out by “Joint EU/US Committee on Agent Markup Languages”
Extends (“DL subset” of) RDF
DAML+OIL submitted to W3C as basis for standardisation
Web-Ontology (WebOnt) Working Group formed
WebOnt group developed OWL language based on DAML+OIL
OWL language now a W3C Proposed Recommendation

73. OWL Language Three species of OWL Semantic layering
OWL full is union of OWL syntax and RDF
OWL DL restricted to FOL fragment (¼ DAML+OIL)
OWL Lite is “easier to implement” subset of OWL DL
Semantic layering
OWL DL ¼ OWL full within DL fragment
DL semantics officially definitive
OWL DL based on SHIQ Description Logic
In fact it is equivalent to SHOIN(Dn) DL
OWL DL Benefits from many years of DL research
Well defined semantics
Formal properties well understood (complexity, decidability)
Known reasoning algorithms
Implemented systems (highly optimised)
DL = Description Logics
See paper Reducing OWL Entailment to Description Logic Satisfiability
by Ian Horrocks and Peter F. Patel-Schneider

74. OWL built-in classes
owl:FunctionalProperty, owl:InverseFunctionalProperty, owl:SymmetricProperty, owl:TransitiveProperty, owl:DeprecatedClass, owl:DeprecatedProperty

75. OWL built in properties
owl:equivalentClass, owl:disjointWith, owl:equivalentProperty, owl:inverseOf, owl:sameAs, owl:differentFrom, owl:complementOf, owl:unionOf, owl:intersectionOf, owl:oneOf, owl:allValuesFrom, owl:onProperty, owl:someValuesFrom, owl:hasValue, owl:minCardinality, owl:maxCardinality, owl:cardinality, owl:distinctMembers
annotation properties: owl:versionInfo, rdfs:label, rdfs:comment, rdfs:seeAlso, rdfs:isDefinedBy
ontology properties: owl:imports, owl:priorVersion, owl:backwardCompatibleWith, owl:incompatibleWith
See more information at:

76. OWL Class Constructors
XMLS datatypes as well as classes in
Arbitrarily complex nesting of constructors

77. OWL Syntax E.g., Person hasChild.(Doctor hasChild.Doctor):
<owl:Class>
<owl:intersectionOf rdf:parseType="collection">
<owl:Class rdf:about="#Person"/>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasChild"/>
<owl:toClass>
<owl:unionOf rdf:parseType="collection">
<owl:Class rdf:about="#Doctor"/>
<owl:hasClass rdf:resource="#Doctor"/>
</owl:Restriction>
</owl:unionOf>
</owl:toClass>
</owl:intersectionOf>
</owl:Class>

78. OWL Axioms Axioms (mostly) reducible to inclusion (v)
C ´ D iff both C v D and D v C

79. XML Schema Datatypes in OWL
OWL supports XML Schema primitive datatypes
E.g., integer, real, string, …
Strict separation between “object” classes and datatypes
Disjoint interpretation domain for datatypes
Disjoint “object” and datatype properties

80. Why Separate Classes and Datatypes?
Philosophical reasons:
Datatypes structured by built-in predicates
Not appropriate to form new datatypes using ontology language
Practical reasons:
Ontology language remains simple and compact
Semantic integrity of ontology language not compromised
Implementability not compromised — can use hybrid reasoner

81. OWL query language: OWL-QL
OWL Query Language (OWL-QL) is an updated version of the DAML Query Language (DQL).
It is intended to be a candidate standard language and protocol for query-answering dialogues among Semantic Web computational agents.
OWL-QL developed at Stanford:
See also:

82. OWL Conclusion We have learned: OWL definition OWL comparison with RDF
OWL classes and properties
Usage scenarios