|
SubscriptionsSites I Read
|
|
|
|
| I am becoming frustrated with the open-world reasoning in OWL. I have created a list ontology as follows:
<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
<!ENTITY dc "http://purl.org/dc/elements/1.1/" >
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
<!ENTITY daml "http://www.daml.org/2001/03/daml+oil#" >
<!ENTITY p1 "http://www.owl-ontologies.com/assert.owl#" >
<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
]>
<rdf:RDF xmlns="http://masaka.cs.ohiou.edu/amitchel/util/list.owl#"
xml:base="http://masaka.cs.ohiou.edu/amitchel/util/list.owl"
xmlns:p1="http://www.owl-ontologies.com/assert.owl#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:daml="http://www.daml.org/2001/03/daml+oil#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:owl="http://www.w3.org/2002/07/owl#">
<owl:Ontology rdf:about=""/>
<owl:Class rdf:ID="EmptyList">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="#hasContents"/>
<owl:maxCardinality rdf:datatype="&xsd;int">0</owl:maxCardinality>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasNext"/>
<owl:maxCardinality rdf:datatype="&xsd;int">0</owl:maxCardinality>
</owl:Restriction>
<owl:Class rdf:about="#List"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#List"/>
<owl:Class>
<owl:complementOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#isFollowedBy"/>
<owl:someValuesFrom rdf:resource="&owl;Thing"/>
</owl:Restriction>
</owl:complementOf>
</owl:Class>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:ObjectProperty rdf:ID="hasContents">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdfs:domain rdf:resource="#List"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="hasNext">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdfs:subPropertyOf rdf:resource="#isFollowedBy"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="isFollowedBy">
<rdf:type rdf:resource="&owl;TransitiveProperty"/>
<rdfs:domain rdf:resource="#List"/>
<rdfs:range>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#List"/>
<owl:Class>
<owl:complementOf rdf:resource="&owl;Thing"/>
</owl:Class>
</owl:unionOf>
</owl:Class>
</rdfs:range>
</owl:ObjectProperty>
<owl:Class rdf:ID="List">
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasContents"/>
<owl:maxCardinality rdf:datatype="&xsd;int">1</owl:maxCardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf>
<owl:Restriction>
<owl:onProperty rdf:resource="#hasNext"/>
<owl:maxCardinality rdf:datatype="&xsd;int">1</owl:maxCardinality>
</owl:Restriction>
</rdfs:subClassOf>
<rdfs:subClassOf rdf:resource="&owl;Thing"/>
</owl:Class>
</rdf:RDF>
I have been testing reasoning on the list class using the following Ontology...
<?xml version="1.0"?>
<!DOCTYPE rdf:RDF [
<!ENTITY owl "http://www.w3.org/2002/07/owl#" >
<!ENTITY dc "http://purl.org/dc/elements/1.1/" >
<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#" >
<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#" >
<!ENTITY daml "http://www.daml.org/2001/03/daml+oil#" >
<!ENTITY p2 "http://www.owl-ontologies.com/assert.owl#" >
<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#" >
<!ENTITY p1 "http://masaka.cs.ohiou.edu/amitchel/util/list.owl#" >
]>
<rdf:RDF xmlns="http://www.owl-ontologies.com/Ontology1157570502.owl#"
xml:base="http://www.owl-ontologies.com/Ontology1157570502.owl"
xmlns:p1="http://masaka.cs.ohiou.edu/amitchel/util/list.owl#"
xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:p2="http://www.owl-ontologies.com/assert.owl#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:daml="http://www.daml.org/2001/03/daml+oil#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:owl="http://www.w3.org/2002/07/owl#">
<owl:Ontology rdf:about="">
<owl:imports rdf:resource="http://masaka.cs.ohiou.edu/amitchel/util/list.owl"/>
</owl:Ontology>
<owl:AllDifferent>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#A"/>
<rdf:Description rdf:about="#B"/>
<rdf:Description rdf:about="#C"/>
<rdf:Description rdf:about="#D"/>
<rdf:Description rdf:about="#E"/>
</owl:distinctMembers>
</owl:AllDifferent>
<owl:AllDifferent>
<owl:distinctMembers rdf:parseType="Collection">
<rdf:Description rdf:about="#one"/>
<rdf:Description rdf:about="#two"/>
<rdf:Description rdf:about="#three"/>
<rdf:Description rdf:about="#four"/>
<rdf:Description rdf:about="#five"/>
<rdf:Description rdf:about="#six"/>
<rdf:Description rdf:about="#seven"/>
<rdf:Description rdf:about="#eight"/>
<rdf:Description rdf:about="#nine"/>
</owl:distinctMembers>
</owl:AllDifferent>
<Character rdf:ID="A"/>
<Character rdf:ID="B"/>
<Character rdf:ID="C"/>
<CharacterItem rdf:ID="Char1">
<p1:hasContents rdf:resource="#A"/>
<p1:hasNext rdf:resource="#Char1"/>
</CharacterItem>
<owl:Class rdf:ID="Character">
<owl:equivalentClass>
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<rdf:Description rdf:about="#A"/>
<rdf:Description rdf:about="#B"/>
<rdf:Description rdf:about="#C"/>
<rdf:Description rdf:about="#D"/>
<rdf:Description rdf:about="#E"/>
</owl:oneOf>
</owl:Class>
</owl:equivalentClass>
<owl:disjointWith rdf:resource="&p1;List"/>
<owl:disjointWith rdf:resource="#Digit"/>
</owl:Class>
<owl:Class rdf:ID="CharacterItem">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="&p1;hasContents"/>
<owl:allValuesFrom rdf:resource="#Character"/>
</owl:Restriction>
<owl:Class rdf:about="&p1;List"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:ID="CharacterList">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#CharacterItem"/>
<owl:Restriction>
<owl:onProperty rdf:resource="&p1;hasNext"/>
<owl:allValuesFrom rdf:resource="#CharacterItem"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<owl:Class rdf:ID="CharListReal">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Class rdf:about="#CharacterItem"/>
<owl:Restriction>
<owl:onProperty rdf:resource="&p1;isFollowedBy"/>
<owl:allValuesFrom rdf:resource="#CharacterItem"/>
</owl:Restriction>
<owl:Restriction>
<owl:onProperty rdf:resource="&p1;isFollowedBy"/>
<owl:someValuesFrom rdf:resource="#CharacterItem"/>
</owl:Restriction>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<Character rdf:ID="D"/>
<owl:Class rdf:ID="Digit">
<owl:equivalentClass>
<owl:Class>
<owl:oneOf rdf:parseType="Collection">
<rdf:Description rdf:about="#eight"/>
<rdf:Description rdf:about="#five"/>
<rdf:Description rdf:about="#four"/>
<rdf:Description rdf:about="#nine"/>
<rdf:Description rdf:about="#one"/>
<rdf:Description rdf:about="#seven"/>
<rdf:Description rdf:about="#six"/>
<rdf:Description rdf:about="#three"/>
<rdf:Description rdf:about="#two"/>
</owl:oneOf>
</owl:Class>
</owl:equivalentClass>
<owl:disjointWith rdf:resource="&p1;List"/>
<owl:disjointWith rdf:resource="#Character"/>
</owl:Class>
<Character rdf:ID="E"/>
<Digit rdf:ID="eight"/>
<p1:EmptyList rdf:ID="EmptyList"/>
<Digit rdf:ID="five"/>
<Digit rdf:ID="four"/>
<owl:ObjectProperty rdf:ID="hasCharacter">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdfs:range rdf:resource="#Character"/>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="hasDigit">
<rdf:type rdf:resource="&owl;FunctionalProperty"/>
<rdfs:range rdf:resource="#Digit"/>
</owl:ObjectProperty>
<p1:List rdf:ID="LetterLetterNum">
<p1:hasContents rdf:resource="#B"/>
<p1:hasNext rdf:resource="#LetterNum"/>
</p1:List>
<p1:List rdf:ID="LetterNum">
<p1:hasContents rdf:resource="#C"/>
<p1:hasNext rdf:resource="#Number"/>
</p1:List>
<p1:List rdf:ID="Name">
<p1:hasContents rdf:resource="#A"/>
<p1:hasNext rdf:resource="#EmptyList"/>
</p1:List>
<Digit rdf:ID="nine"/>
<p1:List rdf:ID="Number">
<p1:hasContents rdf:resource="#one"/>
</p1:List>
<owl:Class rdf:ID="NumberItem">
<owl:equivalentClass>
<owl:Class>
<owl:intersectionOf rdf:parseType="Collection">
<owl:Restriction>
<owl:onProperty rdf:resource="&p1;hasContents"/>
<owl:allValuesFrom rdf:resource="#Digit"/>
</owl:Restriction>
<owl:Class rdf:about="&p1;List"/>
</owl:intersectionOf>
</owl:Class>
</owl:equivalentClass>
</owl:Class>
<Digit rdf:ID="one"/>
<rdf:Description rdf:about="&p1;List">
<owl:disjointWith rdf:resource="#Character"/>
<owl:disjointWith rdf:resource="#Digit"/>
</rdf:Description>
<p1:List rdf:ID="Reflexive">
<p1:hasContents rdf:resource="#B"/>
<p1:hasNext rdf:resource="#Reflexive"/>
</p1:List>
<Digit rdf:ID="seven"/>
<Digit rdf:ID="six"/>
<Digit rdf:ID="three"/>
<Digit rdf:ID="two"/>
</rdf:RDF>
I am trying to create a CharacterList class that encompases all lists that have only characters in them. I have been attempting to utalize the transitive property isFollowedBy for this purpose. Sadly, since transitive properties can not have cardinality constraints attached to them, I have been unable to force closure of any class on this property. I was hopeful that the restriction: p1:isFollowedBy ∀ CharacterItem would cover it since EmptyList is inferred to be a subclass of CharacterItem and EmptyList is restricted by: ¬(p1:isFollowedBy ∃ owl:Thing). Can anyone out there spot the flaw in my logic? Why is not ¬(p1:isFollowedBy ∃ owl:Thing) [read: EmptyList is never followed by anything = EmptyList is followed by nothing] conceptually the same as placing a maxCardinalityConstraint of zero on p1:isFollowedBy [read: EmptyList can be followed by nothing]?
| | |
| Today we will discuss open-world reasoning and the difficulties it poses to our ontology design.
Recall our previous implementation of the N-ary ODP. It included class definitions for SequenceItem and FinalSequenceItem. The two classes are identical except FinalSequenceItem is restricted to individuals who do not have any additional items following them (a maxCardinality of zero on the NextSequence relationship). This means that any SequenceItem without a nextSequence relationship is also a FinalSequenceItem.
Let's define a SequenceItem called testItem with no NextSequence relationship. We might expect our reasoner to classify our testItem as a FinalSequenceItem, since we have not specified a NextSequence relationship. This, however, is not the case. OWL was designed using the open world assumption. In systems utilizing the OWA, facts that are not stated are considered unknown, rather than false. In the testItem example, an open world system can only say that the testItem has at least zero NextSequence relationships. It can not say that it has exactly zero NextSequence relationships, because we have not explicitly stated as much (recall: the omission of a fact does not imply its nonexistence).
This issue comes up again in our definition of CharacterSequenceItem. If we declare an individual, testCharacterItem, from the class SequenceItem with a property value of the Character "K" for the ContainsData relationship, we can not infer that our testCharacterItem is a CharacterSequenceItem. The testCharacterItem could contain other, non-specified, non-character data. If, however, we specify a cardinality-constraint of one for the ContainsData property of a SequenceItem, a reasoner can now infer that our testCharacterItem is, in fact, a CharacterSequenceItem. Since each SequenceItem can have at most one ContainsData property value, we have explicitly constructed a closed-world environment around the ContainsData property.
(More on this tomorrow... this post needs edited too... it's not very easy to read. Does anyone understand anything I've said here today? How can I make it more clear?)
| | |
| In order to model protocol specifics and text-based objects (e.g. email messages) we need to be able to describe an ordered string of characters in OWL. We will attempt to do this using the N-ary Ontology Design Pattern (ODP). (Note: I can not yet determine how this application of the N-ary ODP differs from the List ODP. Reader feedback on this subject will be appriciated.) I'm not 100% convinced of the correctness of the first attempt below. More work needs to be done on verification; however, it is shown here for postarity.
| | |
| Printed out four papers to read. Yes, I know the reading phase should be over, but I haven't worked on this for over a month, so I need a quick refresher.
| | |
| Today we lay out the basis for modeling response capabilities within an ontology. This functionality will allow us to configure an IDS to work with multiple response agents by comparing the response capabilities of those agents with the needs of the system.
| | |
|
