Original Abstract

Recent investigations have uncovered some problems in the relationship between DAML+OIL and the new RDF model theory. There are several ways of remedying these problems, resulting in greater or lesser compatability with RDF. One possible remedy is to diverge from the RDF philosophy only on statements about descriptions, resulting in a complex web ontology language containing a description logic and that is compatible with RDF. Another possible remedy is to remain compatible with RDF only on statements about individuals, resulting in a semantic web ontology language that is very close to standard description logics, but that is not fully compatible with RDF.

New Abstract

To transform description logics into a Semantic Web Ontology Language requires careful consideration of the existing Web Language, including XML, XML Schema, RDF, and RDF Schema. Not only do the actual languages need to be considered, but also their desired places in the larger Semantic Web vision as these desires may have undesirable consequences. There are thus a large number of possible ways of producing a Semantic Web Ontology Language based on description logics, with differing characteristics.

Semantic Web Vision

1. Bring structure to web pages
2. Permit software agents to carry out sophisticated tasks for users
3. Extension of the current web

(Tim Berners-Lee, James Hendler, and Ora Lassila. ``The Semantic Web''. Scientific American, May 2001.)

Semantic Web Tower

Semantic Web Tower (from Tim Berners-Lee)

Requirements for Semantic Web Languages

Form: The language(s) used in the semantic web need well-defined syntax.

• Otherwise software agents cannot determine what constructs they are using.

Meaning: The language(s) used in the semantic web need well-defined semantics.

• Otherwise software agents cannot determine what the constructs that are using mean.

Elements of the Semantic Web Tower

• XML - eXtensible Markup Language , including namespaces
• XML Schema
• RDF - Resource Description Framework
• RDF Schema
• DAML+OIL , an ontology language
• other elements do not yet exist

The Current Vision of the Semantic Web Tower

• XML is the base syntactic language for the Semantic Web.
  • All Semantic Web languages can be written in XML dialects.
  • The meaning of Semantic Web language is not necessarily related to their XML meaning.
• RDF is the base language for the Semantic Web.
  • All Semantic Web languages use RDF for their syntax.
  • All Semantic Web languages build on RDF for their semantics.

Rationale for the Current Vision

• XML is supposed to be the mechanism for defining all Web languages.
  • XML Schema, XML ..., RDF, RDF Schema, OIL, ....
  • Different languages are in different documents.
  • Base data is contained in XML documents.
  • XML systems can parse all Web documents, but will not understand them.
• RDF is supposed to be the mechanism for defining all Semantic Web languages.
  • RDF Schema, ....
  • Different languages are in the same document.
  • All information is contained in RDF documents.
  • RDF systems should be able to parse and (partially) understand all Semantic Web documents.

Problems with the Semantic Web Vision

1. Disconnects at the Foundation (not this talk)
   • The XML meaning is not used, so data written in XML cannot be used in the Semantic Web.
   • XML Schema is not used in the Semantic Web languages.
   • Ignore this problem, for now, and assume that RDF data is the foundation of the Web.
2. An Inadequate Basis
   • RDF is inadequate for providing either syntax or semantics for the entire Semantic Web.

RDF as an Inadequate Basis

• RDF syntax is triples, with little or no other organization.
  • subject, predicate, object
  • No possibility of variables, etc.
• All RDF triples are asserted facts.
  • No possibility of disjunctions, etc.

An Inadequate Basis (daml+oil-ex.daml extracts)

<rdf:RDF ... >

<daml:Ontology rdf:about="">
  <daml:versionInfo>$Id: ....>
  <daml:imports rdf:resource=".../daml+oil"/>
</daml:Ontology>

<daml:Class rdf:ID="Senior">
  <daml:intersectionOf rdf:parseType="daml:collection">
    <daml:Class rdf:about="#Person"/>
    <daml:Restriction>
      <daml:onProperty rdf:resource="#age"/>
      <daml:hasClass rdf:resource=".../daml+oil-ex-dt#over59"/>
    </daml:Restriction>
  </daml:intersectionOf>
</daml:Class>  

An Inadequate Basis (daml+oil-ex.daml extracts)

<daml:Class rdf:ID="Height">
  <daml:oneOf rdf:parseType="daml:collection">
    <Height rdf:ID="short"/>
    <Height rdf:ID="medium"/>
    <Height rdf:ID="tall"/>
  </daml:oneOf>
</daml:Class>
<daml:Class rdf:ID="TallThing">
  <daml:sameClassAs>
    <daml:Restriction>
      <daml:onProperty rdf:resource="#hasHeight"/>
      <daml:hasValue rdf:resource="#tall"/>
    </daml:Restriction>
  </daml:sameClassAs>
</daml:Class>
</rdf:RDF>  

Syntax Problems

• Triples make syntax unnatural.
  • Restrictions have to be split up.
  • Collections have to split up.
    • DAML+OIL defines a special syntax extension for collections.
• Triples allow for deviant syntax.
  • Restrictions with too many pieces.
  • Collections with missing or multiple components.
• Triples allow additions at any time.
  • Can't forbid new triples attached to old syntax.

Semantic Problems

• Everything is triples; all triples have meaning.
• All aspects of syntax contribute to meaning.
  • e.g., ordering in collections
  • the intersection of Student and Employee is different from the intersection of Employee and Student
• All syntax refers to something.
  • e.g., descriptions live in the domain
  • to infer membership in a description, the description has to exist
• The instance and subclass relationships are properties
  • thus can be used in descriptions
• Classes and properties are also individuals
  • thus their properties as individuals can change their behaviour

Semantic Problems - A Theory of Classes

A Desirable Inference:

Premises:

John is an instance of Student.
John is an instance of Employee.

Conclusion:

John is an instance of the intersection of Student and Employee.

• In an RDF extension, this requires that the intersection automatically exists whenever Student and Employee exists.
• Many more of these examples can be devised.

Semantic Problems - A Theory of Classes

A Unfortunate Inference:

Premise:

Conclusion 1:

rdf:type is an instance of the restriction whose instances do not have an rdf:type link to the restriction itself.

Conclusion 2:

rdf:type is not an instance of the restriction whose instances do not have an rdf:type link to the restriction itself.

Computational Problems - Contingent Properties of Properties

<rdf:Property rdf:about="bar">
  <rdfs:subPropertyOf rdf:resource="bbb" />
</rdf:Property>

<rdf:Property rdf:about="baz">
  <rdfs:subPropertyOf rdf:resource="bbb" />
</rdf:Property>

Computational Problems - Contingent Properties of Properties

<Person rdf:about="Jake">

  <rdf:type> 
     <Restriction property="foo" toClass="TransitiveProperty" /> 
  </rdf:type>

  <rdf:type>
     <Restriction property="foo">
       <hasClass> <oneOf> bar baz </oneOf> </hasClass>
     </Restriction>
  </rdf:type>

</Person>

Computational Problems - Contingent Properties of Properties

<Person rdf:about="John">
  <bar rdf:resource="Jill" />
  <bar rdf:resource="Mary" />
</Person>

<Person rdf:about="Jill">
  <bar rdf:resource="Susan" />
</Person>

<Person rdf:about="Mary">
  <bar rdf:resource="Susan" />
</Person>

Solving the Problems

• Allow for non-RDF syntax
  • Syntax that does not denote
    • fixes the paradoxes
  • Syntax that is not triples
    • allow for much nicer syntax
• Don't make classes and properties also be individuals
  • Contingent facts about individuals can't change the status of classes and properties.

A Better Basis

• Treat RDF (or XML) as a language for providing facts.
• Use different syntaxes for the other Semantic Web languages.
  • e.g., (part of) OIL for Ontologies
• Similar to the situation with XML and XML Schema.

A Possible Ontology Language

A Possible Ontology Language - Example

<fowl:Ontology ...>

<DefinedClass ID="Woman">
   <superClasses>
     <class ID="Person" />
     <class ID="Female" />
   </superClasses>
</DefinedClass>

<DefinedClass ID="MarriedPerson">
   <superClasses>
     <class ID="Person" />
   </superClasses>
   <slot property="hasSpouse" required="true" singlevalued="true" />
</DefinedClass>

</fowl:Ontology> 

DAML+OIL Version

<rdf:RDF ... >

<daml:Class rdf:ID="Woman">
  <daml:sameClassAs>
    <daml:intersectionOf rdf:parseType="daml:collection">
      <daml:Class rdf:about="#Person"/>
      <daml:Class rdf:about="#Female"/>
    </daml:intersectionOf>
  </daml:sameClassAs>
</daml:Class>

...

</rdf:RDF>

DAML+OIL Version

<daml:Class rdf:ID="Woman">
  <daml:sameClassAs>
    <daml:intersectionOf rdf:parseType="daml:collection">
      <daml:Class rdf:about="#Person"/>
      <daml:Restriction>
	<daml:onProperty daml:minCardinality="1">
	  <rdf:Property rdf:about="#hasSpouse"/>
	</daml:onProperty>
      </daml:Restriction>
      <daml:Restriction>
	<daml:onProperty daml:maxCardinality="1">
	  <rdf:Property rdf:about="#hasSpouse"/>
	</daml:onProperty>
      </daml:Restriction>
    </daml:intersectionOf>
  </daml:sameClassAs>
</daml:Class> 

Where are We Now?

The WebOnt language

• will be description-logic based
• will probably use triple syntax
  • but will not have all these triples denote
• will probably not allow properties of individuals to affect the behaviour of classes and properties
• will probably be decidable
• will probably be more powerful than description logics with known nicely-behaving inference
• will probably be close to SHOIQ with simple concrete domains