Abstract
OWL is the new ontology language produced by the W3C Web Ontology Working
Group. As such, it is poised to be a major formalism for the design and
dissemination of ontology information, particularly in the Semantic Web, a
part of the World-Wide Web. OWL has influences from several communities,
including the RDF community, the Description Logic community, and the frame
community. These influences have resulted in a wide variety of
requirements on OWL, several of which appear to be conflicting. OWL
contains innovative solutions to several of these apparent conflicts but
other conflicts have meant that it has not been possible to satisfy all the
desired requirements for OWL.
In this talk I will describe the design and development of OWL
concentrating on what makes OWL important, the relationship of OWL to other
efforts, the innovative solutions that were required in its design, and the
impact of the conflicting requirements on OWL.
Acknowledgments and Caveats
Acknowledgments
This talk reports on the work of a large group of researchers, including
many in the W3C RDF Core and Web Ontology Working Groups, but, of course,
has my particular prejudices built into it.
Caveats
- This talk is not a tutorial on OWL
- This talk does not provide complete information on RDF, RDFS, or OWL
- This talk contains personal opinions
- In particular, I am a Description Logic researcher, so some of
this talk will be most closely aligned with this body of work.
Outline
- The Semantic Web
- Introduction to OWL
- Influences on OWL
- Design of OWL
- A new Semantic Web Vision
- Conclusions
The Semantic Web
The Semantic Web Vision
- Building a part of the World Wide Web where knowledge is fully
accessible to computers
- ".... a goal of the Web was that, if the interaction between person and
hypertext could be so intuitive that the machine-readable information space
gave an accurate representation of the state of people's thoughts,
interactions, and work patterns, then machine analysis could become a very
powerful management tool, seeing patterns in our work and facilitating our
working together through the typical problems which beset the management of
large organizations.." http://www.w3.org/People/Berners-Lee/1996/ppf.html
- A very ambitious vision
The Semantic Web
A (Modest) Example
- Building a generic trip planning system and automatically have it
work for all kinds of transportation and accommodation
- Even if the required knowledge is expressed in different
ways
- Requires some means for relating the vocabulary used for different
kinds of transportation and accommodation to the vocabulary used by
the system
Outline
- The Semantic Web
- Introduction to OWL
- Influences on OWL
- Design of OWL
- A new Semantic Web Vision
- Conclusions
OWL Ontology Fragment (in RDF/XML syntax)
Taken from the OWL wine and
food ontologies.
<owl:Class rdf:ID="WhiteWine">
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Wine" />
<owl:Restriction>
<owl:onProperty rdf:resource="#hasColor" />
<owl:hasValue rdf:resource="#White" />
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
In other (more readable) words
A WhiteWine is precisely a Wine that has color White.
(From now on, I will not use the RDF/XML syntax!)
OWL Ontology Fragment (in DL syntax)
wine:Wine ≤ food:PotableLiquid ∩ (≥1 wine:madeFromGrape) ∩
(=1 wine:hasMaker) ∩ (∀ wine:hasMaker wine:Winery) ∩
(=1 wine:hasColor) ∩ ...
wine:madeFromGrape ≤ wine:Wine × wine:WineGrape
wine:hasColor ≤ wine:Wine × wine:WineColor
wine:WineColor = { wine:White, wine:Rose, wine:Red }
wine:White ≠ wine:Rose wine:White ≠ wine:Red wine:Rose ≠ wine:Red
wine:WineDescriptor = wine:WineTaste ∪ wine:WineColor
wine:WhiteWine = wine:Wine ∩ ( wine:hasColor wine:White )
wine:Riesling = wine:Wine ∩ (≤1 wine:madeFromGrape) ∩
(wine:madeFromGrape wine:RieslingGrape )
wine:Riesling ≤ wine:hasColor wine:White
wine:CorbansDryWhiteRiesling ∈ wine:Riesling ∩
(wine:hasMaker wine:Corbans) ∩ ...
Consequences of the Ontology Fragment
OWL is a logic, with an entailment (consequence) relationship.
For example, the ontology fragment above entails:
wine:Riesling ≤ wine:WhiteWine
wine:Riesling ≤ wine:WhiteWine ∩ (=1 wine:hasMaker)
wine:Riesling ≤ wine:WhiteWine ∪ (=7 wine:hasMaker)
wine:Riesling ∩ (wine:hasColor : wine:Red) ≤ wine:WineDescriptor
wine:CorbansDryWhiteRiesling ∈ wine:WhiteWine
Determining consequence in OWL is difficult
- NEXPTIME complete for the DL fragment of OWL
- Sound and complete reasoners not (quite) yet ``practical''
What you can't Say in OWL
- Certain kinds of disjunction
- ``Either Saddam is a terrorist or Bush is a liar''
- But can say ``Bush is either a terrorist or a liar''
ex:Bush ∈ ex:Terrorist ∪ ex:Liar
- Many kinds of universal quantification
- ``For every student and university, there is an
application by that student to that university''
- But can say ``Every student applies to at least five
universities''
ex:Student ≤ (≥ 5 ex:application) ∩
(∀ ex:application ex:University)
- Many kinds of relationships between properties
- ``Uncle is the composition of parent and brother''
- Limitations are in place to keep DL fragment of OWL decidable
What can be Done in OWL
- Build ontologies
- State facts (including disjunctive and vague facts)
- What is the difference between an ontology and a bunch of
facts?
- OWL specifies the consequences of an ontology
- What sorts of consequences?
- Whatever can be said in OWL
- OWL specifies the consequences of a bunch of facts
- What sorts of consequences?
- Whatever can be said in OWL
- Is determining consequence different from retrieval?
- Yes, in some sense, as consequence only provides YES/NO answers
Ontologies (An AI Approach)
- An ontology is way of describing the world
- Determines
- what kinds of things there are in the world
(e.g., Wines, Wineries)
- the relationships between them (e.g., hasMaker)
- Provides
- characteristics of the kinds of things (e.g., WhiteWine
is a subclass of Wine) and
- characteristics of the relationships (e.g., WineColor
can be either White, Rose, or Red)
- Ontologies can have
- narrow coverage (an ontology for ordering wine)
- medium coverage (an ontology for wine and food)
- broad coverage (an ontology for objects, relationships, and
processes)
- Ontologies are everywhere
- DB schemata and Object-Oriented structures often form simple
kinds of ontologies
What OWL Is
- A language for structuring information (into ontologies)
- Define what kinds of things are in the world (classes)
- wines, wineries, white wine, ...
- Define how these things relate (via properties)
A language for providing information about objects using this way of thinking
- Corban's dry white Riesling, ...
Somewhat similar (but more general than) a DB Schema language plus a DB
- Doesn't have the closed-world assumptions built into DBs
- Allows for uncertainty and vagueness
How OWL Fits into the Web
How OWL Fits into the World Wide Web
- OWL is written (officially) in XML
- Identifiers in OWL are IRI references
- Often abbreviated as QNames
- OWL documents are World Wide Web document with media type
application/rdf+xml
How OWL Fits into the Semantic Web
- OWL is written (officially) in RDF/XML
- OWL uses RDF terminology whereever possible
- e.g., rdf:type, rdfs:subClassOf
- OWL semantics is an extension of RDF semantics
- This caused lots of problems
Why You Should Give a Hoot About OWL
- OWL adds a new (currently topmost) level to the Semantic Web
- Ability to describe and reason about ontologies
(vocabularies)
- A way to structure and relate information
- Ontology languages structure ontologies
- Determine what can (and what can not) be said in ontologies
- Determine what kinds of facts interact with ontologies
- Thus,
- OWL limits what can be said in the Semantic Web
- OWL is a target for development (both reasoning tools and user
interface tools)
Outline
- The Semantic Web
- Introduction to OWL
- Influences on OWL
- Design of OWL
- A new Semantic Web Vision
- Conclusions
Influences on OWL
The Semantic Web
- Vision:
- Specify meaning of constructs in the World-Wide Web so that computers
can process and understand them
- Early Progress:
- Devise language (RDF) for writing down simple facts
- RDF is written in XML, and uses many World-Wide Web concepts
- An extension to RDF (RDFS) provides some information about classes and
properties
- Next Goal:
- Add ontologies to the Semantic Web
The Semantic Web Layer Cake
Not yet specified
Not yet specified
Not yet specified
OWL ontology language
RDF provides semantics
XML provides syntax
Identifiers are URIs (IRIs)
RDF
- RDF is a language for recording information in the Semantic Web
- Names in RDF are IRI references
- RDF is a very sparse language
- Can only say a very few things
- RDF is written in XML, but is different
- Only certain XML documents are valid RDF documents
- Meaning of RDF is different from meaning of XML
- First part of processing extracts the RDF triples
from the RDF/XML document
- Then the triples are interpreted as a logical language,
with a model-theoretic semantics
RDF Example
| Exchange Syntax (RDF/XML) | Abstract Syntax (RDF Triples) |
<ex:Person:id="john"> | john <rdf:type> <ex:Person>. |
<ex:name:datatype="&xsd;string"> | john <ex:name> |
John Smith</ex:name> | "John Smith"^^xsd:string. |
<ex:spouse> | john <ex:spouse> sally. |
<ex:Person:id="sally"> | sally <rdf:type> <ex:Person>. |
<ex:father:resource="paul"/> | sally <ex:father> paul. |
</ex:Person> | |
</ex:spouse> | |
</ex:Person> | |
<rdf:description:about="#sally"> | sally <ex:name> |
<ex:name:datatype="&xsd;string"> | "Sally Brown"^xsd:string. |
Sally Brown</ex:name> | |
</rdf:description> | |
RDF Semantics
- Fairly standard model theory
- Similar to the model theory of first-order logic
- Except: predicates (properties) are domain elements
- Entailment is the main RDF semantic relationship
- One set of RDF triples entails another exactly when the second must be
true whenever the first is true
- The previous example entails
<ex:John> <ex:name> _:a .
<ex:John> <ex:spouse> _:b .
_:b < rdf:type> <ex:Person> .
_:b <ex:name> "Sally Brown" .
RDFS
- Adds vocabulary-structuring capabilities to RDF
- Introduces categories for classes, properties
- Allows for class and property hierachy
- Allows for domains and ranges for properties
- Was defined as constraints on RDF triples
- Now defined as a semantic extension to RDF
- Classes in RDFS are very closely related to the extension of rdf:type
RDFS Example
Information about the vocabulary in the previous example:
-
<ex:Person> <rdf:type> <rdfs:Class> .
<ex:name> <rdf:type> <rdf:Property> .
<ex:name> <rdfs:domain> <ex:Person> .
<ex:name> <rdfs:range> <xsd:string> .
<ex:Student> <rdfs:subClassof> <ex:Person> .
- ex:Person is a class;
ex:name is a property
with domain ex:Person and range xsd:string
ex:Student is a subclass of ex:Person
RDF and RDFS Summary
- RDF provides a way of stating simple statements
<ex:john> <rdf:type> <ex:Person> .
<ex:john> <ex:spouse> <ex:sally> .
- RDFS interprets some of these as a very simple ontology language
<ex:Student> <rdfs:subClassOf> <ex:Person> .
Frames
- Formalism for representing information about objects, frames (classes), and slots (properties)
- A frame gathers together information about a particular kind of object
- Example:
Frame Person
name : String
spouse : Person
father : Person
sally isa Person
name = "Sally Brown"
father = paul
Description Logics
- Group of logics
- Based on
- individuals (objects),
- concepts and descriptions (classes), and
- roles (properties)
- Varying expressive power
- General characteristics
- Model-theoretic semantics, similar to that for first-order logic
- Complexity of inference usually known
- Multiple implementations
- Some implementations highly optimized
- Effective tractability
Description Logic Example
john ∈ Person ∩ name="John Smith"
<john,sally> ∈ spouse
Sally ∈ Person ∩ name="Sally Brown"
<sally,paul> ∈ father
spouse is symmetric
paul ∈ Person ∩ ≤ 0 spouse
Student ⊆ Person
Description Logic Inferences
john ∈ Person ∩ name="John Smith"
<john,sally> ∈ spouse
Sally ∈ Person ∩ name="Sally Brown"
<sally,paul> ∈ father
spouse is symmetric
paul ∈ Person ∩ ≤ 0 spouse
Student ⊆ Person
entails
sally ∈ Person ∩ ∃ spouse:Person
Student ∩ spouse:Student ⊆ Person ∩ spouse:Person
paul ∈ ∀ spouse : { sally }
mary ∈ (∀ spouse:Person ) ∪ (∃ spouse : ¬ { john } )
Determining Inference in DLs
- Description Logics can be quite complex
- Boolean operations
- Counted modalities
- Etc.
- Inference can be computationally intractable
- EXPTIME complete or worse
- Nevertheless, there are systems that can effectively determine inference in these DLs
Outline
- The Semantic Web
- Introduction to OWL
- Influences on OWL
- Design of OWL
- A new Semantic Web Vision
- Conclusions
(W3C) Design Criteria for OWL
- Part of the W3C Semantic Web
- Thus an extension of RDF and RDFS with RDF syntax
- Nice syntax, similar to frames
- Clean semantics, as for Description Logics
- To avoid problems with early, underspecified versions of RDF
- Sufficiently expressive to represent many useful ontologies
- Suitable for implementations
No research needed because already done for DAML+OIL
DAML+OIL
- Semantic Web version of Description Logics
- Uses RDF syntax
- Semantics derived from Description Logics semantics
- Only constructs that make DL sense are given DL semantics
- Solution to relationship and semantic tensions
- Highly expressive, but decidable
- Can represent many ontologies
- Incorporates empirically-useful constructs
- Corresponds to an implemented Description Logic - SHIQ(Dn)
- Solution to representation and reasoning tensions
- DAML+OIL is (just) a Description Logic in Semantic Web clothing
- Names of classes, properties, and
individuals are IRI references
- Surface syntax is RDF/XML
- Semantic conditions use RDF triples
Influences on OWL
Tensions in the Design
- Relationship to the Semantic Web
- Clean design vs relationship to existing efforts
- Solved in DAML+OIL (more or less)
- Syntax
- Nice syntax vs RDF/XML
- Not solved in DAML+OIL
- Semantics
- Clean semantics and RDF extension
- DAML+OIL has clean semantics and uses RDF vocabulary,
but doesn't extend RDF semantics (because it predated the RDF semantics)
- Representation
- Logical cleanliness vs empirical utility
- DAML+OIL is a reasonable solution here
- Reasoning
- Effective reasoning vs expressive power
- DAML+OIL is a reasonable solution here as well
Syntax Tension
- RDF/XML syntax is difficult
- Even RDF triples syntax is messy when expressing complex constructs
- Compare
- DAML+OIL syntax
_:a <rdf:type> <daml:Restriction> .
_:a <daml:onProperty> <ex:spouse> .
_:a <daml:toClass> <ex:Person> .
- Description Logic syntax
∀ spouse : Person
Syntax Solution
- Provide alternative syntax for OWL
-
Class(Person partial
restriction(spouse allValuesFrom(Person)
maxCardinality (1))
restriction(name allValuesFrom(xsd:string)
cardinality(1)))
- Close to Description Logics syntax, but also similar to Frames syntax
- Doesn't handle all possible OWL ontologies
- Provide mappings between the two syntaxes
- Not a complete solution, but probably good enough
Are We Done?
- Unfortunately, no.
- DAML+OIL preceded the latest round of work on RDF and RDFS
- Not compatible with RDF datatyping and other new RDF constructs
- Not compatible with the new semantics for RDF
- Therefore, not compatible with the Semantic Web vision
- Thus work needed to be done
Real Influences on OWL
OWL-RDF Compatibility, The Easy Parts
- Datatyping added to RDF
- Just use the RDF solution in OWL
- RDF containers, reification, and literals improved
- No serious work needed to regain compatibility
- Lists added to RDF (modified from DAML+OIL lists)
- Replace DAML+OIL lists by RDF lists
OWL-RDF Semantic Compatibility (part 1)
- Modify DAML+OIL semantics to look like RDF semantics
- Problem:
- Description Logics have a division between individuals and classes,
RDF does not
- ex:john rdf:type ex:Person .
ex:Person rdf:type rdfs:Class .
rdfs:Class rdf:type rdfs:Class .
- Solution:
- Provide a treatment of OWL constructs in an extension of RDF semantics
- Problem:
- Reasoning is now undecidable
- Solution:
- Design a sublanguage of OWL that is decidable -
OWL DL
OWL DL
- Divides the universe disjointly into individuals and classes
- Doesn't allow arbitrary use of RDF vocabulary
- E.g., can't use rdf:type as an individual
- Corresponds to alternative syntax
- Corresponds closely to Description Logic SHOIN(Dn)
OWL Lite
- OWL DL is still a complex language
- Has several recursive constructs
- Want a language that looks even more like frames
- OWL Lite removes several constructs from OWL DL
- Descriptions inside descriptions
- Unions, one of, ...
- OWL Lite corresponds closely to Description Logic SHIN(Dn)
- Known to be decidable
- Has efficient implementations
The Current Semantic Web Vision
Warning: This is my interpretation of the current instantiation
of the semantic web vision in W3C based on various statements made by
people associated with W3C.
- Vision:
- Specify meaning of constructs in the World-Wide Web so that computers
can process and understand them
- Implementation of ``process''
- All information in the Semantic Web will be written in RDF
- Communication language (documents) will be RDF/XML
- Names in the Semantic Web will be IRI references
- Only the RDF triples extracted from the RDF/XML document carry information
- Implementation of ``understand''
- All information in the Semantic Web will understandable as RDF
- Every Semantic Web language will be semantically compatible with
RDF(S)
Why this Implementation of the Vision?
- All Semantic Web documents in RDF/XML:
- So that XML tools (e.g., XSLT) can transform Semantic Web documents
- So that XML tools can be used for the first part of parsing any Semantic Web document.
- Only the RDF triples carry information:
- So that RDF tools can be used to partially process any Semantic Web document.
- All Semantic Web languages are semantic extensions of RDF(S)
- So that RDF tools can capture part of the meaning of any Semantic Web document.
Effect of the Vision on OWL
- Every triple in an OWL document makes a statement
- Even the triples used to encode OWL syntax, e.g., ∀ex:spouse ex:Person
_:a rdf:type owl:Restriction .
_:a owl:onProperty ex:spouse .
_:a owl:allValuesFrom ex:Person .
which thus states that there is an object (:a) ...
- Interferes with entailment, because to entail a bit of OWL syntax requires that the existence of the syntax can be inferred
-
ex:john rdf:type ex:Student .
ex:john rdf:type ex:Employee .
does not entail john ∈ ex:Student ∩ ex:Person
ex:john rdf:type _:a .
_:a owl:intersectionOf _:l1 .
_:l1 rdf:first ex:Student .
_:l1 rdf:rest _:l2 .
_:l2 rdf:first ex:Employee .
_:l2 rdf:rest rdf:nil .
because there need not be an objects for _:a,
_:l1, _:l2
Giving Meaning to Triples
OWL-RDF Semantic Compatibility (part 2)
- Problem:
-
Semantic Web vision means that all triples (including those needed to
encode OWL syntax) make assertions, interfering with entailment
- Solution:
- Add semantic conditions (comprehension principles) that require
the existence of all syntactic constructs
- E.g., all finite lists exist
- E.g., for each property and description there is an
owl:allValuesFrom restriction with that property and condition
OWL-RDF Semantic Compatibility (part 2)
- Problem:
- Comprehension principles can produce paradoxes
- The Russell Set (the set of all sets that don't contain themselves)
- The Liar's paradox (the statement that says that it is false)
- Solution:
-
All paradoxical constructs are self-referential, so only provide
comprehension principles for non-self-referential (tree-like) descriptions
- Problem: Not all non-problematic entailments result
-
ex:john rdf:type ex:Person .
does not entail
ex:john rdf:type _:a .
_:a owl:unionof _:l1 .
_:l1 rdf:first ex:Person . _:l1 rdf:rest _:l2 .
_:l2 rdf:first _:b . _:l2 rdf:rest rdf:nil .
_:b owl:onProperty ex:spouse .
_:b owl:allValuesFrom _:b .
Semantic Compatibility (part 2)
The State of OWL
- OWL provides an ontology level for the Semantic Web
- OWL fits into the Semantic Web vision
- Uses RDF syntax
- Is a semantic extension of RDFS
- OWL has decidable subsets
- OWL DL and OWL Lite
- Subsets have nicer, alternative syntax
- Subsets have no semantic anomalies
- OWL is a compromise
Outline
- The Semantic Web
- Introduction to OWL
- Influences on OWL
- Design of OWL
- A new Semantic Web Vision
- Conclusions
Going Forward
Can the Semantic Web vision be extended to the next (logic) level?
- Full incorporation of variables in RDF is problematic
- Everything in RDF is a ground (or existential) statement
- Why not just allow a different syntax?
- Parsers are very easy to write!
- It is easier to understand a new language than a complex encoding
into an old language (think Pascal vs extensions of assemblers
that could provide real variables and recursion)
- Not really a new vision, just a new implementation of the old vision
A New Implementation of the Vision
- Vision:
- Specify meaning of constructs in the World-Wide Web so that computers
can process and understand them
- Implementation of ``process''
- All information in the Semantic Web will be written in
RDFXML
-
Communication language (documents) will be RDF/XML
- Names in the Semantic Web will be IRI references
-
Only the RDF triples extracted from the RDF/XML document carry information
- Implementation of ``understand''
- Everything in the Semantic Web will be a semantic extension of RDF(S)
- Every Semantic Web language will be semantically compatible with
RDF(S)
- Semantic Web languages will have a means of referencing
documents in the Semantic Web
A New Implementation of the Vision
- The Semantic Web has multiple languages (RDF, OWL, FOL, ...)
- Each language has a model-theoretic semantics
- The different semantics are cOmpatible
- Maybe even XML can be included
- The language of a Semantic Web document is determinable via World Wide Web mechanisms (MIME type, etc.)
- Semantic Web tools and applications may be unable to cope with some documents
- But this is no different from the current vision
- Content negotiation might be used to help matters
- This vision looks, to me, a lot more like the World Wide Web vision
- Various ``languages'': XML, GIF, JPEG, ...
Outline
- The Semantic Web
- Introduction to OWL
- Influences on OWL
- Design of OWL
- A new Semantic Web Vision
- Conclusions
Conclusions
- OWL is here
- As with any standard, OWL is not ideal, but it is usable
- OWL will provide important facilities for the Semantic Web
- Ontology information that can be effectively used
- OWL will provide opportunities for research
- Research on characteristics of ontology languages
- Optimization techniques for reasoning in ontology languages
- It is time for a new implementation of the Semantic Web vision
- Multiple languages, with compatible semantics
- Let at least a few flowers bloom!
Resources
- DAML+OIL
- http://www.daml.org/2001/03/daml+oil-index.html
- OWL (W3C Web Ontology Working Group)
- http://www.w3.org/2001/sw/WebOnt/
- RDF (W3C RDF Core Working Group)
- http://www.w3.org/2001/sw/RDFCore/