The Knowledge Presentation Language
Web Ontology Language (OWL)
 Web Ontology Language (OWL) extends RDF and
RDFS languages by adding several other constructs
such as class (in addition to the rdfs:class),
relationships between class and individuals, and
property characteristics
 These new constructs facilitate interoperability among
distributed resources
 OWL is encoded in RDF/XML
 OWL is said to be ‘monotonic’, meaning that
addition of new information to a knowledge base does
not falsify previous conclusions
Owl dialects
 OWL has three species: OWL-Lite, OWL DL, and
OWL Full
 The differences are on limitations on restrictions on
classes
 OWL Lite: supports class and property hierarchies and
simple restrictions, allowing us to develop thesauri and
simple ontologies
 OWL DL is the decidable version of OWL Full, with some
limitation; it is a restricted version of RDF
 OWL Full has no limitation, but may not be decidable
Features of OWL
 Is compatible with (serializable in) XML
 Uses XSD datatypes
 Follows description logic in having class, property, and
individuals
 Has constructs that are identified by the URIref
 Allow us to define complex classes with Boolean
combinations (intersection, union, complement)
 Makes it possible to define properties and
subproperties and assignng logical metadata (e.g.,
transitivity)
 Has features to set two classes, properties, and
individuals as equivalent
…
 Allows setting the cardinality constraints
 Setting classes as instances
 Resources defined by it can have labels such that they




can be displayed in different natural languages
Allows developing Web-distributed ontologies
Let’s us import and reuse other owl code (ontologies)
by extension
Allows saving the same ontologies with different
versions
Allows defining metadata for ontologies (e.g., author,
version)
OWL ontology header info
 Includes namespace declaration
 Information about the ontology within the owl:Ontology
Qname, e.g., version, comments, and import
 The version includes: owl:versionInfo, owl:priorVersion,
owl:backwardCompatibleWith, owl:incompatibleWith,
owl.deprecatedClass, and owl:deprecatedProperty
 We can also use the rdfs:comment, rdfs:label, rdfs:seeAlso,
and rdfs:isDefinedBy
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about="http://www.Tectonics.org">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Ontology"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about="http://www.StructuralGeology.org">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Ontology"/></rdf:type>
<rdfs:comment>Part of Structural Geology</rdfs:comment>
<rdfs:label>Structural Geology</rdfs:label>
<owl:imports><rdf:Description rdf:about="http://www.Tectonics.org"/> </owl:imports>
<owl:priorVersion><rdf:Description rdf:about="http://www.StructuralGeology.org/v0"/></owl:priorVersion>
</rdf:Description>
</rdf:RDF>
Two Types of Property in OWL
 Datatype Property has a typed literal (e.g., XSD or
RDF literal ) as its range
 As a binary relation, the datatype property relates a set of
instances of a class to a set of instances of a datatype
 A datatype property is declared using the
owl:DatatypeProperty:
<length
rdf:type
owl:DatatypeProperty>
 Or
<owl:datatypeProperty rdf:about=“length”/>
Object Property
 Object property has a URIref as its range
 As a binary property, it relates a set of individuals of one
class to the set of another class
 The subject and objects of a triple are both individuals
 Object properties are declared two different ways:
<analyze
rdf:type
owl:ObjectProperty> or
<owl:objectProperty rdf:about=“analyze”/>
Example in N3
struc:foldDescription rdf:type owl:DatatypeProperty.
struc : foldDescription rdfs : domain struc : Fold.
struc : foldDescription rdfs : range xsd : string.
struc : foldAxis rdf : type owl : ObjectProperty.
struc : foldAxis rdfs : domain struc : Fold.
struc : foldAxis rdfs : range struc : Line.
Domain and range of properties
 Can be assigned in a short form:
<owl:objectProperty rdf:about=“infiltrate”/>
<owl:domain rdf:resource=“SurfaceWater”/>
<owl:range rdf:resource=“Aquifer”/>
</owl:objectProperty>
Or the long way, as is shown in the following slide!
<rdf:Description rdf:about=":infiltrate“><rdf:type>
<rdf:Description
rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":SurfaceWater"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Aquifer"/></rdfs:range>
</rdf:Description>
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about=":length">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#DatatypeProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Fault"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about="http://www.w3.org/2001/XMLSchema#string"/></rdfs:range>
</rdf:Description>
<rdf:Description rdf:about=":infiltrate">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":SurfaceWater"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Aquifer"/></rdfs:range>
</rdf:Description>
<rdf:Description rdf:about=":Fault">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":SurfaceWater"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":Aquifer">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
</rdf:RDF>
owl:inveseOf
 Properties themselves have properties
 Owl:inverseOf property relates two properties to each other
 Many properties in one direction have an inverse
property in the opposite direction
 For example, the first property in each of the following
pairs: ‘analyzes’ and ‘analyzedBy’, ‘investigates’ and
‘investigatedBy’, ‘hasSample’ and ‘sampleOf, ‘wrote’ and
‘writtenBy’, and ‘locatedIn’ and ‘locationOf’, reverses the
direction of the second property
 These follow the definition of the mathematical inverse
function that state: if f(x) = y, then f-1(y) = x.
Inference of the owl:inverseOf
P owl:inverseOf Q.
If
x P y.
Then
y Q x.
hasPart
Fold
Limb
x
partOf
y
 Example: The partOf property is an inverse property
struc : Fold
partOf
hasPart
owl : inveseOf
struc : limb.
struc : hasPart.
 This means that if fold has limb as part, then limb is part
of fold
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about=":Fold"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":Limb"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":partOf"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Limb"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Fold"/></rdfs:range>
<owl:inverseOf><rdf:Description rdf:about=":hasPart"/></owl:inverseOf>
</rdf:Description>
<rdf:Description rdf:about=":hasPart"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
</rdf:Description>
</rdf:RDF>
partOf owl:inverseOf hasPart
owl:symmetricProperty
 If the property that relates two classes is the same in
both directions, we declare the property as symmetric
 For example: ‘equals’ or ‘siblingOf’ is a symmetric property
(if x is siblingOf y, then y is siblingOf x)
 Symmetric properties must be declared as such
P rdf : type owl:SymmetricProperty.
 The inference for a symmetric property is as follows:
P owl:inverseOf P.
 That is, the symmetric property is an inverse property.
owl:transitiveProperty
 In mathematics, a relation is said to be transitive
if P(a,b) and P(b,c) implies P(a,c). This is represented by
the owl:transitiveProperty, which applies to a property.
P
rdf : type
owl : TransitiveProperty.
 The inference for this property is as follows:
IF
x P y. y P z.
THEN x P z.
C part of B
B
A
C
B part of A
FaultBend
x
P
C part of A.
FaultSegment
P
y
Fault
z
partOf
partOf
FaultBend
x
partOf
FaultSegment
y
Fault
z
 The partOf property (containment) may be transitive (not
always). Finger is part of hand, and hand is part of body
 However, someone’s hand is not part of the group to which
the person is part of
 Geologically, being fractal, faults have segments that have
smaller fault segments, which have even smaller segments
which are themselves fault
struc:FaultSegment struc:part of struc: FaultSegment.
struc:partOf
rdf :type
owl:TransitiveProperty.
struc:FaultSegment rdfs:subClassOf
struc:Fault.
Transitive partOf
partOf owl:inverseOf hasPart
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about=":Fault">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":FaultSegment“>
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":partOf"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#TransitiveProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":FaultSegment"/></rdfs:domain>
<rdfs:domain><rdf:Description rdf:about=":FaultBend"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Fault"/></rdfs:range>
</rdf:Description>
<rdf:Description rdf:about=":FaultBend"><rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":hasPart">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Fault"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":FaultSegment"/></rdfs:range>
<owl:inverseOf><rdf:Description rdf:about=":partOf"/></owl:inverseOf>
</rdf:Description>
</rdf:RDF>
locatedIn is
transitive
B
A
C
C locatedIn B B locatedIn A C locatedIn A
geo:locatedIn
rdf:type
owl:TransitiveProperty.
If
tect:SanAndreasFault
geo:California
geo:locatedIn geo:California.
geo:locatedIn geo:United States.
Then
geo:SanAndreasFault
geo:locatedIn
geo:United States.
owl:functionalProperty
x
x
x
x
y
 A functional property p (e.g., hasBiologic Mother) can only
have one unique value y for a particular individual x
 That is, there is a single value of y for a given x as is for a
mathematical function:
 Function y=x2 has a square which is unique for each
input x
 Given x (subject individual) we can find y (object
individual) i.e., x  y
 A functional property is therefore one for which there
is only one value!
 There could be many x (e.g., children; samples),
but all relate only to one y (Mother; Sampler)
 Functional properties have a global cardinality constraint
Inference
 The owl:FunctionalProperty can only take one value for
any individual, allowing sameness to be inferred
 The inference rule for this construct is as follows:
If
P rdf:type owl:FunctionalProperty.
XPA
XPB
Then
A owl:sameAs B.
…
 A property p is functional if x p y1 and x p y2 imply that
y1 = y2 i.e., the two object individuals are the same
(owl: sameAs)
 The subjects are not asserted to be the same;
only the objects are the same
 For example: mineral type is a functional property
min:hasType rdf:type owl:FunctionalProperty.
min:mineral1 min:hasType min:pyr.
min:mineral 1 min:hasType min:pyroxene.
min:pyr owl:sameAs min:pyroxene.
Isotope daughterOf isotope
 sampleLocation and samplerOf are functional properties,
because x sampleLocation y or x samplerOf y has one unique
value y for each x (i.e., location for a sample or person who
owl:FunctionalProperty
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about=":Sample">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":Location">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":sampleLocation">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#FunctionalProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Sample"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Location"/></rdfs:range>
</rdf:Description>
<rdf:Description rdf:about=":Geologist">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":samplerOf“>
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#FunctionalProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Geologist"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Sample"/></rdfs:range>
</rdf:Description>
</rdf:RDF>
Inverse Functional Property
 This property, which is the inverse of the
owl:FuncationalProperty, is very useful for merging data from
different sources
 The owl:FunctionalProperty and owl:InverseFuncationalProperty
allow merging data for a same individual from different sources
 The owl:InverseFunctionalProperty is equivalent to the key in
relational databases, such as SSN and driving license number
 The inference rule of this construct is as follows:
P rdf:type owl:InverseFunctionalProperty.
A P X.
B P X.
Then
A owl:sameAs B.
owl:InverseFuncationalProperty
 If x p y, and p is inverse functional, then there can be only a
single value of x for a given y, that is
 The object individual y of an owl:InverseFunctionalProperty p
uniquely determines a single subject individual x
 Given the object individual (y), we can find a unique subject
individual (x) (i.e., x y-1)
y
x
y
y
 In this case, if x1 p y and x2 p y, then x1 and x2 are the same!
 e.g., Isotope parentOf isotope
 e.g., hasSingleAuthorArticle: a person may have many
published papers (objects), but all are authored by one
author (subject).
Person
hasSingleAuthorArticle
SingleAuthorArticle
 Given a singleAuthorArticle object individual (y) we can find a
hasSingleAuthorPaper
…
Author
Article
 A single value of the property (object y) cannot be
shared by two x subject entities, e.g., describes as in
Geologist describes ThinSection
Geologist
describes
ThinSection
 Declaring a property to be inverse functional, puts a
global cardinality constraints on the property
 Datatype properties cannot be declared inverse-
functional in OWL DL
Example
Station
locatedAt
Location
 Assume location of any measurement is uniquely
identified by the longitude and latitude (defined by
Location class), i.e., no two samples can be taken at
the same exact spot
:Station134 : locatedAt : LocationA.
:Station346 : locatedAt : LocationA.
 We infer that
:Station134 owl : sameAs :Station346
One-to-one Property
x
y
 For a one-to-one relationship, we use a combination of the
owl:FunctionalProperty and owl:inverseFunctionalProperty.
 Note: Sample sampleId XSD:Integer is not a good example,
because it is a datatype property, and not every number
gives you the sample
Sample
:hasimage
:hasImage
:hasImage
:hasImage
X
sampleId
XSD:Integer
rdfs:domain :ThinSection.
rdfs:range :Image.
rdf:type owl:FunctionalProperty.
rdf:type owl:InverseFuncationalProperty.
 So, any two thin sections with the same image must be the
same thin section!
ThinSection
hasImage
Image
 Note that not every functional property can also be an
inverse functional property
 For example, mineral composition can be functional only,
because every mineral has a unique composition, but
many individuals can share that same composition (if they
belong to the same class) (compare with hasFather)
 Some properties can only be inverse functional, but not
functional
 For example, a single-author publication of an author (or
description of an outcrop or a thin section by one person)
may be inverse functional, because it only belongs to one
person
◦ The person can have several such publications or descriptions
owl:equivalentProperties
folds
owl:equivalentProperty
 Already we have learned about asserting that
two properties behave in the same way
buckles
 To make two properties equivalent, we do exactly as we did to
make to classes equivalent (by using rdfs:subclassOf), i.e., use the
rdfs:subPropertyOf twice or using owl:equivalentProperty
 e.g., make the folds and buckles properties equivalent:
struc : folds rdfs : subPropertyOf
struc : buckles rdfs : subPropertyOf
:buckles.
struc:folds.
 This can also be done with the owl:equivalentProperty:
struc:folds
owl:equivalentProperty
struc : buckles.
One-to-one hasImage Property
<rdf:Description rdf:about=":hasImage">
<rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/></rdf:type>
<rdf:type><rdf:Description
rdf:about="http://www.w3.org/2002/07/owl#FunctionalProperty"/></rdf:type>
<rdf:type><rdf:Description
rdf:about="http://www.w3.org/2002/07/owl#InverseFunctionalProperty"/></rdf:type>
<rdfs:domain> <rdf:Description rdf:about=":ThinSection"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":Image"/></rdfs:range>
</rdf:Description>
<rdf:Description rdf:about=":ThinSection">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":Image">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
</rdf:RDF>
shortening
Example
folds
Bedding
equivalentProperty
buckles
 Which means any triple using the ‘folds’ property, can use
its equivalent property ‘buckles’
struc:Shortening
struc:shortening
struc:folds
struc:Bedding.
struc:buckles struc:Bedding.
 Note:
owl:equivalentProperty rdf:type owl : symmetricPropert
Combining Properties
 Writing procedures or modeling processes, for example in a
laboratory experiment, workflow management, and modeling
geological processes, we commonly combine several types of
properties (e.g., inverseOf, transitiveProperty, subPropertyOf )
 In such cases, some activities may depend on the
completion of others
 For example, making thin section may require the following
steps, each may depend on the completion of others. Here is the
workflow:
Slice the rock specimen, square the slice into chip, polish
the chip to fine grit, mount the chip to slide, cut and polish
the section, and finally, mount with cover slide
Workflow
 Since these steps are in order, then each step may
enable the next step, or each step depends or requires
the previous step:
makeChip
polishChip
mountChip
sliceSpecimen
polishSection
putCoverSlide
dependsOn or requires
enables
code
: dependsOn owl: inverseOf :enables
: sliceSpecimen : enables : makeChip.
: makeChip : enables : polishChip.
: polishChip : enables : mountChip.
: mountChip : enables : polishSection.
: polishSection : enables : putCoverslide.
: dependsOn rdfs : subPropertyOf : requires.
: requires rdf : type owl : TransitiveProperty.
: enables rdfs : subPropertyOf : requiredFor.
: requiredFor rdf : type owl : TransitiveProperty
 From the above statements we infer the following requirements
for ‘mountChip’:
: mountChip : requires : polishChip;
: requires : makechip;
: requires : sliceSpecimen.
OWL Class
 OWL allows constructing complex classes using
restrictions of the properties of existing classes
 It also includes:
owl:disjointWith, owl:Thing, owl:Nothing,,
owl:equivalentClass, owl:one of, owl:intersectionOf,
owl:union, and owl:complementOf
Declaring classes in OWL
 An owl class is defined in two different ways:
<owl:Description rdf:about=“ClassName”>
<rdf:type rdf:resource=“&owl;Class”>
</owl:Description>
 Or in short hand, using the owl:Class constructor
<owl:Class rdf:about=“className”/>
Or
<owl:Class rdf:ID=“name”/>
Owl uses the rdfs:subClassOf
 This is used to create class a hierarchy
 rdfs:subClassOf is transitive
<owl:Class rdf:about=“StrikeSlipFault”>
<rdfs:subClassOf rdf:resource=“Fault”/>
<owl:Class>
 Every owl class is a subclass of the owl:Thing
owl:disjointWith
 Two classes can be declared to be disjoint if they
cannot have a common instance
 i.e., their intersection is empty
 For example:
 Solid and Liquid; Solid and Gas
 Inorganic and Organic
 Crystalline and Amorph
 Mineral and Gas, Mineral and Organic
Mineral is naturally occurring, inorganic, solid, crystalline
substance with definite chemical composition.
It is disjoint with amorph, artificial, gas, and organic substances.
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about=":Mineral">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
<owl:disjointWith><rdf:Description rdf:about=":Amorph"/></owl:disjointWith>
<owl:disjointWith><rdf:Description rdf:about=":Artificial"/></owl:disjointWith>
<owl:disjointWith><rdf:Description rdf:about=":Gas"/></owl:disjointWith>
<owl:disjointWith><rdf:Description rdf:about=":Organic"/></owl:disjointWith>
<owl:disjointWith><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></owl:disjointWith>
</rdf:Description>
<rdf:Description rdf:about=":Amorph">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdfs:comment>the Artificial, Gas, and Organic classes here</rdfs:comment>
<rdf:Description rdf:about=":hasComposition">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#DatatypeProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Mineral"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about="http://www.w3.org/2001/XMLSchema#string"/></rdfs:range>
</rdf:Description>
</rdf:RDF>
owl:Thing (Τ)
owl:Nothing ()
 OWL has two predefined classes: owl:Thing and
owl:Nothing
 All individuals are members of the owl:Thing
 Owl:Thing is the top, most general class, and represents
the universe, which means all individuals are its
instances
 Owl:Nothing has no instance
 Because the intersection of two disjoint sets is empty,
it is represented by the owl:Nothing
Intersection (п) of two disjoint classes
that subclass owl:Thing is owl:Nothing
<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntaxns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
<rdf:Description rdf:about=":Liquid">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
<rdfs:subClassOf><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Thing"/></rdfs:subClassOf>
<owl:disjointWith><rdf:Description rdf:about=":Solid"/></owl:disjointWith>
</rdf:Description>
<rdf:Description rdf:about=":MyNothing">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
<owl:intersectionOf rdf:parseType="Collection">
<rdf:Description rdf:about=":Solid"/>
<rdf:Description rdf:about=":Liquid"/>
</owl:intersectionOf>
</rdf:Description>
<rdf:Description rdf:about=":Solid">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
<rdfs:subClassOf><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Thing"/></rdfs:subClassOf>
</rdf:Description>
</rdf:RDF>
Set Equivalence () by owl:equivalentClass
 When we want to assert that two URIs refer to the same thing, we use
owl:equivalentClass
<owl:Class rdf:about=“SaturatedZone”>
<owl:equivalentClass rdf:resource=“ZoneOfSaturation”/>
</owl:Class>
:XRD
struc:Joint
owl:equivalentClass
owl:equivalentClass
:XRayDiffraction.
struc:TensileFracture.
 We can also make two classes to be equal if we make each a subclass of the
other, for example, if we want to say that a joint is the same thing as a
tensile fracture, we assert:
struc:Joint
struc:TensileFracture
rdfs:subClassOf
rdfs:subClassOf
struc:TensileFracture.
struc:Joint.
Inference for owl:equivalentClass
A owl:equivalentClass B.
x rdf:type A
then
x rdf:type B

A
B
x
x=y
 Moreover, from the subClassOf property we additionally infer that
the two classes have exactly the same members:
A rdfs:subClassOf B.
x rdf:type B.
then
x rdf:type A.
 Notice that:
owl:equivalentClass
rdfs:type owl:SymmetricProperty.
owl:one of
x1,…, xn
 Allows defining a class by enumerating its member,
using owl : one of
 Enumeration is a list of options that a user can select
from
 The list is usually exhaustive, like the list of planets,
types of rock or minerals, names of oceans
{Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune}
<rdf:Description rdf:about=":SolarPlanet">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
<owl:oneOf rdf:parseType="Collection">
<rdf:Description rdf:about=":Mercury"/>
<rdf:Description rdf:about=":Venus"/>
<rdf:Description rdf:about=":Earth"/>
<rdf:Description rdf:about=":Mars"/>
<rdf:Description rdf:about=":Jupiter"/>
<rdf:Description rdf:about=":Saturn"/>
<rdf:Description rdf:about=":Uranus"/>
<rdf:Description rdf:about=":Neptune"/>
</owl:oneOf>
<rdfs:comment>Declare each planet as an instance of the SolarPlanet</rdfs:comment>
</rdf:Description>
<rdf:Description rdf:about=":Mercury">
<rdf:type><rdf:Description rdf:about=":SolarPlanet"/></rdf:type>
</rdf:Description>
<rdfs:comment>…</rdfs:comment>
<rdf:Description rdf:about=":Sun">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/></rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":hasPlanet">
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#ObjectProperty"/>
</rdf:type>
<rdf:type><rdf:Description rdf:about="http://www.w3.org/2002/07/owl#FunctionalProperty"/></rdf:type>
<rdfs:domain><rdf:Description rdf:about=":Sun"/></rdfs:domain>
<rdfs:range><rdf:Description rdf:about=":SolarPlanet"/></rdfs:range>
</rdf:Description>
Individuals
 These are instances of physical or virtual types, i.e.,
same type individuals are members of the same class
 Any individual belongs to the owl:Thing class
 An individual can belong to one or more classes
 Individuals may be assigned to a class as follows:
<rdf:Description rdf:about=“instanceName”>
<rdf:type rdf=resource=“ClassName”>
<rdf:Description>
Short form of class assignment
 Alternatively, we can instantiate a class as:
<ClassName rdf:about=“instanceName”/>
<Fault rdf:about=“SanAndreasFault”/>
 Or, use the rdf:ID
<owl : Thing
rdf:ID = “ZagrosFault”/>
<owl : Person
rdf:ID = “Babaie”/>
 Or we can do it using rdf:type as shown on next slide!
 These statements say that the ZagrosFault is a Thing,
and Babaie is of type Person
Instantiating and individual
<?xml version="1.0" encoding="UTF-8"?>
<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#">
<rdf:Description rdf:about=":Mineral">
<rdf:type>
<rdf:Description rdf:about="http://www.w3.org/2002/07/owl#Class"/>
</rdf:type>
</rdf:Description>
<rdf:Description rdf:about=":Mineral1">
<rdf:type><rdf:Description rdf:about=":Mineral"/></rdf:type>
</rdf:Description>
</rdf:RDF>
Same Individuals (owl:sameAs)
 In many cases we want to assert that two things are actually the same
 For example, two samples with different numbers may actually be the
same, or two faults with different names may actually be the same
fault
<Fault rdf:about=“SanAndreasFault”/>
<Fault rdf:about=“SanAndreasShearZone”/>
<rdf:Description rdf:about “SanAndreasFault”>
<owl:sameAs rdf:resource=“SanAndreasShearZone”/>
</rdf:Description>
 For example, Zagros Fault, Zagros shear zone, Zagros Crash zone,
Zagros Thrust
geochem:sample1
owl:sameAs
struc:sample22.
tect:ZagrosFault owl:sameAs
struc:ZagrosShearZone.
Inference
 Notice that owl:sameAs is a symmetric Property:
owl:sameAs rdf : type owl:SymmetricProperty.
 Therefore, we can infer that:
struc:sample22
owl:sameAs geochem:sample1.
struc:ZagrosShearZone owl:sameAs tect:ZagrosFault.
owl:differentFrom
 Is used to declare that individuals are mutually different
 It uses owl:distinctMembers and
rdf:parseType=“Collection” to represent an exhaustive list
<owl:differentFrom>
<owl:distinctMembers rdf:parseType=“Collection”>
<Fault rdf:about=“BrevardFault”/>
<Fault rdf:about=“TowaligaFault”/>
</owl:distinctMembers>
</owl:differentFrom>
Merging Different Databases w/ owl:sameAs
 The owl:sameAs is very useful when merging data from
different databases
 For example, let’s assume that the following ‘Sample’ and
‘Sampling’ tables (next slide) are from two autonomous relational
databases
 As we can see, some concepts are named differently in the two
databases. We want to merge data from the two tables
 Recall that in a relational database, every row is a record of an
individual
 The Sample table has 6 rows and 6 columns, which means that we
can extract 36 triples from this table
 The Sampling table has 8 columns and 6 rows, yielding 48 triples
Sample Table
SAMPLE (Petrology Database)
Sample ID
1
2
3
4
5
6
Sample
Number
N100
N110
N120
N130
N140
N150
Paleont
Age
Miocene
Miocene
Oligocene
Rock
Basalt
Limestone
Limestone
Basalt
Shale
Gabbro
Absolute
Age
75 Ma
73 Ma
70 Ma
Researcher
Babaie
Babaie
Babaie
Babaie
Babaie
Babaie
Make the Triples
 To make the triples, we use the namespace for each group
(e.g., ‘petr’ for the petrology, and ‘tect’ for the tectonics
domains)
 Every cell of each table is a triple, with subject (individual
corresponding to the row) designated with the namespace
and table name attached to the id of the row
 The predicate for each triple is designated with the
namespace and table name attached to field name for the
corresponding cell
 The object is the content of the corresponding cell
Some of the triples are shown below
 Triples for the first row shown below (only triples of two rows
are shown):
petr : Sample1 petr : Sample_Sample_Number N100.
petr : Sample1 petr : Sample_Paleont_Age “”.
Petr : Sample1 petr : Sample_Rock Basalt.
petr : Sample1 petr : Sample_Absolute_Age 75 Ma.
petr : Sample1 petr : Sample_Researcher Babaie.
petr : Sample2 petr : Sample_Sample_Number N110.
petr : Sample2 petr : Sample_Paleont_Age “Miocene”.
Petr : Sample2 petr : Sample_Rock Limestone.
petr : Sample2 petr : Sample_Absolute_Age “”.
petr : Sample2 petr : Sample_Researcher Babaie.
…
SAMPLING (Tectonics Database)
ID
Sample
Number
Region
Sampling
Date
N130
Neyriz
11/2/2007
1
2
N150
Neyriz
11/6/2007
3
N100
Neyriz
11/6/2007
N120
Neyriz
11/3/2007
N140
Neyriz
11/3/2007
N110
Neyriz
11/5/2007
4
5
6
Project
Neyriz
Ophiolite
Neyriz
Ophiolite
Neyriz
Ophiolite
Neyriz
Ophiolite
Neyriz
Ophiolite
Neyriz
Ophiolite
Investigator
Babaie
Babaie
Babaie
Babaie
Babaie
Babaie
Map
Name
Neyriz
1:24000
Neyriz
1:24000
Neyriz
1:24000
Neyriz
1:24000
Neyriz
1:24000
Neyriz
1:24000
Isotopic
Age
73 Ma
70 Ma
75 Ma
 RDF triples for the Sampling table
(only triples of two rows are shown):
tect : Sample1
tect : Sample1
tect : Sample1
tect : Sample1
tect : Sample1
tect : Sample1
tect : Sample1
tect : Sampling_Sample_Number N130.
tect : Sampling_Region Neyriz.
tect : Sampling_Sampling_Date 11/2/2007.
tect : Sampling_Project Neyriz Ophiolite.
tect : Sampling_Investigator Babaie.
tect : Sampling_Map_Name Neyriz 1:24000.
tect : Sampling_Isotopic_Age 73 Ma.
tect : Sample2
tect : Sample2
tect : Sample2
tect : Sample2
tect : Sample2
tect : Sample2
tect : Sample2
tect : Sampling_Sample_Number N150.
tect : Sampling_Region Neyriz.
tect : Sampling_Sampling_Date 11/6/2007.
tect : Sampling_Project Neyriz Ophiolite.
tect : Sampling_Investigator Babaie.
tect : Sampling_Map_Name Neyriz 1:24000.
tect : Sampling_Isotopic_Age 70 Ma.
…
Mapping the Databases
 We need to map the two tables to each other using some
of the rdfs and owl construct if we want to run a federated
query on the two tables
 Because the records (rows) in each table are actually
individual data, we use the owl:sameAs to assert that some
individuals are the same

 Notice that sample number 130 is in the 4th row for the
Sample table, but is in the 1st row of the Sampling table
(same situation for other samples)
The merging assertions:
petr : Sample1 owl : sameAs tect : Sample3.
petr : Sample2 owl : sameAs tect : Sample6.
petr : Sample3 owl : sameAs tect : Sample4.
petr : Sample4 owl : sameAs tect : Sample1.
petr : Sample5 owl : sameAs tect : Sample5.
petr : Sample6 owl : sameAs tect : Sample2.
Boolean class constructors
 OWL provides Boolean constructors such as
owl:intersectionOf, owl:unionOf, and owl:complementOf
to allow modeling complex knowledge
 These constructors represent logical
 and (, conjunction)
 or (, disjunction)
 not (, negation)
 The purpose of these constructors is to combine
simple classes into more complex classes with
increased expressivity
owl:intersectionOf (AпB)
 The class defined by the intersection of two classes
contains instances of both classes
<owl:Class rdf:about=“Semibrittle”>
<owl:intersectionOf rdf:parseType=“Collection”>
<owl:Class rdf:about=“Brittle”/>
<owl:Class rdf:about=“Ductile”/>
</owl:intersectionOf>
</owl:Class>
Owl:unionOf (A U B)
 The class defined by the union of two classes has
instances of either or both classes
<owl:Class rdf:about=“Migmatite”>
<owl:unionOf rdf:parseType=“Collection”>
<owl:Class rdf:about=“MetamorphicRock”/>
<owl:Class rdf:about=“IgneousRock”/>
</owl:unionOf>
</owl:Class>
We can use the owl:intersectionOf and owl:unionOf
constructor s with the owl:subClassOf as in next slide for the
case of owl:complementOf
owl:complementOf (~A)
 The complement of a class contains no instance of the class
 For example, the complement of Fault contains instances
of Cat, Fruit, and River
<owl:Class rdf:about=“Land”>
<owl:subClassOf >
<owl:Class>
<owl:complementOf rdf:resource=“BodyOfWater”>
</owl:Class>
</owl:complementOf>
</owl:Class>
Even though this looks correct, but it is not , because the
instances of the Land class can include
Combination of Boolean constructors
 A better definition of the Land class may, for example,
be defined by first defining a class (e.g., SolidGround)
that annotates all land features, such as continents,
islands, and then declare Land at the intersection of
this class and the complement of the BodyOfWater
class
See next slide

<?xml version="1.0" encoding="UTF-8"?>
<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#">
<owl:Class rdf:about=":Land">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class>
<owl:complementOf rdf:resource=":BodyOfWater"/>
</owl:Class>
<owl:Class rdf:about=":SolidGround"/>
</owl:intersectionOf>
</owl:Class>
<owl:Class rdf:about=":BodyOfWater"/>
</rdf:RDF>
owl.disjointUnionOf
 OWL 2 DL’s owl.disjointUnionOf defines a class
as the union of other classes, all of which are pairwise disjoint
 It is a shorthand for separate axioms making the classes
pairwise disjoint and one setting up the union class
 For example, we can define Mesozoic as the disjointUnionOf
Triassic, Jurassic, and Cretaceous:
<owl.Class rdf:about=“Mesozoic”>
<owl.disjointUnionOf rdf:parseType=“Collection”>
<owl:Class rdf:about=“Cretaceous”/>
<owl:Class rdf:about=“Jurassic”/>
<owl:Class rdf:about=“Triassic”/>
</owl:disjointUnionOf>
</owl.Class
owl:AlldisjointClasses
 OWL 2 also defines the owl:AlldisjointClasses to
collectively define a set of classes as mutually disjoint
 Use the owl:members and rdf:parseType=“Collection”
<owl:AllDisjointClasses>
<owl:members rdf:parseType=“Collection”>
<owl:Class rdf:about=“Cretaceous”/>
<owl:Class rdf:about=“Jurassic”/>
<owl:Class rdf:about=“Triassic”/>
</owl:members>
</owl:AllDisjointClasses>
Other alternative ways
 We can also use OWL 1 and mutually define the Triassic,
Jurassic, and Cretaceous periods as disjoint, with the
owl:disjointWith
<owl:Class rdf:about=“Cretaceous”/>
<owl:Class rdf:about=“Jurassic”/>
<owl:disjointWith rdf:resource=“Cretaceous”/>
</owl:Class>
 Or we can define the Cretaceous, Jurassic, and Triassic
classes as disjoint, and then find the union of these
disjoint sets (see owl code below), which is equivalent to
the owl 2.0 disjointUnionOf shortcut
Example: Laramide Orogeny
 The Laramide orogeny in Montana and Wyoming occurred
during the Late Cretaceous and Eocene (i.e., some
processes occurred in either Cretaceous or Eocene, which
are disjoint)
 The two periods have no intersection!
 Let’s define time:LateCretaceousEocene (may be defined in
the Time ontology) using the owl.disjointUnion, that
occurred either in Cretaceous or in Eocene, but not in their
intersection (i.e., A xor B)
 AxorB: Exclusive disjunction or exclusive or:
One or the other, but not both (red is true in the image),
and is false if neither or both are true
N3 Code for Laramide Orogeny
owl:disjointUnionOf (time:LateCretaceousEocene time:Cretaceous
time:Eocene).
 Assuming that we have the LateCretaceousEocene class:
tect:Laramide
tect: Laramide
time:intervalFor
rdf : type
tect:Orogeny.
time:occurredIn time:LateCretaceousEocene.
owl.inverseOf
time :occurredInInterval.
 We infer that:
time : LateCretaceousEocene intervalFor
tect : Laramide
 Query: Which orogeny occurred in Late Cretaceous-Eocene?):
?orogeny
time : occurredInInterval
 Will return Laramide
time : LateCretaceousEocene.
LateCretaceousEocene
<owl.Class rdf:about=“LateCretaceousEocene”>
<owl.disjointUnionOf rdf:parseType=“Collection”>
<owl:Class rdf:about=“Eocene”/>
<owl:Class rdf:about=“Cretaceous”/>
</owl:disjointUnionOf>
</owl.Class
<owl:Class rdf:about=“LaramideOrogeny”/>
<owl:objectProperty rdf:about=“occurredIn”/>
<rdfs:domain rdf:resource=“LaramideOrogeny”
<rdfs:range rdf:resource =“LateCretaceousEocene”>
Property Restriction
 OWL allows modifying the description of an existing class
C to include a restriction R (based on some property P) on
members of the class
 Restriction in OWL is a class (owl:Restriction), meaning
that it has individual members which are constrained by
modified properties
 The individuals that satisfy R, do not have to be members
of C (they could be in an unnamed class), because R
defines a necessary but not sufficient condition for
membership in C
owl : Restriction rdfs : subClassOf owl : Class.
Example
 A restriction limits the things that can be said (i.e., the
values for its properties) about an individual of a class
 This means that a class may be modified by constraining the
possible values for its properties
 For example, assume that we have the Fold class, which has a
property called limb, and another property called
intersectsAlong, which is a subproperty of the intersects property
 The intersectsAlong can mean intersect along anything
 However, we want to say that the limb of the fold intersects the
axial plane of the fold along the fold axis. Thus, we want to
restrict the intersectsAlong property of the Fold class to have a
fold axis range
 Since we are constraining the values for properties, we use the
keyword: owl:onProperty when we want to limit the way a property is
used for the restricted class. For example, if we are constraining the
use of the intersectsAlong property of the Fold class, we write:
owl:onProperty intersectsAlong.
 Property restrictions are done using the following format:
1
2
3
4
5
6
7
8
9
10
<owl:Class rdf:about = “C”>
…
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource = “P”>
… R (restrictions here)
</owl : Restriction
</rdfs:subClassOf>
…
</owl:Class>
Line 3 indicates that C is a subclass of an unnamed restriction class
(defined in lines 4-7), that satisfies R.
Types of Restriction
 Restrictions in OWL may be of three types:
quantified, cardinality, and value (filter information)
 A quantified restrictions may be:
 Existential () declared with the
owl : someValuesFrom
 Universal (), declared with
owl : allValuesFrom or owl:hasValue
Quantified Restriction
Existential owl:someValuesFrom
 This restriction says: “All individuals for which at least
one (some) value of the property P comes from class
C.”
 This means that there is at least one member of
the class with the P property
C
P
Example
 We would like to make a new restricted REE (Rare
Earth Elements) class out of existing Analysis and
RareEarth classes, by constraining the REE class to
contain only individuals, at least one of which is a rare
earth (this can better be done by defining what the
REE are with a different restriction!)
<owl:Class rdf:about = “REE”>
<rdfs:subClassOf rdf:resource = “Analysis”/>
<owl:Restriction>
<owl:onProperty rdf:resource = “elements”/>
<owl:someValuesFrom rdf:resource = “RareEarth”/>
</owl:Restriction
</rdfs:subClassOf>
</owl:Class>
Restricted
REE class
Example: courses taught at GSU
 Assume that we have the two existing classes: Course and GSU, and
we want to define a new restricted class called GSUCourse from the
Course class
 So, we declare GSUCourse a subclass of Course, and constrain it
with an unnamed Restriction class
 Assume that an existing property called ‘taughtIn’ is defined for the
Course class. The GSUCourse restricted class can only have
individuals some of which are taughtIn GSU
<owl : Class rdf : about = “GSUCourse”>
<rdfs : subClassOf rdf : resource = “Course”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “taughtIn”/>
<owl : someValuesFrom rdf : resource = “GSU”/>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>
Quantified Restriction
Universal owl:allValuesFrom
 This produces a restriction class that says:
“the individuals for which all values of the property P
come from class C.”
 This means that if there are any members, then they
all must have this property P
Example: Planar Structure
<owl:Class rdf:about =“PlanarStructure”>
<rdfs:subClassOf rdf:resource = “Structure”/>
<owl:Restriction>
<owl:onProperty rdf:resource =“attitude”/>
<owl:allValuesFrom rdf:resource =“PlanarAttitude”/>
</owl:Restriction
</rdfs:subClassOf>
</owl:Class>
Example: XRF Analysis
 Assume that we have defined the Analysis and XRF classes
before
 We would like to define a new restricted class constrained
to have all of its individuals be of type XRF
<owl : Class rdf : about = “XRFAnaysis”>
<rdfs : subClassOf rdf : resource = “Analysis”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “typeOfAnalysis”/>
<owl : allValuesFrom rdf : resource = “XRF”/>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>
Cardinality Restriction (Constraint)
 Cardinality restriction imposes a limit on the number
of occurrences of property P that each member of a
class C can have
◦ i.e., it provides constraints on the number of individuals that
can be related to a member of a restriction class
 Cardinality restriction can be used to create special sets

 Exact cardinality restriction, declared by
owl : cardinality, defines the exact number of
occurrences of property P for members of class C
 For example, every mineral may have exactly one refractive
index
Example: Single Authored publication
<owl : Class rdf : about = “SingleAuthorPublication”>
<rdfs : subClassOf rdf : resource = “Publication”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “hasAuthor”/>
<owl : cardinality
rdf : datatype = “&xsd;nonNegativeInteger”> 1
<owl : cardinality>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>
Max or min cardinality restrictions
 Are declared with maxCardinality or minCardinality, and give
the maximum or minimum number of occurrences of
property P for members of class C
 Example: A box fold can have at least two axes.
<owl : Class rdf : about = “BoxFold”>
<rdfs : subClassOf rdf : resource = “Fold”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “axis”/>
<owl : minCardinality
rdf : datatype = “&xsd;nonNegativeInteger”> 2
<owl : mincardinality>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>
Hydrogen has a maximum of three isotopes
<owl : Class rdf : about = “HydrogenIsotope”>
<rdfs : subClassOf rdf : resource = “Isotope”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “numberOfIsotopes”/>
<owl : maxCardinality
rdf : datatype = “&xsd;nonNegativeInteger”> 3
<owl : maxcardinality>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>
Value Restriction (Filter Information)
owl : hasValue
 This is a special case of owl : someValueFrom restriction
in which the class C is a singleton set {A}
 It imposes a limit on the values the occurrences of
property P may have
 This kind of restriction applies to cases in which we
want to say: “all individuals that have the value A
for the property P”.
Planets that orbit around the sun
 Assume ‘orbits’ has a Planet domain and an XSD string
range
<owl : Class rdf : about = “PlanetOrbitingSun”>
<rdfs : subClassOf rdf : resource = “Planet”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “orbits”/>
<owl : hasValue rdf : resource = “Sun”/>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>
Zagros folds are those located in
the Zagros Range
<owl : Class rdf : about = “ZagrosFold”>
<rdfs : subClassOf rdf : resource = “Fold”/>
<owl : Restriction>
<owl : onProperty rdf : resource = “locatedIn”/>
<owl : hasValue rdf : resource = “ZagrosRange”/>
</owl : Restriction
</rdfs : subClassOf>
</owl : Class>