OWL (the Web Ontology Language) is intended to be used by applications
that need to process the content of information instead of just presenting
the human-readable content. 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. The OWL language
provides three increasingly expressive sublanguages: OWL Lite, OWL DL, and
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
Syntax and Semantics.
Status of this document
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/.
This Overview is a non-normative document, which means that it does not
provide a definitive specification of OWL. The examples and other explanatory
material in the Overview are provided to help you understand OWL, but they
may not always provide definitive or complete answers. The normative formal
definition of OWL can be found in the OWL Abstract
Syntax and Semantics.
This document is a working document for the use by W3C Members and other
interested parties. It may be updated, replaced or made obsolete by other
documents at any time.
This document has been produced by the Web Ontology Working Group, as
part of the W3C Semantic Web
Activity. The goals of the Web Ontology working group are discussed in
the Web Ontology Working
Comments on this document should be sent to the W3C mailing list email@example.com
There are no patent disclosures related to this work at the time of this writing.
- Document Roadmap
- Why OWL?
- The three sublanguages of OWL
- The structure of this document
- Language Synopsis
- OWL Lite Synopsis
- OWL DL and OWL Full Synopsis
- Language Description of OWL Lite
- OWL Lite RDF Schema Features
- OWL Lite Equality and Inequality
- OWL Lite Property Characteristics
- OWL Lite Property Type Restrictions
- OWL Lite Restricted Cardinality
- OWL Lite Class Intersection
- OWL Datatypes
- OWL Lite Header Information
- Incremental Language Description of OWL DL and OWL
This document describes OWL (the Web Ontology Language). OWL is intended
to be used by applications that need to process the document content, as
opposed to presenting the content 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
considered 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:
The suggested reading order of these documents is as given, since they have
been listed in increasing degree of technical content.
- This 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 OWL Abstract Syntax and
Semantics document is the final and formally stated normative
definition of the language.
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 next element required
for the Semantic Web is a Web Ontology Language (OWL) which can formally
describe the meaning of the terminology used in web documents and term
interrelationships. 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 Requirements
Document provides more details on ontologies,
motivates the need for a Web Ontology Language in terms of six use cases,
design goals, requirements
and objectives for
OWL providing further support for OWL.
OWL is part of a "stack" of Semantic Web related W3C recommendations, in
the following way:
- 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.
- 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.
- is a vocabulary for describing properties and classes of RDF
resources, with a semantics for generalization-hierarchies of such
properties and classes.
- adds more vocabulary for describing properties and classes: among
others, relations between classes (e.g. disjointness), cardinality
(e.g. "exactly one"), equality, richer typing of properties,
characteristics of properties (e.g. symmetry), and enumerated
1.3 The three sublanguages of OWL
OWL provides three increasingly expressive sublanguages designed for use
by specific communities of implementers and users.
supports those users primarily needing a classification hierarchy and
simple constraint features. 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 provides a quick migration path for thesauri and other
OWL DL supports
those users who want the maximum expressiveness while their reasoning
systems maintain 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
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 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 every feature of OWL
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 restriction constructs
provided by the full language. 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, 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
OWL Full can be viewed as an extension of RDF, while OWL Lite and OWL Full
can be viewed as extensions of a restricted view of RDF. Therefore 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
1.4 The structure of this document
This document first describes the language features from OWL Lite,
followed by a description from the language features that are added in OWL DL
and OWL Full (OWL DL and OWL Full contain the same language features, but OWL
Full is more liberal about how these features can be combined).
2. Language Synopsis
This 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.
2.1 OWL Lite Synopsis
The list of OWL Lite language constructs are given below.
2.2 OWL DL and Full Synopsis
The list of OWL DL and OWL Full language constructs that are in addition
to those of OWL Lite are given below.
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 a few
limitations w.r.t. OWL DL and OWL Full. Classes can only be defined in terms
of named superclasses (superclasses cannot be arbitrary logical expressions),
and only certain kinds of class restrictions can be used. Equivalence between
classes and subclass relationships between classes are also only allowed to
be stated on named classes, and not between arbitrary class expressions.
Similarly, property 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 the superclass of
- rdfs:subClassOf: Class hierarchies
may be created by making one or more statements that a class is a
subclass of one or more other classes. For example, the class Person
could be stated to be a subclass of the class Mammal. From this a
reasoner can deduce that if X is a Person, then X is a Mammal.
- rdfs:Property: A property is a
relationship between individuals. Examples of properties include:
hasChild, hasRelative, hasSibling, and hasAge. The first three relate an
instance of a class Person to another instance of the class Person (and
are thus ObjectProperties), and the last one (hasAge) relates an instance
of the class Person to an instance of the datatype Integer (and is thus a
- 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 X is related to Y by the hasSibling property,
then X is also related to Y by the hasRelative property.
- rdfs:domain: The domain of a property is
the set of individuals to which the property can be applied: if a
property P relates individual X to individual Y, and p has as domain the
class Z, then X must be an instance of Z. 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 is the
set of individuals that the property may have as its value: if a property
P relates individual X to individual Y, and P has as range the class Z,
then Y must be an instance of Z. 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
: 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
3.2 OWL Lite Equality and Inequality
The following OWL Lite features are related to equality or inequality.
: Two classes may be stated to be identical (i.e., they may be stated to
be different names for the same set of individuals). 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 identical. 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
- 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
An individual may be stated to be different from other individuals. For
example, the individual Frank may be sta ted 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
- 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
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
- 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
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
3.4 OWL Lite Property Type Restriction
OWL Lite allows restrictions to be placed on the type of values for a
property. The following two restrictions are placed on properties with
respect to a class and thus have the impact of limiting the extent of the
class with the value restriction.
- 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
- 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).
Alternate namings for these restricted forms of cardinality were discussed.
Current recommendations are to include any such names in a front end system.
More on this topic is available on the publically available webont mail
archives with the most relevant message at
- 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
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.
OWL makes use of the RDF datatyping scheme, which provides a mechanism for
XML Schema datatypes. Such XML Schema datatypes are identified by a URI,
and each time an instance of such a datatype occurs, it must have an RDF
attribute rdf:datatype whose value should be the URI reference of the XML
Schema datatype. See the OWL
Guide for a more detailed description.
3.8 OWL Lite Header Information
OWL supports standard notions of ontology referencing, inclusion, and
meta-information. All three levels of OWL include ways of specifying
ontologies to import, ontology version information, prior ontology version
information, ontologies known to be backward compatible, and ontologies known
to be incompatible. See the OWL
Reference for definitions.
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.
This document provides an overview 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.
- 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
- 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,
(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).
: 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.