Presentation is loading. Please wait.

Presentation is loading. Please wait.

Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/ OWL Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/ http://www.w3.org/TR/owl-ref/

Similar presentations


Presentation on theme: "Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/ OWL Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/ http://www.w3.org/TR/owl-ref/"— Presentation transcript:

1 Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/
OWL Dr. Alexandra I. Cristea

2 What is OWL? W3C Recommendation, February 2004. Web Ontology Language
web standard Newest OWL 2 (November 2009) 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: Please note: New Version Available: OWL 2 (Document Status Update, 12 November 2009) The OWL Working Group has produced a W3C Recommendation for a new version of OWL which adds features to this 2004 version, while remaining compatible. Please see OWL 2 Document Overview for an introduction to OWL 2 and a guide to the OWL 2 document set. OWL 2 has a very similar overall structure to OWL 1. Looking at Figure 1, almost all the building blocks of OWL 2 were present in OWL 1, albeit possibly under different names. The central role of RDF/XML, the role of other syntaxes, and the relationships between the Direct and RDF-Based semantics (i.e., the correspondence theorem) have not changed. More importantly, backwards compatibility with OWL 1 is, to all intents and purposes, complete: all OWL 1 Ontologies remain valid OWL 2 Ontologies, with identical inferences in all practical cases (see Section 4.2 of OWL 2 New Features and Rationale [OWL 2 New Features and Rationale]). OWL 2 adds new functionality with respect to OWL 1. Some of the new features are syntactic sugar (e.g., disjoint union of classes) while others offer new expressivity, including: keys; property chains; richer datatypes, data ranges; qualified cardinality restrictions; asymmetric, reflexive, and disjoint properties; and enhanced annotation capabilities OWL 2 also defines three new profiles [OWL 2 Profiles] and a new syntax [OWL 2 Manchester Syntax]. In addition, some of the restrictions applicable to OWL DL have been relaxed; as a result, the set of RDF Graphs that can be handled by Description Logics reasoners is slightly larger in OWL See more at: See changes only at:

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.. Classes - individuals 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. Oh yes, there is a namespace: xmlns:owl ="http://www.w3.org/2002/07/owl#" 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: Semantic web search engine: Validators are: For RDF: For OWL: For a tutorial on XML, RDF, SPARQL, OWL see: Please note that the latest version is OWL 2: A validator for it is: But we’re not using it, because this lecture still uses OWL 1 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, B&B, 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 existence 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, "http://www.w3.org/TR/2004/REC-owl-guide /wine#Region". 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 Please note that arities of n,m are only possible in OWL DL and above. OWL Lite only supports the arity of 0..1. 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. Please note that by separating Properties and Individuals, they both are first class citizens: you can have individuals that don’t relate to any properties, and viceversa, properties that don’t yet reflect on any individuals.

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="http://www.sample.com/ontologies/zoo#Animal"> 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="http://www.sample.com/ontologies/zoo#Animal">

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. Short test: Does the following construct need to be there?: <rdfs:domain rdf:resource="&owl;Thing" />

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 ="http://www.w3.org/2002/07/owl#" xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs ="http://www.w3.org/2000/01/rdf-schema#" xmlns:xsd ="http://www.w3.org/2001/XMLSchema#" 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> Not OWL Lite! 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 This denotes a complete class (necessary & sufficient condition).

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.” By default, all restrictions are ‘necessary’ only. For defining necessary and sufficient conditions OWL provides the owl:equivalentClass construct. Example usage: <owl:Class rdf:about="#US_President"> <equivalentClass rdf:resource="#PrincipalResidentOfWhiteHouse"/> </owl:Class> NOTE: The use of owl:equivalentClass does not imply class equality! <owl:Class rdf:ID="DaPonteOperaOfMozart"> <owl:equivalentClass> <owl:Class> <owl:oneOf rdf:parseType="Collection"> <Opera rdf:about="#Nozze_di_Figaro"/> <Opera rdf:about="#Don_Giovanni"/> <Opera rdf:about="#Cosi_fan_tutte"/> </owl:oneOf> </owl:Class> </owl:equivalentClass> </owl:Class>

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 Property, 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="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"> [. . .] </rdf:RDF> Remember, validators are: For RDF: For OWL: <?xml version="1.0"?> <rdf:RDF 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:has </travel:has > <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>

65 OWL File: [. . .] OWL body in RDF wrap
<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"> [***] </HeliBunjeeJumping> <?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:has </travel:has > <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>

66 OWL File [***] in HeliBunjeeJumping
<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: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> <?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:has </travel:has > <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>

67 OWL File [+++] in travel:hasContact
<travel:Contact rdf:ID="MSBInc"> <travel:has </travel:has > <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> <?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:has </travel:has > <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>

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:allValuesFrom> <owl:unionOf rdf:parseType="collection"> <owl:Class rdf:about="#Doctor"/> <owl:hasClass rdf:resource="#Doctor"/> </owl:Restriction> </owl:unionOf> </owl:allValuesFrom> </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


Download ppt "Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/ OWL Dr. Alexandra I. Cristea http://www.dcs.warwick.ac.uk/~acristea/ http://www.w3.org/TR/owl-ref/"

Similar presentations


Ads by Google