Abstract
OWL is now a W3C-recommended part of the Semantic Web. OWL provides an
ontology layer for the Semantic Web, largely in the form of an expressive
Description Logic. However, there is a tension between the design needs of
a Description Logic and the W3C vision of the Semantic Web that has
resulted in some significant compromises in the design of OWL.
Nonetheless, OWL provides significant capabilities, both by itself and as
part of a larger logic-based vision of the Semantic Web.
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.
The Semantic Web
The Semantic Web Vision
- Building a part of the World Wide Web where knowledge is fully
accessible to computers
- A very ambitious vision
Bases of the Semantic Web
- All identifiers are global
- Some information sources (documents) can be retrived by ID
- Some information sources can be accessed through services
- Services are accessble by ID
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
- Requires some means of accessing and collecting information
distributed throughout the World Wide Web
The Semantic Web Tower
Not yet specified
Not yet specified
Not yet specified
OWL ontology language
RDF provides semantics
XML provides syntax
Identifiers are URIs (IRIs)
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 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
wine:Riesling ≤ wine:WhiteWine
wine:Riesling ≤ wine:WhiteWine ∩ (=1 wine:hasMaker)
wine:Riesling ≤ wine:WhiteWine ∩ (∀ wine:hasMaker wine:Winery)
wine:Riesling ≤ wine:WhiteWine ∪ (=7 wine:hasMaker)
wine:Riesling = wine:Riesling ∩ (wine:hasColor : wine:White)
wine:Riesling ∩ (wine:hasColor : wine:Red) ≤ wine:WineDescriptor
...
wine:CorbansDryWhiteRiesling ∈ wine:WhiteWine
wine:CorbansDryWhiteRiesling ∈ (wine:hasColor : wine:White) ∩
(wine:hasMaker : wine:Corbans)
...
- Determining consequence in OWL is difficult
- NEXPTIME complete, even if some reasonable restrictions are imposed
- Sound and complete reasoners for fragment not (quite) yet ``practical''
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
What OWL Is Not
What OWL Is Not
- OWL is not a full first-order logic
- OWL has only limited quanitification
- OWL does not have rules (but consider SWRL)
- OWL has no extra-logical facilities
- No processing model
- No side-effects
- OWL has no theory of document (or the Semantic Web as a whole)
What OWL DL Is Not
- Higher-order
- OWL DL does not have metaclasses, etc.
- Reflective
- OWL DL cannot mention its own vocabulary
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 documents
- Media type application/rdf+xml
How OWL Fits into the Semantic Web
- OWL is written (officially) in RDF/XML
- OWL documents can incorporate other OWL (and RDF) documents
- by referencing them in owl:include constructs
- 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)
Influences on OWL
- Semantic Web, especially RDF and RDFS
- RDF/XML syntax is transfer syntax for OWL
- RDF graphs carry information in OWL documents
- OWL is a semantic extension of RDFS
- Frames
- Provides inspiration for alternative syntax for OWL
- Description Logics
- Provide ontology constructs for OWL
- DAML+OIL
- Intermediate point from RDF/RDFS and OIL to OWL
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 graph
from the RDF/XML document
- Then the graph is interpreted as a logical language,
with a model-theoretic semantics
RDF Example
| Exchange Syntax (RDF/XML) | Abstract Syntax (RDF Graph) |
<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 RDF graph 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 graphs
- 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> .
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
(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
Tensions in the Design
- Relationship to the Semantic Web
- Clean design vs relationship to existing efforts
- Syntax
- Nice syntax vs RDF/XML
- Solution: Use several syntaxes
- Semantics
- Clean semantics vs RDF extension
- Representation
- Logical cleanliness vs empirical utility
- Reasoning
- Effective reasoning vs expressive power
DAML+OIL
- Semantic Web version of Description Logics
- Uses RDF syntax
- Semantics derived from Description Logics semantics
- Solution to relationship and semantic tensions
- Highly expressive, but decidable
- Can represent many ontologies
- Incorporates empirically-useful constructs
- Solution to representation and reasoning tensions
Is DAML+OIL the Answer?
- Unfortunately, no.
- DAML+OIL preceded the latest round of work on RDF and RDFS
- Not compatible with new RDF datatyping (easy to fix)
- Not compatible with the new semantics for RDF
- Thus not compatible with the Semantic Web vision
- Thus work needed to be done
Semantic Conformance (part 1)
- Modify DAML+OIL semantics to look like OWL 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:
- Modify OWL semantics to allow metaclasses
- 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 or OWL vocabulary
- E.g., can't use rdf:type as an individual
- E.g., can't use owl:onProperty as a class
- Corresponds to alternative syntax
- (Actually, the alternative syntax corresponds to OWL DL
- Corresponds closely to Description Logic SHOIN(Dn)
- A decidable description logic with NEXPTIME inference
OWL Lite
- OWL DL is still a complex language
- Has several recursive constructs,
e.g., descriptions inside descriptions
- Has several complex constructs,
e.g., unions
- Allows individuals in class definitions
- Want a language that looks even more like frames
- OWL Lite removes several constructs from OWL DL
- Descriptions inside descriptions
- Unions, one of, ...
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 graph extracted from the RDF/XML document carries 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 graph carries 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 graph makes a statement
- Even the triples used to encode OWL syntax
_:a rdf:type owl:Restriction .
_:a owl:onProperty ex:spouse .
_:a owl:allValuesFrom ex:Person .
- 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
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 .
Semantic Conformance (part 2)
- Problem:
-
Semantic Web vision means that all triples (including those needed to
encode complex syntax) make assertions, interfering with entailment
- Solution:
- Add semantic conditions (comprehension principles) that require
the existence of all syntactic constructs
- All finite lists exist
- For each property and description there is an
owl:allValuesFrom restriction with that property and condition
Semantic Conformance (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 Conformance (part 2)
- Solution:
- Alternative Solution:
- Yet Another Solution:
-
Change the Semantic Web Vision (as described later)
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
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 graph extracted from the RDF/XML document carries 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, ...
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/