Mustafa Jarrar Lecture Notes, Knowledge Engineering (SCOM7348) University of Birzeit 1 st Semester, 2011 Knowledge Engineering (SCOM7348) OWL Web Ontology Language Dr. Mustafa Jarrar University of Birzeit mjarrar@birzeit.edu www.jarrar.info Jarrar 2011 1
Reading Material OWL Guide http://www.w3.org/tr/2004/rec-owl-guide-20040210/#basicdefinitions You only need to read: Section 1. Introduction Section 2. The Structure of Ontologies Section 3. Basic Elements Section 4. Ontology Mapping Section 5. Complex Classes OWL 2 Document Overview http://www.w3.org/tr/owl2-overview/ OWL 2 Web Ontology Language: Structural Specification and Functional-Style Syntax http://www.w3.org/2007/owl/draft/owl2-syntax Jarrar 2011 2
What is OWL? http://www.w3schools.com OWL stands for Web Ontology Language. OWL is built on top of RDF. OWL is written in XML. OWL is for processing information on the web. OWL was designed to be interpreted by computers. OWL was not designed for being read by people. OWL has three sublanguages (OWL full, OWL DL, OWL Lite) OWL is a W3C standard. Jarrar 2011 3
OWL Source: www.w3.org Jarrar 2011 4
What is an Ontology 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 them. (only at this stage), you can see an ORM schema as ontology. Later, we will study the difference between an ontology and a databases schema. Jarrar 2011 5
Why OWL? OWL is part of the "Semantic Web Vision" Web information has exact meaning. Web information can be processed by computers. Computers can integrate information from the web. Jarrar 2011 6
OWL was Designed for Processing Information OWL was designed to provide a common way to process the content of web information (instead of displaying it). OWL was designed to be read by computer applications (instead of humans). Jarrar 2011 7
OWL is Different from RDF 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 and RDFS. Jarrar 2011 8
Variations of OWL OWL Full An extension of RDF Allows for classes as instances, modification of RDF and OWL vocabularies OWL DL The part of OWL Full that is in the Description Logic framework. Known to have decidable reasoning. OWL Lite A subset of OWL DL Easier for frame-based tools to transition to Easier reasoning Jarrar 2011 9
OWL is Written in XML OWL is specified in XML so it can be easily exchanged between different types of computers using different types of operating system and application languages. OWL can be seen as an extension of RDF/RDFS, so that RDF parsers can parse OWL. Names in OWL are RDF URI references e.g., http://cohse.semanticweb.org/ontologies/people#pet Often (informally) abbreviated via XML qualified names e.g., pp:pet Data items belong to XML Schema datatypes e.g., XML Schema integers and strings Generally written in RDF/XML form e.g.,.7.8sd:integer,.susan.8sd:string Jarrar 2011 10
OWL is a Web Standard 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. Jarrar 2011 11
OWL 2 OWL 2, became a W3C recommendation in 27 October 2009. An ontology language for the semantic Web which is extended from OWL 1 and empowered by new features. OWL 2 DL underpinning description logic is SROIQ DL. Contains the majority of constructs to be used for building any needed ontology. OWL 2 is supported by several semantic reasoners such as RacerPro 2, Pellet, Hermit and FaCT++. OWL 2 ontologies are primary exchanged as RDF documents, where these ontologies can be used with information written in RDF. OWL 2 elements are identified by Internationalized Resource Identifiers (IRIs). Jarrar 2011 12
Variations of OWL 2 OWL 2 EL Allows for subclass axioms with intersection, existential quantification, top, bottom and closed classes with only one member. Disallow for negation, disjunction, arbitrary universal quantification, role inverses. OWL 2 QL Allows for subproperties, domain, range and subclass statements. Disallow for closed classes. OWL 2 RL Allows for all axiom types, cardinality restrictions(only 1 and 0 on right hand side) and closed classes with only one member. disallow certain constructors( universal and negation on left hand side and extensional and union on right hand side of subclass statements). Jarrar 2011 13
OWL Basics Classes Individuals Properties Special Classes and Properties Jarrar 2011 14
Classes Owl:Class Unary predicates: Person( ), City( ). User-defined classes which are subclasses of root class owl:thing. A class may contain individuals, which are instances of the class, and other subclasses. <owl:class rdf:id= Person"/> <owl:class rdf:id= City"/> <owl:class rdf:id= Country"/> <owl:class rdf:id= Book"/> Similar to Object-Type in ORM, Entity in EER, or Class in UML Jarrar 2011 15
Individuals Individuals Constants: Edward_Said, Palestine. An individual is a member/instance of a class <Man rdf:id= Edward_Said" /> <Country rdf:id= Palestine" /> <City rdf:id= Jerusalem" /> Notice that there is no way in ORM/UML/EER to add instance of concepts as art of the schema. Jarrar 2011 16
Properties owl:objectproperty A relation between instances of two classes. Binary predicates (author(, ) ). Similar to a binary relation in ORM between two entities. <owl:objectproperty rdf:id= Author"> <rdfs:domain rdf:resource="# Book"/> <rdfs:range rdf:resource="#person"/> </owl:objectproperty> Jarrar 2011 17
Properties owl:datatypeproperty Relation between instances of classes and literals. The range of a literal datatype (use XML Schema datatypes). Similar to a binary relation in ORM between an Entity and a Value. <owl:datatypeproperty rdf:id= Title"> <rdfs:domain rdf:resource="#book" /> <rdfs:range rdf:resource=" xsd:string"/> </owl:datatypeproperty> <owl:datatypeproperty rdf:id= Price"> <rdfs:domain rdf:resource="#book" /> <rdfs:range rdf:resource="xsd:integer"/> </owl:datatypeproperty> Jarrar 2011 18
Special Classes and Properties Top class: T owl:thing contains all individuals of the domain. Bottom class: owl:nothing contains no individuals(empty class). Universal property: U owl:topobjectproperty links every individual to every individual. Jarrar 2011 19
Calss Expression Axioms Subclass Axioms Equivalent Classes Disjoint Classes Disjoint Union of Class Expressions Jarrar 2011 20
Class Expression Axioms Subclass Axioms rdfs:subclassof Notice that rdfs:subclassof is part of RDFS, not OWL. This to show that OWL extends RDF/RDFS. rdfs:subclassof is similar to the SubType relation UML and EER, and the same as subtype in ORM, but here it is not a proper subtypes. Similar to a subtype in ORM. SubClassOf( a:man a:person ) means that Each Man is a Person. <owl:class rdf:id= Man"> <rdfs:subclassof rdf:resource= #Person"/>... </owl:class> <owl:class rdf:id= Book"> <rdfs:subclassof rdf:resource="#publication" />... </owl:class> Jarrar 2011 21
Class Expression Axioms Equivalent Classes owl:equivalentclass States the equivalence (in terms of their class extension) of two named classes. Useful when integrating or mapping between two different ontologies. <owl:class rdf:about="#palestine_president"> <owl:equivalentclass rdf:resource= aa:principalresidentofplestine"/> </owl:class> A class axiom may contain (multiple) owl:equivalentclass statements. <owl:class rdf:about="#being"> <owl:equivalentclass rdf:resource="#human"/> <owl:equivalentclass rdf:resource="#person"/> </owl:class> The classes Being, Human and Person are semantically equivalent to each other. Jarrar 2011 22
Class Expression Axioms Disjoint Classes owl:disjointwith Each owl:disjointwith statement asserts that the class extensions of the two class descriptions involved have no individuals in common. DisjointClasses( C1... Cn ) : all of the classes Ci, 1 i n, are pairwise disjoint; that is, no individual can be at the same time an instance of both Ci and Cj for i j. <owl:class rdf:about="#opera"> <rdfs:subclassof rdf:resource="#musicdrama"/> </owl:class> <owl:class rdf:about="#operetta"> <rdfs:subclassof rdf:resource="#musicdrama"/> <owl:disjointwith rdf:resource="#opera"/> </owl:class> Jarrar 2011 23
Class Expression Axioms Disjoint Classes (continued ) owl:alldisjointclasses In order to assert that a set of classes is mutually disjoint, we can use AllDisjointClasses. <rdf:description> <rdf:type rdf:resource="&owl;alldisjointclasses"/> <owl:members rdf:parsetype="collection"> <rdf:description rdf:about="#building"/> <rdf:description rdf:about="#tree"/> <rdf:description rdf:about="#bird"/> </owl:members> </rdf:description> Jarrar 2011 24
Class Expression Axioms Disjoint Union of Class Expressions owl:disjointunionof DisjointUnion( C C1... Cn ): a class C is a disjoint union of the classes Ci, 1 i n, all of which are pairwise disjoint the extensions of all Ci exactly cover the extension of C. DisjointUnion( Person Female Male ) means each Person is either a Male or a Female, each Female is a Person, each Male is a Person, and nothing can be both a Female and a Male. <owl:class rdf:about="#person"> <owl:disjointunionof rdf:parsetype="collection"> <rdf:description rdf:about="#female"/> <rdf:description rdf:about="#male"/> </owl:disjointunionof> Jarrar 2011 25
In what follows we illustrate a simple example represented in ORM and OWL 2. In the example, the illustrated OWL 2 constructs are Class, Subclass, Union of Classes and Disjoint Classes. Male Person Class Expression Axioms OWL2 Example1 Female... <Class rdf:about="&owl2example1;person /> <Class rdf:about="&owl2example1;female"> <rdfs:subclassof rdf:resource="&owl2example1;person"/> <disjointwith rdf:resource="&owl2example1;male"/> </Class> <Class rdf:about="&owl2example1;male"> <rdfs:subclassof rdf:resource="&owl2example1;person"/> </Class> <Class rdf:about="&owl2example1;person"> <equivalentclass> <Class> <unionof rdf:parsetype="collection"> <rdf:description rdf:about="&owl2example1;female"/> <rdf:description rdf:about="&owl2example1;male"/> </unionof> </Class> <equivalentclass> </Class> Jarrar 2011 26
Object Property Axioms Object Subproperties Equivalent Object Properties Disjoint Object Properties Inverse Object Properties Object Property Domain Object Property Range Functional Object Properties Inverse-Functional Object Properties Jarrar 2011 27
Object Property Axioms Object Subproperties rdfs:subpropertyof Properties, like classes, can be arranged in a hierarchy. SubObjectPropertyOf( OP1 OP2 ): if an individual x is connected by OP1 to an individual y, then x is also connected by OP2 to y. The rdfs:subpropertyof means that anything with a Borrows property with value X also has a ChecksOut property with value X. Similar to the Subset constraint in ORM. <owl:objectproperty rdf:id= Borrows"> <rdfs:domain rdf:resource="#person"/> <rdfs:range rdf:resource="#book"/> </owl:objectproperty> <owl:objectproperty rdf:id= ChecksOut"> <rdfs:subpropertyof rdf:resource="# Borrows" /> <rdfs:range rdf:resource="#book" />... </owl:objectproperty> Jarrar 2011 28
Object Property Axioms Equivalent Object Properties owl:equivalentproperty EquivalentObjectProperties( OP1... OPn ) : all of the object properties OPi, 1 i n, are semantically equivalent to each other. Similar to the Equality constraint in ORM. EquivalentObjectProperties( a:hasbrother a:hasmalesibling ) means that having a brother is the same as having a male sibling. <owl:objectproperty rdf:about="#hasbrother"> <owl:equivalentproperty rdf:resource="#hasmalesibling"/> </owl:objectproperty> Jarrar 2011 29
Object Property Axioms Disjoint Object Properties owl:propertydisjointwith DisjointObjectProperties( OP1... OPn ) : all of the object properties OPi, 1 i n, are pairwise disjoint; that is, no individual x can be connected to an individual y by both OPi and OPj for i j. Similar to the Exclusion constraint in ORM. DisjointObjectProperties( a:hasfather a:hasmother ) means that Fatherhood is disjoint with motherhood. <owl:objectproperty rdf:about="#hasfather"> <owl:propertydisjointwith rdf:resource="#hasmother"/> </owl:objectproperty> Jarrar 2011 30
Object Property Axioms Inverse Object Properties owl:inverseof If a property P is tagged as the owl:inverseof Q, then for all x and y: P(x,y) iff Q(y,x). Note that the syntax for owl:inverseof takes a property name as an argument. A iff B means (A implies B) and (B implies A). InverseObjectProperties( OP1 OP2 ) : the object property OP1 is an inverse of the object property OPE2, that is if an individual x is connected by OP1 to an individual y, then y is also connected by OP2 to x, and vice versa. InverseObjectProperties( a:hasfather a:fatherof ) means that having a father is the opposite of being a father of someone. <owl:objectproperty rdf:about="#hasfather"> <owl:equivalentproperty> <rdf:description> <owl:inverseof rdf:resource="#fatherof"/> </rdf:description> </owl:equivalentproperty> </owl:objectproperty> Jarrar 2011 31
Object Property Axioms Object Property Domain rdfs:domain ObjectPropertyDomain(OP C): the domain of the object property OP is the class C, that is, if an individual x is connected by OP with some other individual, then x is an instance of C. ObjectPropertyDomain( a:hasdog a:person ) means that only people can own dogs. <owl:objectproperty rdf:about="#hasdog"> <rdfs:domain rdf:resource="#person"/> </owl:objectproperty> Jarrar 2011 32
Object Property Axioms Object Property Range rdfs:range ObjectPropertyRange(OP C): the range of the object property OP is the class C, that is, if some individual is connected by OP with an individual x, then x is an instance of C. ObjectPropertyRange( a:hasdog a:dog ) means that the range of the a:hasdog property is the class a:dog. <owl:objectproperty rdf:about="#hasdog"> <rdfs:range rdf:resource="#dog"/> </owl:objectproperty> Jarrar 2011 33
Object Property Axioms Functional Object Property Owl:FunctionalProperty FunctionalObjectProperty( OP ) : the object property OP is functional, that is, for each individual x, there can be at most one distinct individual y such that x is connected by OP to y. Similar to the Uniquness constraint in ORM. FunctionalObjectProperty( a:hasfather ) means that each object can have at most one father. <owl:objectproperty rdf:about="#hasfather"> <rdf:type rdf:resource="&owl;functionalproperty"/> </owl:objectproperty> Jarrar 2011 34
Object Property Axioms Inverse-Functional Object Property Owl:InverseFunctionalProperty InverseFunctionalObjectProperty( OPI ) : the object property OPI is inverse-functional, that is, for each individual x, there can be at most one individual y such that y is connected by OP with x. InverseFunctionalObjectProperty( a:fatherof ) means that each object can have at most one father. <owl:objectproperty rdf:about="#fatherof"> <rdf:type rdf:resource="&owl;inversefunctionalproperty"/> </owl:objectproperty> Jarrar 2011 35
Object Property Axioms OWL2 Example2 In what follows we illustrate a simple example represented in ORM and OWL 2. In the example, the illustrated OWL 2 constructs are Object Subproperties, Inverse Object Properties, Object Property Domain, Object Property Range and Functional Object Properties. Drives DrivenBy Gender Has Person Vehicle Owns... <Class rdf:about="&owl2example2;person"/> <Class rdf:about="&owl2example2;vehicle"/> <Class rdf:about="&owl2example2;drivinglicense"/> <Class rdf:about="&owl2example2;gender"/> <ObjectProperty rdf:about="&owl2example2;drives"> <rdfs:domain rdf:resource="&owl2example2;person"/> <rdfs:range rdf:resource="&owl2example2;vehicle"/> </ObjectProperty> <ObjectProperty rdf:about="&owl2example2;drives"> <inverseof rdf:resource="&owl2example2;drivenby"/> </ObjectProperty> <ObjectProperty rdf:about="&owl2example2;owns"> <rdfs:domain rdf:resource="&owl2example2;person"/> <rdfs:range rdf:resource="&owl2example2;vehicle"/> </ObjectProperty> <ObjectProperty rdf:about="&owl2example2;owns"> <rdfs:subpropertyof rdf:resource="&owl2example2;drives"/> </ObjectProperty> <ObjectProperty rdf:about="&owl2example2;has"> <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#functionalproper ty"/> </ObjectProperty> Jarrar 2011 36
Assertions Class Assertions Individual Equality Individual Inequality Jarrar 2011 37
Assertions Class Assertions owl:namedindividual ClassAssertion( C a ) : the individual a is an instance of the class C. ClassAssertion( a:person a:mira ) means that Mira is a Person. <owl:namedindividual rdf:about="#mira"> <rdf:type rdf:resource="#person"/> </owl:namedindividual> Jarrar 2011 38
Assertions Individual Equality owl:sameas Identity between Individuals This mechanism is similar to that for classes, but declares two individuals to be identical. SameIndividual( a1... an ): all of the individuals ai, 1 i n, are equal to each other(synonymes). <Book rdf:id= http://www.amazon.com/orientalism-edward-w-said/dp/039474067x"> <owl:sameas rdf:resource=" http://en.wikipedia.org/wiki/orientalism" /> </Book> <rdf:description rdf:about="#edward_said"> <owl:sameas rdf:resource="# E_Said "/> </rdf:description> <owl:class rdf:id="footballteam"> <owl:sameas rdf:resource="http://sports.org/us#soccerteam"/> </owl:class> Jarrar 2011 39
Assertions Individual Inequality owl:differentfrom [OWL DL] An owl:differentfrom statement indicates that two URI references refer to different individuals. It is needed where OWL 2 does not support unique name assumption. <Book rdf:id="http://www.amazon.com/orientalism-edward-w-said/dp/039474067x"> <owl:differentfrom rdf:resource="http://www.youtube.com/watch?v=x3ia73jxifo"/> </Book> Jarrar 2011 40
Assertions Individual Inequality (AllDifferent) The use of owl:differentfrom is likely to lead to a large number of statements, as all individuals have to be declared pairwise disjoint. DifferentIndividuals( a1... an ): all of the individuals ai, 1 i n, are different from each other; that is, no individuals ai and aj with i j can be derived to be equal. DifferentIndividuals( a:antoon a:mustafa a:rami ) Antoon, Mustafa and Rami are all different from each other. <rdf:description> <rdf:type rdf:resource="&owl;alldifferent"/> <owl:distinctmembers rdf:parsetype="collection"> <rdf:description rdf:about="#antoon"/> <rdf:description rdf:about="#mustafa"/> <rdf:description rdf:about="#rami"/> </owl:distinctmembers> </rdf:description> Jarrar 2011 41
Class Expressions Intersection of Class Expressions Union of Class Expressions Complement of Class Expressions Enumeration of Individuals Jarrar 2011 42
Class Expressions Intersection of Class Expressions owl:intersectionof Describes a class for which the class extension contains precisely those individuals that are members of the class extension of all class descriptions in the list. <owl:class> <owl:intersectionof rdf:parsetype="collection"> <owl:class> <owl:oneof rdf:parsetype="collection"> <owl:thing rdf:about="#birzeituniversity" /> <owl:thing rdf:about="#teracollage" /> </owl:oneof> </owl:class> <owl:class> <owl:oneof rdf:parsetype="collection"> <owl:thing rdf:about="#birzeituniversity" /> <owl:thing rdf:about="#alqudsuniversity" /> <owl:thing rdf:about="#alnajahuniversity" /> </owl:oneof> </owl:class> </owl:intersectionof> </owl:class> Jarrar 2011 43
Class Expressions Union of Class Expressions owl:unionof [OWL DL] Describes an anonymous class for which the class extension contains those individuals that occur in at least one of the class extensions of the class descriptions in the list. <owl:class> <owl:unionof rdf:parsetype="collection"> <owl:class> <owl:oneof rdf:parsetype="collection"> <owl:thing rdf:about="#birzeituniversity" /> <owl:thing rdf:about="#teracollage" /> </owl:oneof> </owl:class> <owl:class> <owl:oneof rdf:parsetype="collection"> <owl:thing rdf:about="#birzeituniversity" /> <owl:thing rdf:about="#alqudsuniversity" /> <owl:thing rdf:about="#alnajahuniversity" /> </owl:oneof> </owl:class> </owl:unionof> </owl:class> Jarrar 2011 44
Class Expressions Complement of Class Expressions owl:complementof [OWL DL] Describes a class for which the class extension contains exactly those individuals that do not belong to the class extension of the class description that is the object of the statement. Analogous to logical negation: the class extension consists of those individuals that are NOT members of the class extension of the complement class. <owl:class rdf:id="notpalestinian"> <owl:intersectionof rdf:parsetype="collection"> <owl:class rdf:about="#person"/> <owl:class> <owl:complementof> <owl:restriction> <owl:onproperty rdf:resource="#hasparent" /> <owl:hasvalue rdf:resource="#palestine" /> </owl:restriction> </owl:complementof> </owl:class> </owl:intersectionof> </owl:class> Jarrar 2011 45
Class Expressions Enumeration of Individuals owl:one of [OWL DL] A list of individuals that are the instances of the class described. This enables a class to be described by exhaustively enumerating its instances. The class extension of a class described with owl:oneof contains exactly the enumerated individuals, no more, no less. <owl:class> < </owl:oneof> owl:oneof rdf:parsetype="collection"> <owl:thing rdf:about="#jerusalem "/> <owl:thing rdf:about="#aka"/> <owl:thing rdf:about="#gaza"/> <owl:thing rdf:about="#nablus"/> <owl:thing rdf:about="#hebron"/> </owl:class> Jarrar 2011 46
Class Expressions Object Property Restrictions Existential Quantification Universal Quantification Individual Value Restriction Self-Restriction Jarrar 2011 47
Class Expressions Object Property Restrictions- Existential Quantification owl:somevaluesfrom For all Accounts, they have at least one Owner that is a Peron. <owl:class rdf:id= Account"> <owl:restriction> <owl:onproperty rdf:resource="#hasowner" /> <owl:somevaluesfrom rdf:resource="#person" /> </owl:restriction> </owl:class> Jarrar 2011 48
Class Expressions Object Property Restrictions- Universal Quantification owl:allvaluesfrom For all Accounts, if they have owners, all the owners are Persons. <owl:class rdf:id= Account"> <owl:restriction> <owl:onproperty rdf:resource="#hasowner" /> <owl:allvaluesfrom rdf:resource="#person" /> </owl:restriction> </owl:class> Jarrar 2011 49
Class Expressions Object Property Restrictions- Individual Value Restriction owl:hasvalue ObjectHasValue( OP a ): consists of an object property OP and an individual a, and it contains all those individuals that are connected by OP to a. <owl:restriction> <owl:onproperty rdf:resource="#fatherof"/> <owl:hasvalue rdf:resource="#john"/> </owl:restriction> Jarrar 2011 50
owl:hasself Class Expressions Object Property Restrictions- Self Restriction ObjectHasSelf( OP ): consists of an object property OP, and it contains all those individuals that are connected by OP to themselves. ObjectHasSelf( a:hates ) contains those individuals that hate themselves. <owl:restriction> <owl:onproperty rdf:resource="#hates"/> <owl:hasself rdf:datatype="&xsd;boolean">true</owl:hasself> </owl:restriction> Jarrar 2011 51
Class Expressions Object Property Cardinality Restrictions Minimum Cardinality Maximum Cardinality Exact Cardinality Jarrar 2011 52
Class Expressions Object Property Cardinality Restrictions- Minimum Cardinality owl:restriction, owl:onproperty, owl:mincardinality OWL allows us to place some restrictions on properties, such as owl:mincardinality. The owl:restriction below is to place a min cardinality constraint on the property AuthorOf, at least one. This is similar to Mandatory in ORM <owl:class rdf:id= Book"> <rdfs:subclassof> <owl:restriction> <owl:onproperty rdf:resource="#authorof"/> <owl:mincardinality rdf:datatype="&xsd;nonnegativeinteger >1</owl:minCardinality> </owl:restriction> </rdfs:subclassof>... </owl:class> Jarrar 2011 53
Class Expressions Object Property Cardinality Restrictions- Maximum Cardinality owl:maxcardinality OWL allows us to place some restrictions on properties, such as owl:maxcardinality. The owl:restriction below is to place a max cardinality constraint on the property AuthorOf, at most one. This is similar to unique in ORM. <owl:class rdf:id= Book"> <rdfs:subclassof> <owl:restriction> <owl:onproperty rdf:resource="#authorof"/> <owl:maxcardinality rdf:datatype="&xsd;nonnegativeinteger >1</owl:maxCardinality> </owl:restriction> </rdfs:subclassof>... </owl:class> Jarrar 2011 54
Class Expressions Object Property Cardinality Restrictions - Cardinality This permits the user to indicate 'at least one', 'no more than one', and 'exactly one'. For example: Each book has at least and at most (i.e., exactly) one ISBN value. <owl:class rdf:id= Book"> <rdfs:subclassof> <owl:restriction> <owl:onproperty rdf:resource="#hasisbn"/> <owl:cardinality rdf:datatype="&xsd;nonnegativeinteger">1</owl:cardinality> </owl:restriction> </rdfs:subclassof> </owl:class> Cardinality with values limited to 0 or 1 are part of OWL Lite. owl:maxcardinality can be used to specify an upper bound. owl:mincardinality can be used to specify a lower bound. In combination, the two can be used to limit the property's cardinality to a numeric interval. Positive integer values other than 0 and 1 are permitted in OWL DL. Jarrar 2011 55
Class Expressions Object Property Cardinality Restrictions- Exact Cardinality owl:qualifiedcardinality The owl:restriction below is to place an exact cardinality expression that contains those individuals that are connected by a:hasvehicle to exactly one instance of a:car. <owl:class rdf:about="#person"> <owl:equivalentclass> <owl:restriction> <owl:onproperty rdf:resource="#hasvehicle"/> <owl:onclass rdf:resource="#car"/> <owl:qualifiedcardinality rdf:datatype="&xsd;nonnegativeinteger">1</owl:qualifiedcardinality> </owl:restriction> </owl:equivalentclass> </owl:class> Jarrar 2011 56
Property Chain Axioms owl:propertychainaxiom Allows for inferring the existence of a property from a chain of properties. <rdf:description rdf:about="hasgrandparent"> <owl:propertychainaxiom rdf:parsetype="collection"> <owl:objectproperty rdf:about="hasparent"/> <owl:objectproperty rdf:about="hasparent"/> </owl:propertychainaxiom> </rdf:description> Jarrar 2011 57
XML Datatypes xsd:string xsd:normalizedstring xsd:boolean xsd:decimal xsd:float xsd:double xsd:integer xsd:nonnegativeinteger xsd:positiveinteger xsd:nonpositiveinteger xsd:negativeinteger xsd:long xsd:int xsd:short xsd:byte xsd:unsignedlong xsd:unsignedint xsd:unsignedshort xsd:unsignedbyte xsd:hexbinary xsd:base64binary xsd:datetime xsd:time xsd:date xsd:gyearmonth xsd:gyear xsd:gmonthday xsd:gday xsd:gmonth xsd:anyuri xsd:token xsd:language xsd:nmtoken xsd:name xsd:ncname The above datatypes, plus rdfs:literal, form the built-in OWL datatypes. Jarrar 2011 58
Properties of Individuals We may also add properties between individuals. <owl:objectproperty rdf:id= hascapital">. <rdfs:domain rdf:resource= #Country" /> <rdfs:range rdf:resource="#city" /> </owl:objectproperty> <owl:objectproperty rdf:id= haspopulation">. <rdfs:domain rdf:resource= #City" /> <rdfs:range rdf:resource=" xsd:integer /> </owl:objectproperty> <City rdf:id= Palestine"> <hascaiptal rdf:resource="#j" /> </Region> Jarrar 2011 59