The OWL Web Ontology Language is designed for use by
applications that need to process the content of information
instead of just presenting information to humans. OWL
facilitates greater machine readability of Web content than
that supported by XML, RDF, and RDF Schema by providing
additional vocabulary along with a formal semantics. OWL has
three increasingly-expressive sublanguages: OWL Lite, OWL DL,
and OWL Full.

This document is written for readers who want a first
impression of the capabilities of OWL. It provides an
introduction to OWL by informally describing the features of
each of the sublanguages of OWL. Some knowledge of RDF Schema is
useful for understanding this document, but not essential.
After this document, interested readers may turn to the OWL
Guide for a more detailed descriptions and extensive
examples on the features of OWL. The normative formal
definition of OWL can be found in the OWL
Semantics and Abstract Syntax.

This is a non-normative overview of OWL; it does not provide
a definitive specification of OWL. The examples and other
explanatory material herein are provided to help understand OWL,
but may not always provide definitive or complete answers. The
normative formal definition of OWL can be found in the OWL
Semantics and Abstract Syntax.

This section describes the status of this document at
the time of its publication. Other documents may supersede
this document. A list of current W3C Recommendations and
other technical reports is available at http://www.w3.org/TR/.

1. Introduction

This document describes the OWL Web Ontology Language. OWL
is intended to be used when the information contained in
documents needs to be processed by applications, as opposed to
situations where the content only needs to be presented to
humans. OWL can be used to explicitly represent the meaning of
terms in vocabularies and the relationships between those
terms. This representation of terms and their
interrelationships is called an ontology. OWL has more
facilities for expressing meaning and semantics than XML, RDF,
and RDF-S, and thus OWL goes beyond these languages in its
ability to represent machine readable content on the Web. OWL
is a revision of the DAML+OIL web
ontology language incorporating lessons learned from the
design and application of DAML+OIL.

1.1 Document Roadmap

The OWL Language is described by a set of documents, each
fulfilling a different purpose, and catering for a different
audience. The following provides a brief roadmap for navigating
through this set of documents:

This Owl
Overview gives a simple introduction to OWL by providing
a language feature listing with very brief feature
descriptions;

The OWL
Guide demonstrates the use of the OWL language by
providing an extended example. It also provides glossary
of the terminology used in these documents;

The OWL
Reference gives a systematic and compact (but still
informally stated) description of all the modelling
primitives of OWL;

The suggested reading order of these documents is as given,
since they have been listed in increasing degree of technical
content.

1.2 Why OWL?

The Semantic Web is a vision for the future of the Web in
which information is given explicit meaning, making it easier
for machines to automatically process and integrate information
available on the Web. The Semantic Web will build on XML's
ability to define customized tagging schemes and RDF's flexible
approach to representing data. The first level above RDF
required for the Semantic Web is an ontology language what can
formally describe the meaning of terminology used in Web
documents. If machines are expected to perform useful reasoning
tasks on these documents, the language must go beyond the basic
semantics of RDF Schema. The OWL Use Cases and
Requirements Document provides more details on
ontologies, motivates the need for a Web Ontology Language
in terms of six
use cases, and formulates design
goals, requirements
and objectives
for OWL.

OWL has been designed to meet this need for a Web Ontology
Language. OWL is part of the growing stack of W3C
recommendations related to the Semantic Web.

XML provides a
surface syntax for structured documents, but imposes no
semantic constraints on the meaning of these documents.

XML Schema is
a language for restricting the structure of XML
documents.

RDF
is a datamodel for objects ("resources") and relations
between them, provides a simple semantics for this
datamodel, and these datamodels can be represented in an
XML syntax.

RDF
Schema is a vocabulary for describing properties and
classes of RDF resources, with a semantics for
generalization-hierarchies of such properties and
classes.

1.3 The three sublanguages of
OWL

OWL provides three increasingly expressive sublanguages
designed for use by specific communities of implementers and
users.

OWL
Lite supports those users primarily needing a
classification hierarchy and simple constraints. For
example, while it 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 OWL Lite provides a quick
migration path for thesauri and other taxonomies.

OWL DL
supports those users who want the maximum expressiveness
while retaining computational completeness (all conclusions
are guaranteed to be computed) and decidability (all
computations will finish in finite time). OWL DL includes
all OWL language constructs, but they can be used only
under certain restrictions (for example, while a class may
be a subclass of many classes, a class cannot be an
instance of another class).
OWL DL is so named due to its correspondence with description logics, a
field of research that has studied the logics that form the
formal foundation of OWL.

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. 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 complete
reasoning for every feature of OWL Full.

Each of these sublanguages is an extension of its simpler
predecessor, both in what can be legally expressed and in what
can be validly concluded. The following set of relations hold.
Their inverses do not.

Every legal OWL Lite ontology is a legal OWL DL
ontology.

Every legal OWL DL ontology is a legal OWL Full
ontology.

Every valid OWL Lite conclusion is a valid OWL DL
conclusion.

Every valid OWL DL conclusion is a valid OWL Full
conclusion.

Ontology developers adopting OWL should consider which
sublanguage best suits their needs. The choice between OWL Lite
and OWL DL depends on the extent to which users require the
more-expressive constructs provided by OWL DL and OWL Full. The
choice between OWL DL and OWL Full mainly depends on the extent
to which users require the meta-modeling facilities of RDF
Schema (e.g. defining classes of classes, or attaching
properties to classes). When using OWL Full as compared to OWL
DL, reasoning support is less predictable since complete OWL
Full implementations do not currently exist.

OWL Full can be viewed as an extension of RDF, while OWL Lite
and OWL DL can be viewed as extensions of a restricted view of
RDF. Every OWL (Lite, DL, Full) document is an RDF document,
and every RDF document is an OWL Full document, but only some
RDF documents wll be a legal OWL Lite or OWL DL document.

1.4 The structure of this
document

This document first describes the features from OWL Lite,
followed by a description from the features that are added in
OWL DL and OWL Full (OWL DL and OWL Full contain the same
features, but OWL Full is more liberal about how these features
can be combined).

2. Language Synopsis

This section provides a quick index to all the language
features for OWL Lite, OWL DL, and OWL Full.

In this document, italicized terms are terms in OWL.
Prefixes of rdf: or rdfs: are used when terms are already
present in RDF or RDF Schema. Otherwise terms are introduced by
OWL. Thus, the term rdfs:subPropertyOf indicates that
subPropertyOf is already in the rdfs vocabulary (technically :
the rdfs namespace). Also, the term Class is more
precisely stated as owl:Class and is a term introduced
by OWL.

3. Language Description of OWL
Lite

This section provides an informal description of the OWL
Lite language features. We do not discuss the specific syntax
of these features (see the OWL Reference for
definitions). Each language feature is hyperlinked to the
appropriate place in the OWL
Guide for more examples and guidance on usage.

OWL Lite uses only some of the OWL language features and has
has more limitations on the use of the features than OWL DL or
OWL Full. ... are also only allowed between named classes, ...
Similarly, restrictions In OWL Lite classes can only be defined
in terms of named superclasses (superclasses cannot be
arbitrary expressions), and only certain kinds of class
restrictions can be used. Equivalence between classes and
subclass relationships between classes are also only allowed
between named classes, and not between arbitrary class
expressions. Similarly, restrictions in OWL Lite use only named
classes. OWL Lite also has a limited notion of cardinality -
the only cardinalities allowed to be explicitly stated are 0 or
1.

3.1 OWL Lite RDF Schema
Features

The following OWL Lite features related to RDF Schema are
included.

Class: A class defines a group of individuals
that belong together because they share some properties. For
example, Deborah and Frank are both members of the class
Person. Classes can be organized in a specialization
hierarchy using SubClassOf.
There is a built-in most general class named Thing that is
the class of all individuals and a superclass of all OWL
classes.

rdfs:subClassOf: Class hierarchies may be created
by making one or more statements that a class is a subclass
of another class. For example, the class Person could be
stated to be a subclass of the class Mammal. From this a
reasoner can deduce that if an individual is a Person, then
it is a Mammal.

rdfs:Property: Properties can be used to state
relationships between individuals or from individuals to data
values. Examples of properties include hasChild, hasRelative,
hasSibling, and hasAge. The first three can be used to relate
an instance of a class Person to another instance of the
class Person (and are thus ObjectProperties), and the last
(hasAge) can be used to relate an instance of the class
Person to an instance of the datatype Integer (and is thus a
Datatype property).

rdfs:subPropertyOf: Property hierarchies may be
created by making one or more statements that a property is a
subproperty of one or more other properties. For example,
hasSibling may be stated to be a subproperty of hasRelative.
From this a reasoner can deduce that if an individual is
related to another by the hasSibling property, then it is
also related to the other by the hasRelative property.

rdfs:domain: A domain of a property limits the
individuals to which the property can be applied. If a
property relates individual to another individual, and the
property has a class as one of its domains, then the
individual must belong to the class. For example, the
property hasChild may be stated to have the domain of Mammal.
From this a reasoner can deduce that if Frank hasChild Anna,
then Frank must be a Mammal. Note that rdfs:domain is
called a global restriction since the restriction is stated
on the property and not just on the property when it is
associated with a particular class. See the discussion below
on local restrictions for more information.

rdfs:range: The range of a property limits the
individuals that the property may have as its value. If a
property relates an individual to another individual, and the
property has a class as its range, then the other indivual
must belong to the range class. For example, the property
hasChild may be stated to have the range of Mammal. From this
a reasoner can deduce that if Louise is related to Deborah by
the hasChild property, i.e., Deborah is the child of Louise,
then Deborah is a Mammal. Range is also a global restriction
as is domain above. Again, see the discussion below on local
restrictions (e.g. AllValuesFrom)
for more information.

Individual : Individuals are instances of
classes, and properties may be used to relate one individual
to another. For example, an individual named Deborah may be
described as an instance of the class Person and the property
hasEmployer may be used to relate the individual Deborah to
the individual StanfordUniversity.

3.2 OWL Lite Equality and
Inequality

The following OWL Lite features are related to equality or
inequality.

equivalentClass : Two classes may be
stated to be equivalent. Equivalent classes have the same
instances. Equality can be used to create synonymous classes.
For example, Car can be stated to be equivalentClass
to Automobile. From this a reasoner can deduce that any
individual that is an instance of Car is also an instance of
Automobile and vice versa.

equivalentProperty: Two properties may be stated
to be equivalent. Equivalent properties relate one individual
to the same set of other individuals. Equality may be used to
create synonymous properties. For example, hasLeader may be
stated to be the equivalentProperty to hasHead. From
this a reasoner can deduce that if X is related to Y by the
property hasLeader, X is also related to Y by the property
hasHead and vice versa. A reasoner can also deduce that
hasLeader is a subproperty of hasHead and hasHead is a
subProperty of hasLeader.

sameIndividualAs: Two individuals may be stated
to be the same. This construct may be used to create a number
of different names that refer to the same individual. For
example, the individual Deborah may be stated to be the same
individual as DeborahMcGuinness.

differentFrom: An individual may be stated to be
different from other individuals. For example, the individual
Frank may be stated to be different from the individuals
Deborah and Jim. Thus, if the individuals Frank and Deborah
are both values for a property that is stated to be
functional (thus the property has at most one value), then
there is a contradiction. Explicitly stating that individuals
are different can be important in when using languages such
as OWL (and RDF) that do not assume that individuals have one
and only one name. For example, with no additional
information, a reasoner will not deduce that Frank and
Deborah refer to distinct individuals.

allDifferent: A number of individuals may be
stated to be mutually distinct in one allDifferent statement.
For example, Frank, Deborah, and Jim could be stated to be
mutually distinct using the allDifferent construct. Unlike
the differentFrom statement above, this would also enforce
that Jim and Deborah are distinct (not just that Frank is
distinct from Deborah and Frank is distinct from Jim). The
allDifferent construct is particularly useful when there are
sets of distinct objects and when modelers are interested in
enforcing the unique names assumption within those sets of
objects.

3.3 OWL Lite Property
Characteristics

There are special identifiers in OWL Lite that are used to
provide information concerning properties and their values.

inverseOf: One property may be stated to be the
inverse of another property. If the property P1 is stated to
be the inverse of the property P2, then if X is related to Y
by the P2 property, then Y is related to X by the P1
property. For example, if hasChild is the inverse of
hasParent and Deborah hasParent Louise, then a reasoner can
deduce that Louise hasChild Deborah.

TransitiveProperty: Properties may be stated to
be transitive. If a property is transitive, then if the pair
(x,y) is an instance of the transitive property P, and the
pair (y,z) is an instance of P, then the pair (x,z) is also
an instance of P. For example, if ancestor is stated to be
transitive, and if Sara is an ancestor of Louise (i.e.,
(Sara,Louise) is an instance of the property ancestor) and
Louise is an ancestor of Deborah (i.e., (Louise,Deborah) is
an instance of the property ancestor), then a reasoner can
deduce that Sara is an ancestor of Deborah (i.e.,
(Sara,Deborah) is an instance of the property
ancestor).
OWL Lite (and OWL DL) impose the side condition that
transitive properties (and their superproperties) cannot have
a maxCardinality 1 restriction. Without this side-condition,
OWL Lite and OWL DL would become undecidable languages. See
the property axiom section of the OWL Abstract Syntax
and Semantics document for more information.

SymmetricProperty: Properties may be stated to be
symmetric. If a property is symmetric, then if the pair (x,y)
is an instance of the symmetric property P, then the pair
(y,x) is also an instance of P. For example, friend may be
stated to be a symmetric property. Then a reasoner that is
given that Frank is a friend of Deborah can deduce that
Deborah is a friend of Frank. Note that properties that are
to be made symmetric may not have arbitrary domains and
ranges.

FunctionalProperty : Properties may be stated to
have a unique value. If a property is a FunctionalProperty,
then it has no more than one value for each individual (it
may have no values for an individual). This characteristic
has been referred to as having a unique property.
FunctionalProperty is shorthand for stating that the
property's minimum cardinality is zero and its maximum
cardinality is 1. For example, hasPrimaryEmployer may be
stated to be a FunctionalProperty. From this a reasoner may
deduce that no individual may have more than one primary
employer. This does not imply that every Person must have at
least one primary employer however.

InverseFunctionalProperty: Properties may be
stated to be inverse functional. If a property is inverse
functional then the inverse of the property is functional.
Thus the inverse of the property has at most one value for
each individual. This characteristic has also been referred
to as an unambiguous property. For example,
hasUSSocialSecurityNumber (a unique identifier for United
States residents) may be stated to be inverse functional (or
unambiguous). The inverse of this property (which may be
referred to as isTheSocialSecurityNumberFor) has at most one
value for any individual in the class of social security
numbers. Thus any one person's social security number is the
only value for their isTheSocialSecurityNumberfor property.
From this a reasoner can deduce that no two different
individual instances of Person have the identical US Social
Security Number. Also, a reasoner can deduce that if two
instances of Person have the same social security number,
then those two instances refer to the same individual.

3.4 OWL Lite Property Type
Restriction

OWL Lite allows restrictions to be placed on how properties can
be used by instances of a class. The following two restrictions
limit which values can be used while the next section's
restrictions limit how many values can be used.

allValuesFrom: The restriction allValuesFrom is
stated on a property with respect to a class. It means that
this property on this particular class has a local range
restriction associated with it. Thus if an instance of the
class is related by the property to a second individual, then
the second individual can be inferred to be an instance of
the local range restriction class. For example, the class
Person may have a property called hasOffspring restricted to
have allValuesFrom the class Person. This means that if an
individual person Louise is related by the property
hasOffspring to the individual Deborah, then from this a
reasoner can deduce that Deborah is an instance of the class
Person. This restriction allows the property hasOffspring to
be used with other classes, such as the class Cat, and have
an appropriate value restriction associated with the use of
the property on that class. In this case, hasOffspring would
have the local range restriction of Cat when associated with
the class Cat and would have the local range restriction
Person when associated with the class Person. Note that a
reasoner can not deduce from an allValuesFrom restriction
alone that there actually is at least one value for the
property.

someValuesFrom: The restriction
someValuesFrom is stated on a property with respect to
a class. A particular class may have a restriction on a
property that at least one value for that property is of a
certain type. For example, the class SemanticWebPaper may
have a someValuesFrom restriction on the hasKeyword
property that states that some value for the
hasKeyword property should be an instance of the class
SemanticWebTopic. This allows for the option of having
multiple keywords and as long as one or more is an instance
of the class SemanticWebTopic, then the paper would be
consistent with the someValuesFrom restriction. Unlike
allValuesFrom, someValuesFrom does not restrict
all the values of the property to be instances of the same
class. If myPaper is an instance of the SemanticWebPaper
class, then myPaper is related by the hasKeyword
property to at least one instance of the SemanticWebTopic
class. Note that a reasoner can not deduce (as it could with
allValuesFrom restrictions) that all values of
hasKeyword are instances of the SemanticWebTopic class

3.5 OWL Lite Restricted
Cardinality

OWL Lite includes a limited form of cardinality
restrictions. OWL (and OWL Lite) cardinality restrictions are
referred to as local restrictions, since they are stated on
properties with respect to a particular class. That is, the
restrictions constrain the cardinality of that property on
instances of that class. OWL Lite cardinality restrictions are
limited because they only allow statements concerning
cardinalities of value 0 or 1 (they do not allow arbitrary
values for cardinality, as is the case in OWL DL and OWL
Full).

minCardinality: Cardinality is stated on a
property with respect to a particular class. If a
minCardinality of 1 is stated on a property with
respect to a class, then any instance of that class will be
related to at least one individual by that property. This
restriction is another way of saying that the property is
required to have a value for all instances of the
class. For example, the class Person would not have any
minimum cardinality restrictions stated on a hasOffspring
property since not all persons have offspring. The class
Parent, however would have a minimum cardinality of 1 on the
hasOffspring property. If a reasoner knows that Louise is a
Person, then nothing can be deduced about a minimum
cardinality for her hasOffspring property. Once it is
discovered that Louise is an instance of Parent, then a
reasoner can deduce that Louise is related to at least one
individual by the hasOffspring property. From this
information alone, a reasoner can not deduce any maximum
number of offspring for individual instances of the class
parent. In OWL Lite the only minimum cardinalities allowed
are 0 or 1. A minimum cardinality of zero on a property just
states (in the absence of any more specific information) that
the property is optional with respect to a class. For
example, the property has Offspring may have a minimum
cardinality of zero on the class Person (while it is stated
to have the more specific information of minimum cardinality
of one on the class Parent).

maxCardinality: Cardinality is stated on a
property with respect to a particular class. If a
maxCardinality of 1 is stated on a property with
respect to a class, then any instance of that class will be
related to at most one individual by that property. A
maxCardinality 1 restriction is sometimes called a functional
or unique property. For example, the property
hasRegisteredVotingState on the class UnitedStatesCitizens
may have a maximum cardinality of one (because people are
only allowed to vote in only one state). From this a reasoner
can deduce that individual instances of the class USCitizens
may not be related to two or more distinct individuals
through the hasRegisteredVotingState property. From a maximum
cardinality one restriction alone, a reasoner can not deduce
a minimum cardinality of 1. It may be useful to state that
certain classes have no values for a particular property. For
example, instances of the class UnmarriedPerson should not be
related to any individuals by the property hasSpouse.
This situation is represented by a maximum cardinality of
zero on the hasSpouse property on the class
UnmarriedPerson.

cardinality: Cardinality is provided as a
convenience when it is useful to state that a property on a
class has both minCardinality 0 and
maxCardinality 0 or both minCardinality 1 and
maxCardinality 1. For example, the class Person has
exactly one value for the property hasBirthMother. From this
a reasoner can deduce that no two distinct individual
instances of the class Mother may be values for the
hasBirthMother property of the same person.

3.6 OWL Lite Class
Intersection

OWL Lite has contains an intersection constructor but limits
its usage.

intersectionOf: OWL Lite allows intersections of
named classes and restrictions. For example, the class
EmployedPerson can be described as the intersectionOf
Person and EmployedThings (which could be defined as things
that have a minimum cardinality of 1 on the hasEmployer
property). From this a reasoner may deduce that any
particular EmployedPerson has at least one employer.

3.7 Datatypes

OWL uses the RDF mechanisms for data values.
See the
OWL Guide for a more detailed description.

3.8 OWL Lite Header
Information

OWL Lite supports notions of ontology inclusion and
relationships and attaching information to ontologies.
See the OWL
Reference for details and the OWL Guide for
examples.

4. Incremental Language
Description of OWL DL and OWL FULL

Both OWL DL and OWL Full use the same vocabulary although OWL
DL is subject to some restrictions. Roughly, OWL DL requires
type separation (a class can not also be an individual or
property, a property can not also be an individual or class).
This implies that restrictions cannot be applied to the
language elements of OWL itself (something that is allowed in
OWL Full). Furthermore, OWL DL requires that properties are
either ObjectProperties or DatatypeProperties:
DatatypeProperties are relations between instances of classes
and RDF literals and XML Schema datatypes, while
ObjectProperties are relations between instances of two
classes. The OWL
Abstract Syntax and Semantics document explains the
distinctions and limitations. We describe the OWL DL and OWL
Full vocabulary that extends the constructions of OWL Lite
below.

oneOf: (enumerated classes): Classes can be
described by enumeration of the individuals that make up the
class. The members of the class are exactly the set of
enumerated individuals; no more, no less. For example, the
class of daysOfTheWeek can be described by simply enumerating
the individuals Sunday, Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday. From this a reasoner can deduce the maximum
cardinality (7) of any property that has daysOfTheWeek as its
allValuesFrom restriction.

hasValue: (property values): A property can be
required to have a certain individual as a value (also
sometimes referred to as property values). For example,
instances of the class of dutchCitizens can be characterized
as those people that have theNetherlands as a value of their
nationality. (TheNetherlands itself is an instance of the
class of Nationalities).

disjointWith: OWL Full allows the statement that
classes are disjoint. For example, Man and Woman can be
stated to be disjoint classes. From this disjointWith
statement, a reasoner can deduce an inconsistency when an
individual is stated to be an instance of both and similarly
a reasoner can deduce that if A is an instance of Man, then A
is not an instance of Woman.

unionOf, complementOf, intersectionOf (Boolean
combinations): OWL allows arbitrary Boolean combinations of
classes and restrictions: unionOf, complementOf, and
intersectionOf. For example, using unionOf, we can state that
a class contains things that are either USCitizens or
DutchCitizens. Using complementOf, we could state that
children are not SeniorCitizens. (i.e. the class
Children is a subclass of the complement of SeniorCitizens).
Citizenship of the European Union could be described as the
union of the citizenship of all member states.

minCardinality, maxCardinality, cardinality
(full cardinality): While in OWL Lite, cardinalities are
restricted to at least, at most or exactly 1 or 0, full OWL
allows cardinality statements for arbitrary non-negative
integers. For example the class of DINKs ("Dual Income, No
Kids") would restrict the cardinality of the property
hasIncome to a minimum cardinality of two (while the property
hasChild would have be restricted to cardinality 0).

complex classes : In many
constructs, OWL Lite restricts the syntax to single class
names (e.g. in subClassOf or equivalentClass statements). OWL
Full extends this restriction to allow arbitrarily complex
class descriptions, consisting of enumerated classes,
property restrictions, and Boolean combinations. OWL also
includes a special "bottom" class with the name Nothing that
is the class that has no instances. Also, OWL full allows
classes to be used as instances (and OWL DL and OWL Lite do
not). For more on this topic, see the "Design for Use"
section of the Guide document.

This document provides an overview of the Web Ontology Language
by providing a brief introduction to why one might need a Web
ontology language and how OWL fits in with related W3C
languages. It also provides a brief description of the three
OWL sublanguages: OWL Lite, OWL DL, and OWL Full along with a
feature synopsis for each of the languages. This document is an
update to the Feature Synopsis Document. It provides simple
descriptions of the constructs along with simple examples. It
references the OWL
reference document, the OWL
Guide, and the OWL Abstract Syntax and
Semantics document for more details. Previous versions (
January 2, 2003,
July 29, 2002,
July 8, 2002,
June 23, 2002,
May 26, 2002, and
May 15, 2002) of this document provide the historical view
of the evolution of OWL Lite and the issues discussed in its
evolution.