ontology file //Re: Question about Drool reasoning (Lorenz Buehmann)

classic Classic list List threaded Threaded
2 messages Options
Reply | Threaded
Open this post in threaded view
|

ontology file //Re: Question about Drool reasoning (Lorenz Buehmann)

claire qiu
Hi Lorenz,

I have attached the ontology. 
For the simplicity, I rewrote the KB as following :

Rules:
SmallApple(x) <-  Apple(x), hasSize(x,y),Small(y).
HappyKid(x)  <->  hasObject(x,y),SmallApple(y).

facts:
Apple(Apple1), Small(Small1), hasSize(Apple1,Small1), hasObject(Jimmy,Apple1).

As far as my understanding, Jimmy is a HappyKid should be a logical consequence.

Maybe I understood the reasoning mechanism of Drool wrongly. 

Please share you insights. Thanks

Best,
Claire

On Tue, Jun 27, 2017 at 9:05 PM, <[hidden email]> wrote:
Send protege-user mailing list submissions to
        [hidden email]

To subscribe or unsubscribe via the World Wide Web, visit
        https://mailman.stanford.edu/mailman/listinfo/protege-user
or, via email, send a message with subject or body 'help' to
        [hidden email]

You can reach the person managing the list at
        [hidden email]

When replying, please edit your Subject line so it is more specific
than "Re: Contents of protege-user digest..."


Today's Topics:

   1. Re: Sparql help for subClassOf (sb)
   2. Re: Question about Drool reasoning (Martin O'Connor)
   3. Re: SWRLTab syntax error (Martin O'Connor)
   4. Re: Problem with OWL viz (Nick89)
   5. Re: Question about Drool reasoning (Lorenz Buehmann)
   6. Re: Question about Drool reasoning (Lorenz Buehmann)
   7. Re: Question about Drool reasoning (Lorenz Buehmann)
   8. "Intelligent" support for ontology merging/mapping?! (Nick89)
   9. Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  10. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Lorenz Buehmann)
  11. Re: Why don't OWL individuals automatically get   assigned all
      properties of their class and superclasses? (Adila Alfa Krisnadhi)
  12. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  13. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  14. Re: Why don't OWL individuals automatically       get     assigned all
      properties of their class and superclasses? (Jos Lehmann)
  15. Re: Why don't OWL individuals automatically get   assigned all
      properties of their class and superclasses? (Adila Alfa Krisnadhi)
  16. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Lorenz Buehmann)
  17. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  18. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  19. Re: Question about Drool reasoning (Martin O'Connor)
  20. Re: Question about Drool reasoning (Martin O'Connor)
  21. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Lorenz Buehmann)
  22. Re: Why don't OWL individuals automatically get   assigned all
      properties of their class and superclasses? (Adila Alfa Krisnadhi)
  23. Re: Question about Drool reasoning (Samson Tu)
  24. Re: Help regarding the Classes present in PROV-O (Samson Tu)
  25. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Michael DeBellis)
  26. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Dave McComb)


----------------------------------------------------------------------

Message: 1
Date: Mon, 26 Jun 2017 13:22:41 -0700 (PDT)
From: sb <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Sparql help for subClassOf
Message-ID: <[hidden email]>
Content-Type: text/plain; charset=us-ascii

Dear All,

I solved my problem via the code below. Before I was making a structural
mistake.

PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX radlex:
<http://bioontology.org/projects/ontologies/radlex/radlexOwlDlComponent#>

SELECT DISTINCT ?term ?name ?synonym ?subClassOf ?subClassOf_name
FROM <http://bioportal.bioontology.org/ontologies/RID>
WHERE
{
 ?term radlex:Preferred_name ?name .
 ?term radlex:Synonym ?synonym .
 ?term rdfs:subClassOf ?subClassOf .
  ?subClassOf radlex:Preferred_name ?subClassOf_name
}  LIMIT 100



--
View this message in context: http://protege-project.136.n4.nabble.com/Sparql-help-for-subClassOf-tp4668886p4668934.html
Sent from the Protege User mailing list archive at Nabble.com.


------------------------------

Message: 2
Date: Tue, 27 Jun 2017 02:06:02 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="us-ascii"


Can you send the ontology to me.

It is possible that the OWL 2 RL profile supported by the SWRLTab does not support this conclusion (though I think it should).

Martin

On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]<mailto:[hidden email]>> wrote:

Claire already shares her ontology.

The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.

The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.

With best regards,
Samson


On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email]<mailto:[hidden email]>> wrote:


I'm wondering how HemiT can infer this...

We still have the open world assumption, i.e. the conclusion that

:Apple1 rdf:type :SmallApple

is not possible - given that I did not overlook something.

Can you share the ontology?

On <a href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
Hi,
here is my modelling:
#    Object Properties
:hasObject rdf:type owl:ObjectProperty ;
           rdfs:subPropertyOf owl:topObjectProperty .
:hasSize rdf:type owl:ObjectProperty ,
                  owl:FunctionalProperty .

#    Classes
:Apple rdf:type owl:Class .
:HappyKid rdf:type owl:Class ;
          owl:equivalentClass [ rdf:type owl:Restriction ;
                                owl:onProperty :hasObject ;
                                owl:someValuesFrom :SmallApple
                              ] .
:Small rdf:type owl:Class .
:SmallApple rdf:type owl:Class ;
            owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:someValuesFrom :Small
                                                       ]
                                                       [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:allValuesFrom :Small
                                                       ]
                                                     ) ;
                                  rdf:type owl:Class
                                ] .

#    Individuals
:Apple1 rdf:type owl:NamedIndividual ,
                 :Apple ;
        :hasSize :Small1 .
:Jimmy rdf:type owl:NamedIndividual ;
       :hasObject :Apple1 .
:Small1 rdf:type owl:NamedIndividual ,
                 :Small .

SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)


After run the Drool, it cannot infer that Jimmy is a HappyKid.


But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.

Can someone please explain the differences?

Best,
Claire




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/9d25e39e/attachment-0001.html>

------------------------------

Message: 3
Date: Tue, 27 Jun 2017 03:39:02 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] SWRLTab syntax error
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"


I have fixed this problem. The SWRL editor no longer performs annotation-based rendering of OWL entity names.

A new 2.0.2 version of the SWRLTab plugin is available on Maven Central. Update in Protege via File->Check for plugins?.

Martin

On Jun 26, 2017, at 9:02 AM, Davide Sottara <[hidden email]<mailto:[hidden email]>> wrote:

I found the same issue a few days ago and was about to report it.

I can confirm the editor does not work with labels, and shows the labels even when 'View by IRI/prefixed name" is set

I am using Protege 5.2, on Linux, with SWRLTab 2.0.1 (Jun 24th)

Thanks!

On Mon, Jun 26, 2017 at 10:32 AM, Martin O'Connor <[hidden email]<mailto:[hidden email]>> wrote:

It looks like the SWRLTab is picking up your label-based entity name rendering preference and complaining because it cannot yet handle labels as names for OWL entities.

I will try to fix that issue this week. In the meantime, you could switch to rendering entity names by short or prefixed form using the following menu options:

View->Render by prefixed name
View->Render by entity IRI short name (id)

Martin

> On Jun 26, 2017, at 4:55 AM, claire Qiu <[hidden email]<mailto:[hidden email]>> wrote:
>
> Hi,
> I have added a rule as shown below.
> <image.png>
>
> But after I saved it and reopen it, it shows syntactical error:
> <image.png>
>
> it used the label instead of the IRI name.
>
> My SWRLTable version is:2.0.1
>
> Thanks in advance!
>
> Best,
> Claire
> _______________________________________________
> protege-user mailing list
> [hidden email]<mailto:[hidden email]>
> https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/01e4d537/attachment-0001.html>

------------------------------

Message: 4
Date: Tue, 27 Jun 2017 00:46:44 -0700 (PDT)
From: Nick89 <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Problem with OWL viz
Message-ID: <[hidden email]>
Content-Type: text/plain; charset=us-ascii

Hi Gracie,

It worked.

I actually didn't even have this additional Graphviz-Thing installed.
I downloaded Graphviz, pasted it into the Protege plugin folder and directed
the settings-path to it. That's it.

Thank you for your support!



--
View this message in context: http://protege-project.136.n4.nabble.com/Problem-with-OWL-viz-tp4668925p4668937.html
Sent from the Protege User mailing list archive at Nabble.com.


------------------------------

Message: 5
Date: Tue, 27 Jun 2017 10:23:13 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

@Samson: Right, but not a complete document such that one could load it
e.g. into Protege for debugging.

Cheers,

Lorenz


On <a href="tel:26.06.2017%2020" value="+12606201720">26.06.2017 20:53, Samson Tu wrote:
> Claire already shares her ontology.
>
> The property hasSize is functional. Given that Apple1 hasSize Small1
> (of type Small), Apple1 is a SmallApple.
>
> The Drool-based SWRLTab should have concluded that Jimmie is a
> HappyKid w/o the equivalence definition of HappyKid. The Pellet
> reasoner uses the SWRL rule to make that conclusion.
>
> /With best regards,/
> /Samson/
>
>
>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann
>> <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>> I'm wondering how HemiT can infer this...
>>
>> We still have the open world assumption, i.e. the conclusion that
>>
>> :Apple1 rdf:type :SmallApple
>>
>> is not possible - given that I did not overlook something.
>>
>> Can you share the ontology?
>>
>>
>> On <a href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
>>> Hi,
>>> here is my modelling:
>>>
>>>     *#    Object Properties*
>>>     :hasObject rdf:type owl:ObjectProperty ;
>>>                rdfs:subPropertyOf owl:topObjectProperty .
>>>     :hasSize rdf:type owl:ObjectProperty ,
>>>                       owl:FunctionalProperty .
>>>
>>>
>>>
>>>     *#    Classes*
>>>     :Apple rdf:type owl:Class .
>>>     :HappyKid rdf:type owl:Class ;
>>>               owl:equivalentClass [ rdf:type owl:Restriction ;
>>>                                     owl:onProperty :hasObject ;
>>>                                     owl:someValuesFrom :SmallApple
>>>                                   ] .
>>>     :Small rdf:type owl:Class .
>>>     :SmallApple rdf:type owl:Class ;
>>>                 owl:equivalentClass [ owl:intersectionOf ( [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:someValuesFrom :Small
>>>                                                            ]
>>>                                                            [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:allValuesFrom :Small
>>>                                                            ]
>>>                                                          ) ;
>>>                                       rdf:type owl:Class
>>>                                     ] .
>>>
>>>     *#    Individuals*
>>>     :Apple1 rdf:type owl:NamedIndividual ,
>>>                      :Apple ;
>>>             :hasSize :Small1 .
>>>     :Jimmy rdf:type owl:NamedIndividual ;
>>>            :hasObject :Apple1 .
>>>     :Small1 rdf:type owl:NamedIndividual ,
>>>                      :Small .
>>>
>>>     *SWRL rule:*  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>
>>>
>>>
>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>
>>>
>>> But, if I model HappyKid as a class: /HappyKid isEquvilentTo
>>> hasObject some SmallApple/, the Hermit reasoner can infer that Jimmy
>>> is a HappyKid.
>>>
>>> Can someone please explain the differences?
>>>
>>> Best,
>>> Claire
>>>
>>>
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email]
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/a7470295/attachment-0001.html>

------------------------------

Message: 6
Date: Tue, 27 Jun 2017 10:24:32 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

By the way, I overlooked the functionality of :hasSize.

Indeed, you're right. anyways, loading the ontology in Protege and using
the explanation feature would have been easier for me :D


Cheers,

Lorenz


On <a href="tel:26.06.2017%2020" value="+12606201720">26.06.2017 20:53, Samson Tu wrote:
> Claire already shares her ontology.
>
> The property hasSize is functional. Given that Apple1 hasSize Small1
> (of type Small), Apple1 is a SmallApple.
>
> The Drool-based SWRLTab should have concluded that Jimmie is a
> HappyKid w/o the equivalence definition of HappyKid. The Pellet
> reasoner uses the SWRL rule to make that conclusion.
>
> /With best regards,/
> /Samson/
>
>
>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann
>> <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>> I'm wondering how HemiT can infer this...
>>
>> We still have the open world assumption, i.e. the conclusion that
>>
>> :Apple1 rdf:type :SmallApple
>>
>> is not possible - given that I did not overlook something.
>>
>> Can you share the ontology?
>>
>>
>> On <a href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
>>> Hi,
>>> here is my modelling:
>>>
>>>     *#    Object Properties*
>>>     :hasObject rdf:type owl:ObjectProperty ;
>>>                rdfs:subPropertyOf owl:topObjectProperty .
>>>     :hasSize rdf:type owl:ObjectProperty ,
>>>                       owl:FunctionalProperty .
>>>
>>>
>>>
>>>     *#    Classes*
>>>     :Apple rdf:type owl:Class .
>>>     :HappyKid rdf:type owl:Class ;
>>>               owl:equivalentClass [ rdf:type owl:Restriction ;
>>>                                     owl:onProperty :hasObject ;
>>>                                     owl:someValuesFrom :SmallApple
>>>                                   ] .
>>>     :Small rdf:type owl:Class .
>>>     :SmallApple rdf:type owl:Class ;
>>>                 owl:equivalentClass [ owl:intersectionOf ( [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:someValuesFrom :Small
>>>                                                            ]
>>>                                                            [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:allValuesFrom :Small
>>>                                                            ]
>>>                                                          ) ;
>>>                                       rdf:type owl:Class
>>>                                     ] .
>>>
>>>     *#    Individuals*
>>>     :Apple1 rdf:type owl:NamedIndividual ,
>>>                      :Apple ;
>>>             :hasSize :Small1 .
>>>     :Jimmy rdf:type owl:NamedIndividual ;
>>>            :hasObject :Apple1 .
>>>     :Small1 rdf:type owl:NamedIndividual ,
>>>                      :Small .
>>>
>>>     *SWRL rule:*  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>
>>>
>>>
>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>
>>>
>>> But, if I model HappyKid as a class: /HappyKid isEquvilentTo
>>> hasObject some SmallApple/, the Hermit reasoner can infer that Jimmy
>>> is a HappyKid.
>>>
>>> Can someone please explain the differences?
>>>
>>> Best,
>>> Claire
>>>
>>>
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email]
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/633fa752/attachment-0001.html>

------------------------------

Message: 7
Date: Tue, 27 Jun 2017 10:27:09 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

@Martin

OWL RL does not support owl:allValuesFrom in a subclass expression [1]
which makes the equivalence axiom working only in one direction.


Cheers,

Lorenz


[1] https://www.w3.org/TR/owl2-profiles/#Class_Expressions_3


On <a href="tel:27.06.2017%2004" value="+12706201704">27.06.2017 04:06, Martin O'Connor wrote:
>
> Can you send the ontology to me.
>
> It is possible that the OWL 2 RL profile supported by the SWRLTab does
> not support this conclusion (though I think it should).
>
> Martin
>
>> On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>> Claire already shares her ontology.
>>
>> The property hasSize is functional. Given that Apple1 hasSize Small1
>> (of type Small), Apple1 is a SmallApple.
>>
>> The Drool-based SWRLTab should have concluded that Jimmie is a
>> HappyKid w/o the equivalence definition of HappyKid. The Pellet
>> reasoner uses the SWRL rule to make that conclusion.
>>
>> /With best regards,/
>> /Samson/
>>
>>
>>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann
>>> <[hidden email]
>>> <mailto:[hidden email]>> wrote:
>>>
>>> I'm wondering how HemiT can infer this...
>>>
>>> We still have the open world assumption, i.e. the conclusion that
>>>
>>> :Apple1 rdf:type :SmallApple
>>>
>>> is not possible - given that I did not overlook something.
>>>
>>> Can you share the ontology?
>>>
>>>
>>> On <a href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
>>>> Hi,
>>>> here is my modelling:
>>>>
>>>>     *#    Object Properties*
>>>>     :hasObject rdf:type owl:ObjectProperty ;
>>>>                rdfs:subPropertyOf owl:topObjectProperty .
>>>>     :hasSize rdf:type owl:ObjectProperty ,
>>>>                       owl:FunctionalProperty .
>>>>
>>>>
>>>>
>>>>     *#    Classes*
>>>>     :Apple rdf:type owl:Class .
>>>>     :HappyKid rdf:type owl:Class ;
>>>>               owl:equivalentClass [ rdf:type owl:Restriction ;
>>>>                                     owl:onProperty :hasObject ;
>>>>                                     owl:someValuesFrom :SmallApple
>>>>                                   ] .
>>>>     :Small rdf:type owl:Class .
>>>>     :SmallApple rdf:type owl:Class ;
>>>>                 owl:equivalentClass [ owl:intersectionOf ( [
>>>>     rdf:type owl:Restriction ;
>>>>
>>>>      owl:onProperty :hasSize ;
>>>>
>>>>      owl:someValuesFrom :Small
>>>>                                                            ]
>>>>                                                            [
>>>>     rdf:type owl:Restriction ;
>>>>
>>>>      owl:onProperty :hasSize ;
>>>>
>>>>      owl:allValuesFrom :Small
>>>>                                                            ]
>>>>                                                          ) ;
>>>>                                       rdf:type owl:Class
>>>>                                     ] .
>>>>
>>>>     *#    Individuals*
>>>>     :Apple1 rdf:type owl:NamedIndividual ,
>>>>                      :Apple ;
>>>>             :hasSize :Small1 .
>>>>     :Jimmy rdf:type owl:NamedIndividual ;
>>>>            :hasObject :Apple1 .
>>>>     :Small1 rdf:type owl:NamedIndividual ,
>>>>                      :Small .
>>>>
>>>>     *SWRL rule:*  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>>
>>>>
>>>>
>>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>>
>>>>
>>>> But, if I model HappyKid as a class: /HappyKid isEquvilentTo
>>>> hasObject some SmallApple/, the Hermit reasoner can infer that
>>>> Jimmy is a HappyKid.
>>>>
>>>> Can someone please explain the differences?
>>>>
>>>> Best,
>>>> Claire
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> protege-user mailing list
>>>> [hidden email]
>>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email] <mailto:[hidden email]>
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/44199008/attachment-0001.html>

------------------------------

Message: 8
Date: Tue, 27 Jun 2017 01:39:32 -0700 (PDT)
From: Nick89 <[hidden email]>
To: [hidden email]
Subject: [protege-user] "Intelligent" support for ontology
        merging/mapping?!
Message-ID: <[hidden email]>
Content-Type: text/plain; charset=us-ascii

Hey,

I'm new to Protege, but i already have a certain problem.

I have two differently structured ontologies and i want to merge/map them
together.

<http://protege-project.136.n4.nabble.com/file/n4668941/Ontology_mapping.png>

Yes - I'm aware that there is the functionality *Refactor *> *Merge*. But
all that gives it to me is just writing both ontology trees one under the
other.

What I want is a programme intelligence telling me: "Hey, there is already a
concept called 'Laptops Dell'. Do you want to transfer this concept to the
other one?".

Or: "Hey, there is already a concept called 'Accessories', but the
subclasses are different. Should the concept be transferred by giving you
the possibility to choose one subclass as a superior class of the other
subclass?"

I read about this PROMPT plug-in, but I also read that it's not supported by
Protege 5.2.0 anymore.

Thanks for any help!

Greetz
Nick



--
View this message in context: http://protege-project.136.n4.nabble.com/Intelligent-support-for-ontology-merging-mapping-tp4668941.html
Sent from the Protege User mailing list archive at Nabble.com.


------------------------------

Message: 9
Date: Tue, 27 Jun 2017 10:17:38 +0000
From: Jos Lehmann <[hidden email]>
To: "[hidden email]"
        <[hidden email]>
Subject: [protege-user] Why don't OWL individuals automatically get
        assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="us-ascii"

Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/f68ef5a6/attachment-0001.html>

------------------------------

Message: 10
Date: Tue, 27 Jun 2017 12:23:47 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

Automatically asserted? How? What would be the automatic value of
`hasYearOfDeath`?


On <a href="tel:27.06.2017%2012" value="+12706201712">27.06.2017 12:17, Jos Lehmann wrote:
>
> Hi there
>
>
>
> A general question: is there reference explaining why, when creating
> an OWL individual (socrates) of a class (Human subClassOf Mortal), all
> properties of that class and of its superclasses (Mortal subClassOf
> hasYearOfDeath) are not automatically asserted for the created
> individual? Is an implicit assertion made, i.e. inconsistency arises
> only in case properties are asserted for the individual that
> contradict properties stated in the class/superclasses?
>
>
>
> Thanks, Jos
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/45063ec1/attachment-0001.html>

------------------------------

Message: 11
Date: Tue, 27 Jun 2017 06:45:32 -0400
From: Adila Alfa Krisnadhi <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

Hi,

I think, the reason behind your question is because you are confusing OWL with object-oriented languages: they are completely different.

In object-oriented (programming) languages, properties are understood as members of some class. That?s why it makes sense to say ?properties of a class?, and moreover, semantics of inheritance may allow properties of a class to be inherited by its subclass or instances of its subclass.

In contrast, in OWL, there is no such thing as properties of a class. Properties are first class citizens of the language, that is, they can be declared in an ontology without being attached to a class.

To your question, when you create an individual socrates and asserts it to be an instance of a class Human, you actually only say that socrates is an element of the set the class Human refers to. (This is the precise reading of ?socrates is a Human? in OWL).
If you then have a subclass axiom: Human subClassOf Mortal, then this subclass axiom together with your previous assertion regarding socrates allow you to infer that socrates is an element of the set that the class Mortal refers to, but nothing more than that.

Your other statement ?Mortal subClassOf hasYearOfDeath? is an illegal statement in OWL, i.e., a syntactic error. In OWL, you can say any of the following:

1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.

Other choices will lead to other consequences.

?adila


> On Jun 27, 2017, at 6:17 AM, Jos Lehmann <[hidden email]> wrote:
>
> Hi there
>
> A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?
>
> Thanks, Jos
> _______________________________________________
> protege-user mailing list
> [hidden email] <mailto:[hidden email]>
> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/e011d77f/attachment-0001.html>

------------------------------

Message: 12
Date: Tue, 27 Jun 2017 10:53:03 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On <a href="tel:27.06.2017%2012" value="+12706201712">27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos




_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/f71979e8/attachment-0002.html>

------------------------------

Message: 13
Date: Tue, 27 Jun 2017 10:53:03 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos




_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/f71979e8/attachment-0003.html>

------------------------------

Message: 14
Date: Tue, 27 Jun 2017 11:00:23 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="utf-8"

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.


Von: protege-user [mailto:[hidden email]] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 12:46
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi,

I think, the reason behind your question is because you are confusing OWL with object-oriented languages: they are completely different.

In object-oriented (programming) languages, properties are understood as members of some class. That?s why it makes sense to say ?properties of a class?, and moreover, semantics of inheritance may allow properties of a class to be inherited by its subclass or instances of its subclass.

In contrast, in OWL, there is no such thing as properties of a class. Properties are first class citizens of the language, that is, they can be declared in an ontology without being attached to a class.

To your question, when you create an individual socrates and asserts it to be an instance of a class Human, you actually only say that socrates is an element of the set the class Human refers to. (This is the precise reading of ?socrates is a Human? in OWL).
If you then have a subclass axiom: Human subClassOf Mortal, then this subclass axiom together with your previous assertion regarding socrates allow you to infer that socrates is an element of the set that the class Mortal refers to, but nothing more than that.

Your other statement ?Mortal subClassOf hasYearOfDeath? is an illegal statement in OWL, i.e., a syntactic error. In OWL, you can say any of the following:

1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

Jos


Other choices will lead to other consequences.

?adila


On Jun 27, 2017, at 6:17 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos
_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/be0635be/attachment-0001.html>

------------------------------

Message: 15
Date: Tue, 27 Jun 2017 07:34:49 -0400
From: Adila Alfa Krisnadhi <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

Hi Jos,

See my response at the end.

> On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]> wrote:
>
> Hi Adila
>
> Thank you for your detailed reply. See my question below toward the end of you reply.
>
>
>
> 1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
> 1a. Mortal subClassOf hasYearOfDeath some C
> 1b. Mortal subClassOf hasYearOfDeath only C
> 1c. Mortal subClassOf hasYearOfDeath min n C
> 1d. Mortal subClassOf hasYearOfDeath max n C
> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>
> 2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
> 2a. Mortal subClassOf hasYearOfDeath some DR
> 2b. Mortal subClassOf hasYearOfDeath only DR
> 2c. Mortal subClassOf hasYearOfDeath min n DR
> 2d. Mortal subClassOf hasYearOfDeath max n DR
>
> Which expression did you intend to have?
>
> If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
> If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.
>
>
> Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they?re solving is ontology consistency problem. That is, the question: ?Is the input ontology consistent??
The question is equivalent to asking ?Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?? (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer ?Yes, the ontology is consistent? because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the reasoner would answer with ?yes?. Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don?t know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

?adila









-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/39d5be2c/attachment-0001.html>

------------------------------

Message: 16
Date: Tue, 27 Jun 2017 14:18:31 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

That's not possible. What would be the "default value"? Who decides on
the default value? And how would you define that in OWL? OWL is the base
language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the
definition of such an axiom needs a value and anything in Protege is
based on the allowed OWL axioms and other constructs only.


On 27.06.2017 12:53, Jos Lehmann wrote:
>
> Hi Lorenz
>
>
>
> I mean: asserting the property when creating the individual either
> with a default value (e.g. not asserted) or without a value at all (I
> know that is not possible in Prot?g?, but I am not sure why that is
> the case).
>
>
>
> In my example:
>
>
>
> ?         Why, when creating the individual socrates TypeOf Human,
> doesn?t socrates automatically get, for instance, hasLiteracyLevel
> (for the sake of the example, I am assuming this property is
> introduced on/defining of class Human) with a default value or no
> asserted value (for sake of the example, the property would range on a
> numeric scale 0 to 5)?
>
> ?         Also why, after deducing socrates TypeOf Mortal, doesn?t
> socrates get, for instance, hasYearOfDeath (for the sake of the
> example I am assuming this property is introduced on/defining of class
> Mortal) with a default value or no asserted value (the property would
> range on a calendar)?
>
>
>
>
>
> Thanks Jos
>
>
>
>
>
> *Von:*protege-user [mailto:[hidden email]]
> *Im Auftrag von *Lorenz Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 12:24
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically
> get assigned all properties of their class and superclasses?
>
>
>
> Automatically asserted? How? What would be the automatic value of
> `hasYearOfDeath`?
>
>
>
> On 27.06.2017 12:17, Jos Lehmann wrote:
>
>     Hi there
>
>
>
>     A general question: is there reference explaining why, when
>     creating an OWL individual (socrates) of a class (Human subClassOf
>     Mortal), all properties of that class and of its superclasses
>     (Mortal subClassOf hasYearOfDeath) are not automatically asserted
>     for the created individual? Is an implicit assertion made, i.e.
>     inconsistency arises only in case properties are asserted for the
>     individual that contradict properties stated in the
>     class/superclasses?
>
>
>
>     Thanks, Jos
>
>
>
>
>     _______________________________________________
>
>     protege-user mailing list
>
>     [hidden email]
>     <mailto:[hidden email]>
>
>     https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/cadeb9f0/attachment-0001.html>

------------------------------

Message: 17
Date: Tue, 27 Jun 2017 14:06:15 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Adila & Lorenz

Thank you for both your replies. The two parts of Adila's last reply marked in yellow below seem to me to answer my original question, i.e.


1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual

2.       such assertions are implicit, and the reasoner can be queried about them

I'd add: Prot?g? does not make such assertions explicit.

Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.

Thanks, Jos


----------------------------------------------------


Von: protege-user [mailto:[hidden email]] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 13:35
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi Jos,

See my response at the end.

On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.



1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they're solving is ontology consistency problem. That is, the question: "Is the input ontology consistent?"
The question is equivalent to asking "Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?" (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer "Yes, the ontology is consistent" because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
"(hasYearOfDeath some rdfs:Literal)(socrates)" and then check if the reasoner would answer with "yes". Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)" and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don't know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

-adila



Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 14:19
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.

On 27.06.2017 12:53, Jos Lehmann wrote:
Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/06aff8fa/attachment-0002.html>

------------------------------

Message: 18
Date: Tue, 27 Jun 2017 14:06:15 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Adila & Lorenz

Thank you for both your replies. The two parts of Adila's last reply marked in yellow below seem to me to answer my original question, i.e.


1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual

2.       such assertions are implicit, and the reasoner can be queried about them

I'd add: Prot?g? does not make such assertions explicit.

Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.

Thanks, Jos


----------------------------------------------------


Von: protege-user [mailto:[hidden email]] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 13:35
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi Jos,

See my response at the end.

On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.



1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they're solving is ontology consistency problem. That is, the question: "Is the input ontology consistent?"
The question is equivalent to asking "Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?" (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer "Yes, the ontology is consistent" because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
"(hasYearOfDeath some rdfs:Literal)(socrates)" and then check if the reasoner would answer with "yes". Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)" and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don't know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

-adila



Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 14:19
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.

On 27.06.2017 12:53, Jos Lehmann wrote:
Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/06aff8fa/attachment-0003.html>

------------------------------

Message: 19
Date: Tue, 27 Jun 2017 14:21:10 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Cc: "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

OWL RL does not support owl:allValuesFrom in a subclass expression [1] which makes the equivalence axiom working only in one direction.

Yup.

It is worth noting that the OWL 2 RL profile supports a restricted subset of OWL and will not produce all the inferences that reasoners such as HermiT and Pellet will. These reasoners support the full language. For the majority of ontologies these restrictions are not significant. See [1] for some details on the SWRLTab?s OWL 2 RL implementation..

Martin

[1] http://ceur-ws.org/Vol-849/paper_31.pdf


On 27.06.2017 04:06, Martin O'Connor wrote:

Can you send the ontology to me.

It is possible that the OWL 2 RL profile supported by the SWRLTab does not support this conclusion (though I think it should).

Martin

On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]<mailto:[hidden email]>> wrote:

Claire already shares her ontology.

The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.

The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.

With best regards,
Samson


On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email]<mailto:[hidden email]>> wrote:


I'm wondering how HemiT can infer this...

We still have the open world assumption, i.e. the conclusion that

:Apple1 rdf:type :SmallApple

is not possible - given that I did not overlook something.

Can you share the ontology?

On 26.06.2017 10:58, claire Qiu wrote:
Hi,
here is my modelling:
#    Object Properties
:hasObject rdf:type owl:ObjectProperty ;
           rdfs:subPropertyOf owl:topObjectProperty .
:hasSize rdf:type owl:ObjectProperty ,
                  owl:FunctionalProperty .

#    Classes
:Apple rdf:type owl:Class .
:HappyKid rdf:type owl:Class ;
          owl:equivalentClass [ rdf:type owl:Restriction ;
                                owl:onProperty :hasObject ;
                                owl:someValuesFrom :SmallApple
                              ] .
:Small rdf:type owl:Class .
:SmallApple rdf:type owl:Class ;
            owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:someValuesFrom :Small
                                                       ]
                                                       [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:allValuesFrom :Small
                                                       ]
                                                     ) ;
                                  rdf:type owl:Class
                                ] .

#    Individuals
:Apple1 rdf:type owl:NamedIndividual ,
                 :Apple ;
        :hasSize :Small1 .
:Jimmy rdf:type owl:NamedIndividual ;
       :hasObject :Apple1 .
:Small1 rdf:type owl:NamedIndividual ,
                 :Small .

SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)


After run the Drool, it cannot infer that Jimmy is a HappyKid.


But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.

Can someone please explain the differences?

Best,
Claire




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/47806224/attachment-0002.html>

------------------------------

Message: 20
Date: Tue, 27 Jun 2017 14:21:10 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Cc: "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

OWL RL does not support owl:allValuesFrom in a subclass expression [1] which makes the equivalence axiom working only in one direction.

Yup.

It is worth noting that the OWL 2 RL profile supports a restricted subset of OWL and will not produce all the inferences that reasoners such as HermiT and Pellet will. These reasoners support the full language. For the majority of ontologies these restrictions are not significant. See [1] for some details on the SWRLTab?s OWL 2 RL implementation..

Martin

[1] http://ceur-ws.org/Vol-849/paper_31.pdf


On 27.06.2017 04:06, Martin O'Connor wrote:

Can you send the ontology to me.

It is possible that the OWL 2 RL profile supported by the SWRLTab does not support this conclusion (though I think it should).

Martin

On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]<mailto:[hidden email]>> wrote:

Claire already shares her ontology.

The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.

The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.

With best regards,
Samson


On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email]<mailto:[hidden email]>> wrote:


I'm wondering how HemiT can infer this...

We still have the open world assumption, i.e. the conclusion that

:Apple1 rdf:type :SmallApple

is not possible - given that I did not overlook something.

Can you share the ontology?

On 26.06.2017 10:58, claire Qiu wrote:
Hi,
here is my modelling:
#    Object Properties
:hasObject rdf:type owl:ObjectProperty ;
           rdfs:subPropertyOf owl:topObjectProperty .
:hasSize rdf:type owl:ObjectProperty ,
                  owl:FunctionalProperty .

#    Classes
:Apple rdf:type owl:Class .
:HappyKid rdf:type owl:Class ;
          owl:equivalentClass [ rdf:type owl:Restriction ;
                                owl:onProperty :hasObject ;
                                owl:someValuesFrom :SmallApple
                              ] .
:Small rdf:type owl:Class .
:SmallApple rdf:type owl:Class ;
            owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:someValuesFrom :Small
                                                       ]
                                                       [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:allValuesFrom :Small
                                                       ]
                                                     ) ;
                                  rdf:type owl:Class
                                ] .

#    Individuals
:Apple1 rdf:type owl:NamedIndividual ,
                 :Apple ;
        :hasSize :Small1 .
:Jimmy rdf:type owl:NamedIndividual ;
       :hasObject :Apple1 .
:Small1 rdf:type owl:NamedIndividual ,
                 :Small .

SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)


After run the Drool, it cannot infer that Jimmy is a HappyKid.


But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.

Can someone please explain the differences?

Best,
Claire




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/47806224/attachment-0003.html>

------------------------------

Message: 21
Date: Tue, 27 Jun 2017 16:23:44 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"



On 27.06.2017 16:06, Jos Lehmann wrote:
>
> Hi Adila & Lorenz
>
>
>
> Thank you for both your replies. The two parts of Adila?s last reply
> marked in yellow below seem to me to answer my original question, i.e.
>
>
>
> 1.       the reasoner does not /explicitly/ derive assertions of
> properties from the class (or superclass) that classifies an individual
>
What? Inferencing by a reasoner makes implicit assertions explicit. Not
the other way around.
owl:hasValue can be used to infer property assertions from ac lass
definition: For example,

A subClassOf p value x
a1 type A
-> a1 p x

> 2.       such assertions are implicit, and the reasoner can be queried
> about them
>
The reasoner can be queried? Use the OWL API to query for something. Or
use the DL Query tab in Protege that makes use of an OWL reasoner.
>
>
>
> I?d add: Prot?g? does not make such assertions explicit.
>
If you run the reasoner from the menu command, some of the inferred
assertions will be shown in the Protege editor. I said "some" because
you can configure it in the preferences and moreover, for some
assertions it's even not intended in order to ensure some degree of
performance of the editor. In addition, you can export inferred axioms.
>
>
>
> Also, I am not sure how to query the reasoner within or without
> Prot?g?. If you can direct me at resources on how to learn that, that
> would help me.
>
>
>
> Thanks, Jos
>
>
>
>
>
> ----------------------------------------------------
>
>
>
>
>
> *Von:*protege-user [mailto:[hidden email]]
> *Im Auftrag von *Adila Alfa Krisnadhi
> *Gesendet:* Dienstag, 27. Juni 2017 13:35
> *An:* User support for WebProtege and Protege Desktop
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically
> get assigned all properties of their class and superclasses?
>
>
>
> Hi Jos,
>
>
>
> See my response at the end.
>
>
>
> On Jun 27, 2017, at 7:00 AM, Jos Lehmann
> <[hidden email]
> <mailto:[hidden email]>> wrote:
>
>
>
> Hi Adila
>
>
>
> Thank you for your detailed reply. See my question below toward the
> end of you reply.
>
>
>
>
>
>
>
> 1. If hasYearOfDeath is an object property (pointing to individuals),
> then you can state any of the following where n is a nonnegative
> integer, C is a class expression, which can be complex or atomic
> (including owl:Thing and owl:Nothing):
>
> 1a. Mortal subClassOf hasYearOfDeath some C
>
> 1b. Mortal subClassOf hasYearOfDeath only C
>
> 1c. Mortal subClassOf hasYearOfDeath min n C
>
> 1d. Mortal subClassOf hasYearOfDeath max n C
>
> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>
>
>
> 2. If hasYearOfDeath is a data property (pointing to literal values),
> then you can state any of the following where n is a nonnegative
> integer, DR is a data range (including datatypes).
>
> 2a. Mortal subClassOf hasYearOfDeath some DR
>
> 2b. Mortal subClassOf hasYearOfDeath only DR
>
> 2c. Mortal subClassOf hasYearOfDeath min n DR
>
> 2d. Mortal subClassOf hasYearOfDeath max n DR
>
>
>
> Which expression did you intend to have?
>
>
>
> If you chose 1a and pick owl:Thing for the class expression C, then
> together with the previous assertion and subclass axiom, you can infer
> that socrates is related to some (unnamed) object through hasYearOfDeath.
>
> If you chose 2a and pick rdfs:Literal for DR, then together with the
> previous assertion and subclass axiom, you can infer that socrates is
> related to some (unknown) literal value through hasYearOfDeath.
>
>
>
>
>
> Suppose I pick your second option above: would the reasoner assert for
> individual socrates the property hasYearOfDeath to some unknown
> Literal? As far as I can tell it does not/ would not.
>
>
>
> What reasoner are you using for this?
>
> For most OWL reasoners, such as Hermit or Pellet, the basic reasoning
> problem they?re solving is ontology consistency problem. That is, the
> question: ?Is the input ontology consistent??
>
> The question is equivalent to asking ?Does the input ontology have a
> model, i.e., an interpretation satisfying all of its axioms?? (model
> and interpretation here is in the sense of OWL Direct semantics).
>
>
>
> In our case, EVERY model of the set of three statements (individual
> assertion, subclass axiom, and axiom for 2a) would necessarily contain
> an instantiation of a binary relationship from socrates to some
> unknown literal. Hence, such a relationship is really inferred,
> meaning the aforementioned relationship MUST necessarily hold.
>
>
>
> Hermit and Pellet would derive that inference, but would not make an
> explicit statement about that relationship. Instead they will only
> return an answer ?Yes, the ontology is consistent? because they
> discover that the statements have a model and thus the relationship
> must hold.
>
>
>
> If you really want to check if the reasoner can derive such a
> particular relationship, then you need to ask it directly in the form
> of query answering.There are different ways to express the query. One
> of it would be asking the query
>
> ?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the
> reasoner would answer with ?yes?. Or you could ask the query
> "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is
> one of the answer.
>
>
>
> Unfortunately, I never explore Protege interface features for this
> task, if any, so I don?t know how to actually do it in Protege.
>
>
>
> Alternatively, you could check if a relationship from socrates to some
> literal value via hasYearOfDeath actually holds by using the
> consistency checking. You could do it by asserting that socrates is an
> instance of the class (not hasYearOfDeath some rdfs:Literal), in
> addition to the three previous statements. If after running the
> reasoner, it says that the ontology is not consistent, then the
> relationship is actually inferred.
>
>
>
> ?adila
>
>
>
>
>
>
>
> *Von:*protege-user [mailto:[hidden email]]
> *Im Auftrag von *Lorenz Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 14:19
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically
> get assigned all properties of their class and superclasses?
>
>
>
> That's not possible. What would be the "default value"? Who decides on
> the default value? And how would you define that in OWL? OWL is the
> base language of the things that you can edit in Protege.
>
> And you can not add a property to an individual without a value - the
> definition of such an axiom needs a value and anything in Protege is
> based on the allowed OWL axioms and other constructs only.
>
>
>
> On 27.06.2017 12:53, Jos Lehmann wrote:
>
>     Hi Lorenz
>
>
>
>     I mean: asserting the property when creating the individual either
>     with a default value (e.g. not asserted) or without a value at all
>     (I know that is not possible in Prot?g?, but I am not sure why
>     that is the case).
>
>
>
>     In my example:
>
>
>
>     ?         Why, when creating the individual socrates TypeOf Human,
>     doesn?t socrates automatically get, for instance, hasLiteracyLevel
>     (for the sake of the example, I am assuming this property is
>     introduced on/defining of class Human) with a default value or no
>     asserted value (for sake of the example, the property would range
>     on a numeric scale 0 to 5)?
>
>     ?         Also why, after deducing socrates TypeOf Mortal, doesn?t
>     socrates get, for instance, hasYearOfDeath (for the sake of the
>     example I am assuming this property is introduced on/defining of
>     class Mortal) with a default value or no asserted value (the
>     property would range on a calendar)?
>
>
>
>
>
>     Thanks Jos
>
>
>
>
>
>     *Von:*protege-user
>     [mailto:[hidden email]] *Im Auftrag von
>     *Lorenz Buehmann
>     *Gesendet:* Dienstag, 27. Juni 2017 12:24
>     *An:* [hidden email]
>     <mailto:[hidden email]>
>     *Betreff:* Re: [protege-user] Why don't OWL individuals
>     automatically get assigned all properties of their class and
>     superclasses?
>
>
>
>     Automatically asserted? How? What would be the automatic value of
>     `hasYearOfDeath`?
>
>
>
>     On 27.06.2017 12:17, Jos Lehmann wrote:
>
>         Hi there
>
>
>
>         A general question: is there reference explaining why, when
>         creating an OWL individual (socrates) of a class (Human
>         subClassOf Mortal), all properties of that class and of its
>         superclasses (Mortal subClassOf hasYearOfDeath) are not
>         automatically asserted for the created individual? Is an
>         implicit assertion made, i.e. inconsistency arises only in
>         case properties are asserted for the individual that
>         contradict properties stated in the class/superclasses?
>
>
>
>         Thanks, Jos
>
>
>
>
>
>         _______________________________________________
>
>         protege-user mailing list
>
>         [hidden email]
>         <mailto:[hidden email]>
>
>         https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
>
>     _______________________________________________
>
>     protege-user mailing list
>
>     [hidden email]
>     <mailto:[hidden email]>
>
>     https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/17e1f98c/attachment-0001.html>

------------------------------

Message: 22
Date: Tue, 27 Jun 2017 10:44:23 -0400
From: Adila Alfa Krisnadhi <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

Hi,

I think my reply earlier was a little bit not precise and the use of explicit vs implicit was probably misleading.
So let me clarify below.

> On Jun 27, 2017, at 10:23 AM, Lorenz Buehmann <[hidden email]> wrote:
>
>
>
> On 27.06.2017 16:06, Jos Lehmann wrote:
>> Hi Adila & Lorenz
>>
>> Thank you for both your replies. The two parts of Adila?s last reply marked in yellow below seem to me to answer my original question, i.e.
>>
>> 1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual
> What? Inferencing by a reasoner makes implicit assertions explicit. Not the other way around.
> owl:hasValue can be used to infer property assertions from ac lass definition: For example,

What I meant was that when reasoners are used in conjunction with a user interface such as Protege, some of the logical consequences may not necessary be displayed. In fact, some ontologies may have infinitely many logical consequences even when restricted to the ontology?s signature symbols. Hence, it is normal if some of them are not displayed. So, I didn?t mean that it was not explicit in the way you described since of course reasoners make implicit assertions explicit.

>
> A subClassOf p value x
> a1 type A
> -> a1 p x

What is x here? A specific named individual?
I don?t think that this is necessarily what Jos intended. He just wanted to infer that a1 ?has a property? somewhat similar to the frame-based reading of object-oriented languages, and not necessarily inferring that a1 has a p-relation to specific individual x.


>
>> 2.       such assertions are implicit, and the reasoner can be queried about them
> The reasoner can be queried? Use the OWL API to query for something. Or use the DL Query tab in Protege that makes use of an OWL reasoner.

This may just be a minor misunderstanding.
Of course a reasoner can be queried, otherwise, how would you know the result of reasoning? The question is how. Using OWL API is one way to do it, that is, we fundamentally do not query the OWL API itself, but rather query the reasoner through OWL API.
Some reasoner such as Hermit provides other means to access the result of reasoning, e.g., command line (see http://www.hermit-reasoner.com/command.html <http://www.hermit-reasoner.com/command.html>).

regards,
?adila



>>
>> I?d add: Prot?g? does not make such assertions explicit.
> If you run the reasoner from the menu command, some of the inferred assertions will be shown in the Protege editor. I said "some" because you can configure it in the preferences and moreover, for some assertions it's even not intended in order to ensure some degree of performance of the editor. In addition, you can export inferred axioms.
>>
>> Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.
>>
>> Thanks, Jos
>>
>>
>> ----------------------------------------------------
>>
>>
>> Von: protege-user [mailto:[hidden email] <mailto:[hidden email]>] Im Auftrag von Adila Alfa Krisnadhi
>> Gesendet: Dienstag, 27. Juni 2017 13:35
>> An: User support for WebProtege and Protege Desktop
>> Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?
>>
>> Hi Jos,
>>
>> See my response at the end.
>>
>> On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email] <mailto:[hidden email]>> wrote:
>>
>> Hi Adila
>>
>> Thank you for your detailed reply. See my question below toward the end of you reply.
>>
>>
>>
>> 1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
>> 1a. Mortal subClassOf hasYearOfDeath some C
>> 1b. Mortal subClassOf hasYearOfDeath only C
>> 1c. Mortal subClassOf hasYearOfDeath min n C
>> 1d. Mortal subClassOf hasYearOfDeath max n C
>> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>>
>> 2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
>> 2a. Mortal subClassOf hasYearOfDeath some DR
>> 2b. Mortal subClassOf hasYearOfDeath only DR
>> 2c. Mortal subClassOf hasYearOfDeath min n DR
>> 2d. Mortal subClassOf hasYearOfDeath max n DR
>>
>> Which expression did you intend to have?
>>
>> If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
>> If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.
>>
>>
>> Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.
>>
>> What reasoner are you using for this?
>> For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they?re solving is ontology consistency problem. That is, the question: ?Is the input ontology consistent??
>> The question is equivalent to asking ?Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?? (model and interpretation here is in the sense of OWL Direct semantics).
>>
>> In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.
>>
>> Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer ?Yes, the ontology is consistent? because they discover that the statements have a model and thus the relationship must hold.
>>
>> If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
>> ?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the reasoner would answer with ?yes?. Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one of the answer.
>>
>> Unfortunately, I never explore Protege interface features for this task, if any, so I don?t know how to actually do it in Protege.
>>
>> Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.
>>
>> ?adila
>>
>>
>>
>> Von: protege-user [mailto:[hidden email] <mailto:[hidden email]>] Im Auftrag von Lorenz Buehmann
>> Gesendet: Dienstag, 27. Juni 2017 14:19
>> An: [hidden email] <mailto:[hidden email]>
>> Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?
>>
>> That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.
>>
>> And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.
>>
>>
>> On 27.06.2017 12:53, Jos Lehmann wrote:
>> Hi Lorenz
>>
>> I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).
>>
>> In my example:
>>
>> ?         Why, when creating the individual socrates TypeOf Human, doesn?t socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?
>> ?         Also why, after deducing socrates TypeOf Mortal, doesn?t socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?
>>
>>
>> Thanks Jos
>>
>>
>> Von: protege-user [mailto:[hidden email] <mailto:[hidden email]>] Im Auftrag von Lorenz Buehmann
>> Gesendet: Dienstag, 27. Juni 2017 12:24
>> An: [hidden email] <mailto:[hidden email]>
>> Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?
>>
>> Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?
>>
>>
>> On 27.06.2017 12:17, Jos Lehmann wrote:
>> Hi there
>>
>> A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?
>>
>> Thanks, Jos
>>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>
> _______________________________________________
> protege-user mailing list
> [hidden email] <mailto:[hidden email]>
> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/5c521d0a/attachment-0001.html>

------------------------------

Message: 23
Date: Tue, 27 Jun 2017 08:24:51 -0700
From: Samson Tu <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

Actually, I just copy and pasted most of the ontology-defining email text (minus the swrl rule) to a file and loaded it in Protege. I only had to enter the swrl rule manually. I used Protege's explanation facility to see that "Jimmie is a HappyKid" could be inferred in two ways.

Thanks for pointing out that RL does not support owl:allValuesFrom.

With best regards,
Samson


> On Jun 27, 2017, at 1:23 AM, Lorenz Buehmann <[hidden email]> wrote:
>
> @Samson: Right, but not a complete document such that one could load it e.g. into Protege for debugging.
>
> Cheers,
>
> Lorenz
>
> On 26.06.2017 20:53, Samson Tu wrote:
>> Claire already shares her ontology.
>>
>> The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.
>>
>> The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.
>>
>> With best regards,
>> Samson
>>
>>
>>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email] <mailto:[hidden email]>> wrote:
>>>
>>> I'm wondering how HemiT can infer this...
>>>
>>> We still have the open world assumption, i.e. the conclusion that
>>> :Apple1 rdf:type :SmallApple
>>>
>>> is not possible - given that I did not overlook something.
>>> Can you share the ontology?
>>>
>>> On 26.06.2017 10:58, claire Qiu wrote:
>>>> Hi,
>>>> here is my modelling:
>>>> #    Object Properties
>>>> :hasObject rdf:type owl:ObjectProperty ;
>>>>            rdfs:subPropertyOf owl:topObjectProperty .
>>>> :hasSize rdf:type owl:ObjectProperty ,
>>>>                   owl:FunctionalProperty .
>>>>
>>>> #    Classes
>>>> :Apple rdf:type owl:Class .
>>>> :HappyKid rdf:type owl:Class ;
>>>>           owl:equivalentClass [ rdf:type owl:Restriction ;
>>>>                                 owl:onProperty :hasObject ;
>>>>                                 owl:someValuesFrom :SmallApple
>>>>                               ] .
>>>> :Small rdf:type owl:Class .
>>>> :SmallApple rdf:type owl:Class ;
>>>>             owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
>>>>                                                          owl:onProperty :hasSize ;
>>>>                                                          owl:someValuesFrom :Small
>>>>                                                        ]
>>>>                                                        [ rdf:type owl:Restriction ;
>>>>                                                          owl:onProperty :hasSize ;
>>>>                                                          owl:allValuesFrom :Small
>>>>                                                        ]
>>>>                                                      ) ;
>>>>                                   rdf:type owl:Class
>>>>                                 ] .
>>>>
>>>> #    Individuals
>>>> :Apple1 rdf:type owl:NamedIndividual ,
>>>>                  :Apple ;
>>>>         :hasSize :Small1 .
>>>> :Jimmy rdf:type owl:NamedIndividual ;
>>>>        :hasObject :Apple1 .
>>>> :Small1 rdf:type owl:NamedIndividual ,
>>>>                  :Small .
>>>>
>>>> SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>>
>>>>
>>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>>
>>>>
>>>> But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.
>>>>
>>>> Can someone please explain the differences?
>>>>
>>>> Best,
>>>> Claire
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> protege-user mailing list
>>>> [hidden email] <mailto:[hidden email]>
>>>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email] <mailto:[hidden email]>
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/150d6f93/attachment-0001.html>

------------------------------

Message: 24
Date: Tue, 27 Jun 2017 10:48:38 -0700
From: Samson Tu <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Help regarding the Classes present in
        PROV-O
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

Hi,

Your question is really out of scope for the [hidden email] <mailto:[hidden email]>.

Had you checked the documentation comments associated with subclasses of Influence? For example, the Communication class has the comment:

An instance of prov:Communication provides additional descriptions about the binary prov:wasInformedBy relation from an informed prov:Activity to the prov:Activity that informed it. For example, :you_jumping_off_bridge prov:wasInformedBy :everyone_else_jumping_off_bridge; prov:qualifiedCommunication [ a prov:Communication; prov:activity :everyone_else_jumping_off_bridge; :foo :bar ].

The point is that an object property like prov:wasInformedBy is a binary relation allowing you to say only

you_jumping_off_bridge prov:wasInformedBy :everyone_else_jumping_off_bridge;

Therefore, if you want to qualify the relation with additional facts (e.g., the date of communication), the ?Communication? class reifies the prov:wasInformedBy relation, so that you can say, for example,

you_jumping_off_bridge prov:qualifiedCommunication
        [ a prov:Communication;
         prov:activity :everyone_else_jumping_off_bridge;
        :date ?2017-01-17?
        ... ].

See also [1]

With best regards,
Samson

[1] https://www.w3.org/TR/swbp-n-aryRelations/ <https://www.w3.org/TR/swbp-n-aryRelations/>


> On Jun 17, 2017, at 9:10 AM, mrinal pandey <[hidden email]> wrote:
>
> Dear all,
> I have created an Ontology, have implemented some rules in it, have also
> Imported the PROV-O Ontology of entity, agent and actvity and have thus
> embedded provenance descriptions to the same reading the PROV-DM and PROV-O
> primer of w3c consortium. However I  have a confusion here. I am unable to
> figure out how to implement Influence classes in like activity influence,
> agent influence and entity influence, despite reading the examples present
> in the PROV-O specification. Would thus request one and all to help me in
> implementing the same. It would be very nice if someone could tell me how to
> implement these classes, is it just by creating the instances of the same or
> is it some other way. I would greatly appreciate if someone could explain
> the same by the help of a small example implemented practically.I am getting
> confused as to when and how to implement classes and when an how to
> implement the object properties of the same.
> Refer to screenshot attached for further details.
> <http://protege-project.136.n4.nabble.com/file/n4668848/Protege_question.jpg>
>
>
>
> --
> View this message in context: http://protege-project.136.n4.nabble.com/Help-regarding-the-Classes-present-in-PROV-O-tp4668848.html
> Sent from the Protege User mailing list archive at Nabble.com.
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

--
Samson Tu                                                      email: [hidden email]
Senior Research Engineer                              web: www.stanford.edu/~swt/
Center for Biomedical Informatics Research      phone: 1-650-725-3391
Stanford University                                          fax: 1-650-725-7944



-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/e1ac5d37/attachment-0001.html>

------------------------------

Message: 25
Date: Tue, 27 Jun 2017 11:22:38 -0700
From: Michael DeBellis <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <CALGFikf7A=6_cJwmkF7hyoMX1RMch_nEjb-_-7L_hJom9T=[hidden email]>
Content-Type: text/plain; charset="utf-8"

Jos,

OWL doesn't do default values. I think the reason is that it also doesn't
treat failure as negation. I.e., you can't assume that because there is no
value known that one doesn't actually exist. So given that you can't reason
about which objects should be given default values. Just because they don't
have values at that point in time doesn't mean they aren't there. This is
known as the Open World assumption which is different than the Closed World
assumption that many languages use. For example in Lisp nil is equivalent
to false.

Regarding your second question "how to query the reasoner" just a matter of
terminology but you don't query the reasoner. You query the ontology and
the reasoner makes changes to the ontology. There are many ways to query
the ontology. One way is to use SQWRL, its an extension of SWRL but just
for doing queries.

You can also use Protege to type DL queries. Go to Window>Tabs>DL Query and
you will see a new tab that lets you type DL Queries and see the results.
Note: if you use this pay attention to the check box in the lower right
corner that says "Query for" the default is that instances is not checked
in that box so the first time people use it (at least the first time I used
it) it can be confusing because you can give a query that returns a bunch
of instances but not see them because the Instances box isn't checked.

BTW, if you are interested in using SWRL and SQWRL here is a brief tutorial
I wrote that introduces them using a process modeling example:

http://symbolicshacker.blogspot.com/2017/06/swrl-process-modeling-tutorial.html

Cheers,

Michael

On Tue, Jun 27, 2017 at 7:06 AM, Jos Lehmann <
[hidden email]> wrote:

> Hi Adila & Lorenz
>
>
>
> Thank you for both your replies. The two parts of Adila?s last reply
> marked in yellow below seem to me to answer my original question, i.e.
>
>
>
> 1.       the reasoner does not *explicitly* derive assertions of
> properties from the class (or superclass) that classifies an individual
>
> 2.       such assertions are implicit, and the reasoner can be queried
> about them
>
>
>
> I?d add: Prot?g? does not make such assertions explicit.
>
>
>
> Also, I am not sure how to query the reasoner within or without Prot?g?.
> If you can direct me at resources on how to learn that, that would help me.
>
>
>
> Thanks, Jos
>
>
>
>
>
> ----------------------------------------------------
>
>
>
>
>
> *Von:* protege-user [mailto:[hidden email]] *Im
> Auftrag von *Adila Alfa Krisnadhi
> *Gesendet:* Dienstag, 27. Juni 2017 13:35
> *An:* User support for WebProtege and Protege Desktop
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically get
> assigned all properties of their class and superclasses?
>
>
>
> Hi Jos,
>
>
>
> See my response at the end.
>
>
>
> On Jun 27, 2017, at 7:00 AM, Jos Lehmann <Jos.Lehmann@bauhaus-
> luftfahrt.net> wrote:
>
>
>
> Hi Adila
>
>
>
> Thank you for your detailed reply. See my question below toward the end of
> you reply.
>
>
>
>
>
>
>
> 1. If hasYearOfDeath is an object property (pointing to individuals), then
> you can state any of the following where n is a nonnegative integer, C is a
> class expression, which can be complex or atomic (including owl:Thing and
> owl:Nothing):
>
> 1a. Mortal subClassOf hasYearOfDeath some C
>
> 1b. Mortal subClassOf hasYearOfDeath only C
>
> 1c. Mortal subClassOf hasYearOfDeath min n C
>
> 1d. Mortal subClassOf hasYearOfDeath max n C
>
> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>
>
>
> 2. If hasYearOfDeath is a data property (pointing to literal values), then
> you can state any of the following where n is a nonnegative integer, DR is
> a data range (including datatypes).
>
> 2a. Mortal subClassOf hasYearOfDeath some DR
>
> 2b. Mortal subClassOf hasYearOfDeath only DR
>
> 2c. Mortal subClassOf hasYearOfDeath min n DR
>
> 2d. Mortal subClassOf hasYearOfDeath max n DR
>
>
>
> Which expression did you intend to have?
>
>
>
> If you chose 1a and pick owl:Thing for the class expression C, then
> together with the previous assertion and subclass axiom, you can infer that
> socrates is related to some (unnamed) object through hasYearOfDeath.
>
> If you chose 2a and pick rdfs:Literal for DR, then together with the
> previous assertion and subclass axiom, you can infer that socrates is
> related to some (unknown) literal value through hasYearOfDeath.
>
>
>
>
>
> Suppose I pick your second option above: would the reasoner assert for
> individual socrates the property hasYearOfDeath to some unknown Literal? As
> far as I can tell it does not/ would not.
>
>
>
> What reasoner are you using for this?
>
> For most OWL reasoners, such as Hermit or Pellet, the basic reasoning
> problem they?re solving is ontology consistency problem. That is, the
> question: ?Is the input ontology consistent??
>
> The question is equivalent to asking ?Does the input ontology have a
> model, i.e., an interpretation satisfying all of its axioms?? (model and
> interpretation here is in the sense of OWL Direct semantics).
>
>
>
> In our case, EVERY model of the set of three statements (individual
> assertion, subclass axiom, and axiom for 2a) would necessarily contain an
> instantiation of a binary relationship from socrates to some unknown
> literal. Hence, such a relationship is really inferred, meaning the
> aforementioned relationship MUST necessarily hold.
>
>
>
> Hermit and Pellet would derive that inference, but would not make an
> explicit statement about that relationship. Instead they will only return
> an answer ?Yes, the ontology is consistent? because they discover that the
> statements have a model and thus the relationship must hold.
>
>
>
> If you really want to check if the reasoner can derive such a particular
> relationship, then you need to ask it directly in the form of query
> answering. There are different ways to express the query. One of it would
> be asking the query
>
> ?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the
> reasoner would answer with ?yes?. Or you could ask the query
> "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one
> of the answer.
>
>
>
> Unfortunately, I never explore Protege interface features for this task,
> if any, so I don?t know how to actually do it in Protege.
>
>
>
> Alternatively, you could check if a relationship from socrates to some
> literal value via hasYearOfDeath actually holds by using the consistency
> checking. You could do it by asserting that socrates is an instance of the
> class (not hasYearOfDeath some rdfs:Literal), in addition to the three
> previous statements. If after running the reasoner, it says that the
> ontology is not consistent, then the relationship is actually inferred.
>
>
>
> ?adila
>
>
>
>
>
>
>
> *Von:* protege-user [mailto:[hidden email]] *Im
> Auftrag von *Lorenz Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 14:19
>
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically get
> assigned all properties of their class and superclasses?
>
>
>
> That's not possible. What would be the "default value"? Who decides on the
> default value? And how would you define that in OWL? OWL is the base
> language of the things that you can edit in Protege.
>
> And you can not add a property to an individual without a value - the
> definition of such an axiom needs a value and anything in Protege is based
> on the allowed OWL axioms and other constructs only.
>
>
>
> On 27.06.2017 12:53, Jos Lehmann wrote:
>
> Hi Lorenz
>
>
>
> I mean: asserting the property when creating the individual either with a
> default value (e.g. not asserted) or without a value at all (I know that is
> not possible in Prot?g?, but I am not sure why that is the case).
>
>
>
> In my example:
>
>
>
> ?         Why, when creating the individual socrates TypeOf Human,
> doesn?t socrates automatically get, for instance, hasLiteracyLevel (for the
> sake of the example, I am assuming this property is introduced on/defining
> of class Human) with a default value or no asserted value (for sake of the
> example, the property would range on a numeric scale 0 to 5)?
>
> ?         Also why, after deducing socrates TypeOf Mortal, doesn?t
> socrates get, for instance, hasYearOfDeath (for the sake of the example I
> am assuming this property is introduced on/defining of class Mortal) with a
> default value or no asserted value (the property would range on a calendar)?
>
>
>
>
>
> Thanks Jos
>
>
>
>
>
> *Von:* protege-user [mailto:[hidden email]
> <[hidden email]>] *Im Auftrag von *Lorenz
> Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 12:24
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically get
> assigned all properties of their class and superclasses?
>
>
>
> Automatically asserted? How? What would be the automatic value of `
> hasYearOfDeath`?
>
>
>
> On 27.06.2017 12:17, Jos Lehmann wrote:
>
> Hi there
>
>
>
> A general question: is there reference explaining why, when creating an
> OWL individual (socrates) of a class (Human subClassOf Mortal), all
> properties of that class and of its superclasses (Mortal subClassOf
> hasYearOfDeath) are not automatically asserted for the created individual?
> Is an implicit assertion made, i.e. inconsistency arises only in case
> properties are asserted for the individual that contradict properties
> stated in the class/superclasses?
>
>
>
> Thanks, Jos
>
>
>
>
>
> _______________________________________________
>
> protege-user mailing list
>
> [hidden email]
>
> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
>
> _______________________________________________
>
> protege-user mailing list
>
> [hidden email]
>
> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/c186db5a/attachment-0001.html>

------------------------------

Message: 26
Date: Tue, 27 Jun 2017 18:45:44 +0000
From: Dave McComb <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>

Content-Type: text/plain; charset="windows-1252"

If you are interested in negation as failure and constraints in general, I'd recommend SHACL

https://www.w3.org/TR/shacl/


SHACL adds on to OWL, rather than replacing it.  The way we use it is to define open world meaning in owl, that way if you are harvesting data from the web you can take it as is (it's really pointless to try to constrain the web) but then you can have a separate repository for curated data.  Both repositories can share the same OWL and therefore share the same meaning and vocabulary, but only the curated repo has the constraints.


There are extensions to SHACL that provide defaults as well.


Dave McComb

Semantic Arts, Inc.


Shapes Constraint Language (SHACL)<https://www.w3.org/TR/shacl/>
www.w3.org
Abstract. This document defines the SHACL Shapes Constraint Language, a language for validating RDF graphs against a set of conditions. These conditions are provided ...





________________________________
From: protege-user <[hidden email]> on behalf of Michael DeBellis <[hidden email]>
Sent: Tuesday, June 27, 2017 12:22 PM
To: User support for WebProtege and Protege Desktop
Subject: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Jos,

OWL doesn't do default values. I think the reason is that it also doesn't treat failure as negation. I.e., you can't assume that because there is no value known that one doesn't actually exist. So given that you can't reason about which objects should be given default values. Just because they don't have values at that point in time doesn't mean they aren't there. This is known as the Open World assumption which is different than the Closed World assumption that many languages use. For example in Lisp nil is equivalent to false.

Regarding your second question "how to query the reasoner" just a matter of terminology but you don't query the reasoner. You query the ontology and the reasoner makes changes to the ontology. There are many ways to query the ontology. One way is to use SQWRL, its an extension of SWRL but just for doing queries.

You can also use Protege to type DL queries. Go to Window>Tabs>DL Query and you will see a new tab that lets you type DL Queries and see the results. Note: if you use this pay attention to the check box in the lower right corner that says "Query for" the default is that instances is not checked in that box so the first time people use it (at least the first time I used it) it can be confusing because you can give a query that returns a bunch of instances but not see them because the Instances box isn't checked.

BTW, if you are interested in using SWRL and SQWRL here is a brief tutorial I wrote that introduces them using a process modeling example:

http://symbolicshacker.blogspot.com/2017/06/swrl-process-modeling-tutorial.html

Cheers,

Michael

On Tue, Jun 27, 2017 at 7:06 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:
Hi Adila & Lorenz

Thank you for both your replies. The two parts of Adila?s last reply marked in yellow below seem to me to answer my original question, i.e.


1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual

2.       such assertions are implicit, and the reasoner can be queried about them

I?d add: Prot?g? does not make such assertions explicit.

Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.

Thanks, Jos


----------------------------------------------------


Von: protege-user [mailto:[hidden email]<mailto:[hidden email]>] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 13:35
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi Jos,

See my response at the end.

On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.



1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they?re solving is ontology consistency problem. That is, the question: ?Is the input ontology consistent??
The question is equivalent to asking ?Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?? (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer ?Yes, the ontology is consistent? because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the reasoner would answer with ?yes?. Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don?t know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

?adila



Von: protege-user [mailto:[hidden email]<mailto:[hidden email]>] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 14:19

An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.

On 27.06.2017 12:53, Jos Lehmann wrote:
Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn?t socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn?t socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/4be40804/attachment-0001.html>

------------------------------

Subject: Digest Footer

_______________________________________________
protege-user mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user


------------------------------

End of protege-user Digest, Vol 41, Issue 30
********************************************


_______________________________________________
protege-user mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user

example.owl (4K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: ontology file //Re: Question about Drool reasoning (Lorenz Buehmann)

Lorenz Buehmann

Haven't you read all the answers here on the mailing list? Please read Martins answer in particular.


On 28.06.2017 09:51, claire Qiu wrote:
Hi Lorenz,

I have attached the ontology. 
For the simplicity, I rewrote the KB as following :

Rules:
SmallApple(x) <-  Apple(x), hasSize(x,y),Small(y).
HappyKid(x)  <->  hasObject(x,y),SmallApple(y).

facts:
Apple(Apple1), Small(Small1), hasSize(Apple1,Small1), hasObject(Jimmy,Apple1).

As far as my understanding, Jimmy is a HappyKid should be a logical consequence.

Maybe I understood the reasoning mechanism of Drool wrongly. 

Please share you insights. Thanks

Best,
Claire

On Tue, Jun 27, 2017 at 9:05 PM, <[hidden email]> wrote:
Send protege-user mailing list submissions to
        [hidden email]

To subscribe or unsubscribe via the World Wide Web, visit
        https://mailman.stanford.edu/mailman/listinfo/protege-user
or, via email, send a message with subject or body 'help' to
        [hidden email]

You can reach the person managing the list at
        [hidden email]

When replying, please edit your Subject line so it is more specific
than "Re: Contents of protege-user digest..."


Today's Topics:

   1. Re: Sparql help for subClassOf (sb)
   2. Re: Question about Drool reasoning (Martin O'Connor)
   3. Re: SWRLTab syntax error (Martin O'Connor)
   4. Re: Problem with OWL viz (Nick89)
   5. Re: Question about Drool reasoning (Lorenz Buehmann)
   6. Re: Question about Drool reasoning (Lorenz Buehmann)
   7. Re: Question about Drool reasoning (Lorenz Buehmann)
   8. "Intelligent" support for ontology merging/mapping?! (Nick89)
   9. Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  10. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Lorenz Buehmann)
  11. Re: Why don't OWL individuals automatically get   assigned all
      properties of their class and superclasses? (Adila Alfa Krisnadhi)
  12. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  13. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  14. Re: Why don't OWL individuals automatically       get     assigned all
      properties of their class and superclasses? (Jos Lehmann)
  15. Re: Why don't OWL individuals automatically get   assigned all
      properties of their class and superclasses? (Adila Alfa Krisnadhi)
  16. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Lorenz Buehmann)
  17. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  18. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Jos Lehmann)
  19. Re: Question about Drool reasoning (Martin O'Connor)
  20. Re: Question about Drool reasoning (Martin O'Connor)
  21. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Lorenz Buehmann)
  22. Re: Why don't OWL individuals automatically get   assigned all
      properties of their class and superclasses? (Adila Alfa Krisnadhi)
  23. Re: Question about Drool reasoning (Samson Tu)
  24. Re: Help regarding the Classes present in PROV-O (Samson Tu)
  25. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Michael DeBellis)
  26. Re: Why don't OWL individuals automatically get assigned all
      properties of their class and superclasses? (Dave McComb)


----------------------------------------------------------------------

Message: 1
Date: Mon, 26 Jun 2017 13:22:41 -0700 (PDT)
From: sb <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Sparql help for subClassOf
Message-ID: <[hidden email]>
Content-Type: text/plain; charset=us-ascii

Dear All,

I solved my problem via the code below. Before I was making a structural
mistake.

PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX radlex:
<http://bioontology.org/projects/ontologies/radlex/radlexOwlDlComponent#>

SELECT DISTINCT ?term ?name ?synonym ?subClassOf ?subClassOf_name
FROM <http://bioportal.bioontology.org/ontologies/RID>
WHERE
{
 ?term radlex:Preferred_name ?name .
 ?term radlex:Synonym ?synonym .
 ?term rdfs:subClassOf ?subClassOf .
  ?subClassOf radlex:Preferred_name ?subClassOf_name
}  LIMIT 100



--
View this message in context: http://protege-project.136.n4.nabble.com/Sparql-help-for-subClassOf-tp4668886p4668934.html
Sent from the Protege User mailing list archive at Nabble.com.


------------------------------

Message: 2
Date: Tue, 27 Jun 2017 02:06:02 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="us-ascii"


Can you send the ontology to me.

It is possible that the OWL 2 RL profile supported by the SWRLTab does not support this conclusion (though I think it should).

Martin

On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]<mailto:[hidden email]>> wrote:

Claire already shares her ontology.

The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.

The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.

With best regards,
Samson


On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email]<mailto:[hidden email]>> wrote:


I'm wondering how HemiT can infer this...

We still have the open world assumption, i.e. the conclusion that

:Apple1 rdf:type :SmallApple

is not possible - given that I did not overlook something.

Can you share the ontology?

On <a moz-do-not-send="true" href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
Hi,
here is my modelling:
#    Object Properties
:hasObject rdf:type owl:ObjectProperty ;
           rdfs:subPropertyOf owl:topObjectProperty .
:hasSize rdf:type owl:ObjectProperty ,
                  owl:FunctionalProperty .

#    Classes
:Apple rdf:type owl:Class .
:HappyKid rdf:type owl:Class ;
          owl:equivalentClass [ rdf:type owl:Restriction ;
                                owl:onProperty :hasObject ;
                                owl:someValuesFrom :SmallApple
                              ] .
:Small rdf:type owl:Class .
:SmallApple rdf:type owl:Class ;
            owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:someValuesFrom :Small
                                                       ]
                                                       [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:allValuesFrom :Small
                                                       ]
                                                     ) ;
                                  rdf:type owl:Class
                                ] .

#    Individuals
:Apple1 rdf:type owl:NamedIndividual ,
                 :Apple ;
        :hasSize :Small1 .
:Jimmy rdf:type owl:NamedIndividual ;
       :hasObject :Apple1 .
:Small1 rdf:type owl:NamedIndividual ,
                 :Small .

SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)


After run the Drool, it cannot infer that Jimmy is a HappyKid.


But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.

Can someone please explain the differences?

Best,
Claire




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/9d25e39e/attachment-0001.html>

------------------------------

Message: 3
Date: Tue, 27 Jun 2017 03:39:02 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] SWRLTab syntax error
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"


I have fixed this problem. The SWRL editor no longer performs annotation-based rendering of OWL entity names.

A new 2.0.2 version of the SWRLTab plugin is available on Maven Central. Update in Protege via File->Check for plugins?.

Martin

On Jun 26, 2017, at 9:02 AM, Davide Sottara <[hidden email]<mailto:[hidden email]>> wrote:

I found the same issue a few days ago and was about to report it.

I can confirm the editor does not work with labels, and shows the labels even when 'View by IRI/prefixed name" is set

I am using Protege 5.2, on Linux, with SWRLTab 2.0.1 (Jun 24th)

Thanks!

On Mon, Jun 26, 2017 at 10:32 AM, Martin O'Connor <[hidden email]<mailto:[hidden email]>> wrote:

It looks like the SWRLTab is picking up your label-based entity name rendering preference and complaining because it cannot yet handle labels as names for OWL entities.

I will try to fix that issue this week. In the meantime, you could switch to rendering entity names by short or prefixed form using the following menu options:

View->Render by prefixed name
View->Render by entity IRI short name (id)

Martin

> On Jun 26, 2017, at 4:55 AM, claire Qiu <[hidden email]<mailto:[hidden email]>> wrote:
>
> Hi,
> I have added a rule as shown below.
> <image.png>
>
> But after I saved it and reopen it, it shows syntactical error:
> <image.png>
>
> it used the label instead of the IRI name.
>
> My SWRLTable version is:2.0.1
>
> Thanks in advance!
>
> Best,
> Claire
> _______________________________________________
> protege-user mailing list
> [hidden email]<mailto:[hidden email]>
> https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/01e4d537/attachment-0001.html>

------------------------------

Message: 4
Date: Tue, 27 Jun 2017 00:46:44 -0700 (PDT)
From: Nick89 <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Problem with OWL viz
Message-ID: <[hidden email]>
Content-Type: text/plain; charset=us-ascii

Hi Gracie,

It worked.

I actually didn't even have this additional Graphviz-Thing installed.
I downloaded Graphviz, pasted it into the Protege plugin folder and directed
the settings-path to it. That's it.

Thank you for your support!



--
View this message in context: http://protege-project.136.n4.nabble.com/Problem-with-OWL-viz-tp4668925p4668937.html
Sent from the Protege User mailing list archive at Nabble.com.


------------------------------

Message: 5
Date: Tue, 27 Jun 2017 10:23:13 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

@Samson: Right, but not a complete document such that one could load it
e.g. into Protege for debugging.

Cheers,

Lorenz


On <a moz-do-not-send="true" href="tel:26.06.2017%2020" value="+12606201720">26.06.2017 20:53, Samson Tu wrote:
> Claire already shares her ontology.
>
> The property hasSize is functional. Given that Apple1 hasSize Small1
> (of type Small), Apple1 is a SmallApple.
>
> The Drool-based SWRLTab should have concluded that Jimmie is a
> HappyKid w/o the equivalence definition of HappyKid. The Pellet
> reasoner uses the SWRL rule to make that conclusion.
>
> /With best regards,/
> /Samson/
>
>
>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann
>> <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>> I'm wondering how HemiT can infer this...
>>
>> We still have the open world assumption, i.e. the conclusion that
>>
>> :Apple1 rdf:type :SmallApple
>>
>> is not possible - given that I did not overlook something.
>>
>> Can you share the ontology?
>>
>>
>> On <a moz-do-not-send="true" href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
>>> Hi,
>>> here is my modelling:
>>>
>>>     *#    Object Properties*
>>>     :hasObject rdf:type owl:ObjectProperty ;
>>>                rdfs:subPropertyOf owl:topObjectProperty .
>>>     :hasSize rdf:type owl:ObjectProperty ,
>>>                       owl:FunctionalProperty .
>>>
>>>
>>>
>>>     *#    Classes*
>>>     :Apple rdf:type owl:Class .
>>>     :HappyKid rdf:type owl:Class ;
>>>               owl:equivalentClass [ rdf:type owl:Restriction ;
>>>                                     owl:onProperty :hasObject ;
>>>                                     owl:someValuesFrom :SmallApple
>>>                                   ] .
>>>     :Small rdf:type owl:Class .
>>>     :SmallApple rdf:type owl:Class ;
>>>                 owl:equivalentClass [ owl:intersectionOf ( [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:someValuesFrom :Small
>>>                                                            ]
>>>                                                            [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:allValuesFrom :Small
>>>                                                            ]
>>>                                                          ) ;
>>>                                       rdf:type owl:Class
>>>                                     ] .
>>>
>>>     *#    Individuals*
>>>     :Apple1 rdf:type owl:NamedIndividual ,
>>>                      :Apple ;
>>>             :hasSize :Small1 .
>>>     :Jimmy rdf:type owl:NamedIndividual ;
>>>            :hasObject :Apple1 .
>>>     :Small1 rdf:type owl:NamedIndividual ,
>>>                      :Small .
>>>
>>>     *SWRL rule:*  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>
>>>
>>>
>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>
>>>
>>> But, if I model HappyKid as a class: /HappyKid isEquvilentTo
>>> hasObject some SmallApple/, the Hermit reasoner can infer that Jimmy
>>> is a HappyKid.
>>>
>>> Can someone please explain the differences?
>>>
>>> Best,
>>> Claire
>>>
>>>
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email]
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/a7470295/attachment-0001.html>

------------------------------

Message: 6
Date: Tue, 27 Jun 2017 10:24:32 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

By the way, I overlooked the functionality of :hasSize.

Indeed, you're right. anyways, loading the ontology in Protege and using
the explanation feature would have been easier for me :D


Cheers,

Lorenz


On <a moz-do-not-send="true" href="tel:26.06.2017%2020" value="+12606201720">26.06.2017 20:53, Samson Tu wrote:
> Claire already shares her ontology.
>
> The property hasSize is functional. Given that Apple1 hasSize Small1
> (of type Small), Apple1 is a SmallApple.
>
> The Drool-based SWRLTab should have concluded that Jimmie is a
> HappyKid w/o the equivalence definition of HappyKid. The Pellet
> reasoner uses the SWRL rule to make that conclusion.
>
> /With best regards,/
> /Samson/
>
>
>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann
>> <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>> I'm wondering how HemiT can infer this...
>>
>> We still have the open world assumption, i.e. the conclusion that
>>
>> :Apple1 rdf:type :SmallApple
>>
>> is not possible - given that I did not overlook something.
>>
>> Can you share the ontology?
>>
>>
>> On <a moz-do-not-send="true" href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
>>> Hi,
>>> here is my modelling:
>>>
>>>     *#    Object Properties*
>>>     :hasObject rdf:type owl:ObjectProperty ;
>>>                rdfs:subPropertyOf owl:topObjectProperty .
>>>     :hasSize rdf:type owl:ObjectProperty ,
>>>                       owl:FunctionalProperty .
>>>
>>>
>>>
>>>     *#    Classes*
>>>     :Apple rdf:type owl:Class .
>>>     :HappyKid rdf:type owl:Class ;
>>>               owl:equivalentClass [ rdf:type owl:Restriction ;
>>>                                     owl:onProperty :hasObject ;
>>>                                     owl:someValuesFrom :SmallApple
>>>                                   ] .
>>>     :Small rdf:type owl:Class .
>>>     :SmallApple rdf:type owl:Class ;
>>>                 owl:equivalentClass [ owl:intersectionOf ( [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:someValuesFrom :Small
>>>                                                            ]
>>>                                                            [
>>>     rdf:type owl:Restriction ;
>>>
>>>      owl:onProperty :hasSize ;
>>>
>>>      owl:allValuesFrom :Small
>>>                                                            ]
>>>                                                          ) ;
>>>                                       rdf:type owl:Class
>>>                                     ] .
>>>
>>>     *#    Individuals*
>>>     :Apple1 rdf:type owl:NamedIndividual ,
>>>                      :Apple ;
>>>             :hasSize :Small1 .
>>>     :Jimmy rdf:type owl:NamedIndividual ;
>>>            :hasObject :Apple1 .
>>>     :Small1 rdf:type owl:NamedIndividual ,
>>>                      :Small .
>>>
>>>     *SWRL rule:*  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>
>>>
>>>
>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>
>>>
>>> But, if I model HappyKid as a class: /HappyKid isEquvilentTo
>>> hasObject some SmallApple/, the Hermit reasoner can infer that Jimmy
>>> is a HappyKid.
>>>
>>> Can someone please explain the differences?
>>>
>>> Best,
>>> Claire
>>>
>>>
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email]
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/633fa752/attachment-0001.html>

------------------------------

Message: 7
Date: Tue, 27 Jun 2017 10:27:09 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

@Martin

OWL RL does not support owl:allValuesFrom in a subclass expression [1]
which makes the equivalence axiom working only in one direction.


Cheers,

Lorenz


[1] https://www.w3.org/TR/owl2-profiles/#Class_Expressions_3


On <a moz-do-not-send="true" href="tel:27.06.2017%2004" value="+12706201704">27.06.2017 04:06, Martin O'Connor wrote:
>
> Can you send the ontology to me.
>
> It is possible that the OWL 2 RL profile supported by the SWRLTab does
> not support this conclusion (though I think it should).
>
> Martin
>
>> On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]
>> <mailto:[hidden email]>> wrote:
>>
>> Claire already shares her ontology.
>>
>> The property hasSize is functional. Given that Apple1 hasSize Small1
>> (of type Small), Apple1 is a SmallApple.
>>
>> The Drool-based SWRLTab should have concluded that Jimmie is a
>> HappyKid w/o the equivalence definition of HappyKid. The Pellet
>> reasoner uses the SWRL rule to make that conclusion.
>>
>> /With best regards,/
>> /Samson/
>>
>>
>>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann
>>> <[hidden email]
>>> <mailto:[hidden email]>> wrote:
>>>
>>> I'm wondering how HemiT can infer this...
>>>
>>> We still have the open world assumption, i.e. the conclusion that
>>>
>>> :Apple1 rdf:type :SmallApple
>>>
>>> is not possible - given that I did not overlook something.
>>>
>>> Can you share the ontology?
>>>
>>>
>>> On <a moz-do-not-send="true" href="tel:26.06.2017%2010" value="+12606201710">26.06.2017 10:58, claire Qiu wrote:
>>>> Hi,
>>>> here is my modelling:
>>>>
>>>>     *#    Object Properties*
>>>>     :hasObject rdf:type owl:ObjectProperty ;
>>>>                rdfs:subPropertyOf owl:topObjectProperty .
>>>>     :hasSize rdf:type owl:ObjectProperty ,
>>>>                       owl:FunctionalProperty .
>>>>
>>>>
>>>>
>>>>     *#    Classes*
>>>>     :Apple rdf:type owl:Class .
>>>>     :HappyKid rdf:type owl:Class ;
>>>>               owl:equivalentClass [ rdf:type owl:Restriction ;
>>>>                                     owl:onProperty :hasObject ;
>>>>                                     owl:someValuesFrom :SmallApple
>>>>                                   ] .
>>>>     :Small rdf:type owl:Class .
>>>>     :SmallApple rdf:type owl:Class ;
>>>>                 owl:equivalentClass [ owl:intersectionOf ( [
>>>>     rdf:type owl:Restriction ;
>>>>
>>>>      owl:onProperty :hasSize ;
>>>>
>>>>      owl:someValuesFrom :Small
>>>>                                                            ]
>>>>                                                            [
>>>>     rdf:type owl:Restriction ;
>>>>
>>>>      owl:onProperty :hasSize ;
>>>>
>>>>      owl:allValuesFrom :Small
>>>>                                                            ]
>>>>                                                          ) ;
>>>>                                       rdf:type owl:Class
>>>>                                     ] .
>>>>
>>>>     *#    Individuals*
>>>>     :Apple1 rdf:type owl:NamedIndividual ,
>>>>                      :Apple ;
>>>>             :hasSize :Small1 .
>>>>     :Jimmy rdf:type owl:NamedIndividual ;
>>>>            :hasObject :Apple1 .
>>>>     :Small1 rdf:type owl:NamedIndividual ,
>>>>                      :Small .
>>>>
>>>>     *SWRL rule:*  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>>
>>>>
>>>>
>>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>>
>>>>
>>>> But, if I model HappyKid as a class: /HappyKid isEquvilentTo
>>>> hasObject some SmallApple/, the Hermit reasoner can infer that
>>>> Jimmy is a HappyKid.
>>>>
>>>> Can someone please explain the differences?
>>>>
>>>> Best,
>>>> Claire
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> protege-user mailing list
>>>> [hidden email]
>>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email] <mailto:[hidden email]>
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/44199008/attachment-0001.html>

------------------------------

Message: 8
Date: Tue, 27 Jun 2017 01:39:32 -0700 (PDT)
From: Nick89 <[hidden email]>
To: [hidden email]
Subject: [protege-user] "Intelligent" support for ontology
        merging/mapping?!
Message-ID: <[hidden email]>
Content-Type: text/plain; charset=us-ascii

Hey,

I'm new to Protege, but i already have a certain problem.

I have two differently structured ontologies and i want to merge/map them
together.

<http://protege-project.136.n4.nabble.com/file/n4668941/Ontology_mapping.png>

Yes - I'm aware that there is the functionality *Refactor *> *Merge*. But
all that gives it to me is just writing both ontology trees one under the
other.

What I want is a programme intelligence telling me: "Hey, there is already a
concept called 'Laptops Dell'. Do you want to transfer this concept to the
other one?".

Or: "Hey, there is already a concept called 'Accessories', but the
subclasses are different. Should the concept be transferred by giving you
the possibility to choose one subclass as a superior class of the other
subclass?"

I read about this PROMPT plug-in, but I also read that it's not supported by
Protege 5.2.0 anymore.

Thanks for any help!

Greetz
Nick



--
View this message in context: http://protege-project.136.n4.nabble.com/Intelligent-support-for-ontology-merging-mapping-tp4668941.html
Sent from the Protege User mailing list archive at Nabble.com.


------------------------------

Message: 9
Date: Tue, 27 Jun 2017 10:17:38 +0000
From: Jos Lehmann <[hidden email]>
To: "[hidden email]"
        <[hidden email]>
Subject: [protege-user] Why don't OWL individuals automatically get
        assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="us-ascii"

Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/f68ef5a6/attachment-0001.html>

------------------------------

Message: 10
Date: Tue, 27 Jun 2017 12:23:47 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

Automatically asserted? How? What would be the automatic value of
`hasYearOfDeath`?


On <a moz-do-not-send="true" href="tel:27.06.2017%2012" value="+12706201712">27.06.2017 12:17, Jos Lehmann wrote:
>
> Hi there
>
>
>
> A general question: is there reference explaining why, when creating
> an OWL individual (socrates) of a class (Human subClassOf Mortal), all
> properties of that class and of its superclasses (Mortal subClassOf
> hasYearOfDeath) are not automatically asserted for the created
> individual? Is an implicit assertion made, i.e. inconsistency arises
> only in case properties are asserted for the individual that
> contradict properties stated in the class/superclasses?
>
>
>
> Thanks, Jos
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/45063ec1/attachment-0001.html>

------------------------------

Message: 11
Date: Tue, 27 Jun 2017 06:45:32 -0400
From: Adila Alfa Krisnadhi <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

Hi,

I think, the reason behind your question is because you are confusing OWL with object-oriented languages: they are completely different.

In object-oriented (programming) languages, properties are understood as members of some class. That?s why it makes sense to say ?properties of a class?, and moreover, semantics of inheritance may allow properties of a class to be inherited by its subclass or instances of its subclass.

In contrast, in OWL, there is no such thing as properties of a class. Properties are first class citizens of the language, that is, they can be declared in an ontology without being attached to a class.

To your question, when you create an individual socrates and asserts it to be an instance of a class Human, you actually only say that socrates is an element of the set the class Human refers to. (This is the precise reading of ?socrates is a Human? in OWL).
If you then have a subclass axiom: Human subClassOf Mortal, then this subclass axiom together with your previous assertion regarding socrates allow you to infer that socrates is an element of the set that the class Mortal refers to, but nothing more than that.

Your other statement ?Mortal subClassOf hasYearOfDeath? is an illegal statement in OWL, i.e., a syntactic error. In OWL, you can say any of the following:

1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.

Other choices will lead to other consequences.

?adila


> On Jun 27, 2017, at 6:17 AM, Jos Lehmann <[hidden email]> wrote:
>
> Hi there
>
> A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?
>
> Thanks, Jos
> _______________________________________________
> protege-user mailing list
> [hidden email] <mailto:[hidden email]>
> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/e011d77f/attachment-0001.html>

------------------------------

Message: 12
Date: Tue, 27 Jun 2017 10:53:03 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On <a moz-do-not-send="true" href="tel:27.06.2017%2012" value="+12706201712">27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos




_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/f71979e8/attachment-0002.html>

------------------------------

Message: 13
Date: Tue, 27 Jun 2017 10:53:03 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos




_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/f71979e8/attachment-0003.html>

------------------------------

Message: 14
Date: Tue, 27 Jun 2017 11:00:23 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="utf-8"

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.


Von: protege-user [mailto:[hidden email]] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 12:46
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi,

I think, the reason behind your question is because you are confusing OWL with object-oriented languages: they are completely different.

In object-oriented (programming) languages, properties are understood as members of some class. That?s why it makes sense to say ?properties of a class?, and moreover, semantics of inheritance may allow properties of a class to be inherited by its subclass or instances of its subclass.

In contrast, in OWL, there is no such thing as properties of a class. Properties are first class citizens of the language, that is, they can be declared in an ontology without being attached to a class.

To your question, when you create an individual socrates and asserts it to be an instance of a class Human, you actually only say that socrates is an element of the set the class Human refers to. (This is the precise reading of ?socrates is a Human? in OWL).
If you then have a subclass axiom: Human subClassOf Mortal, then this subclass axiom together with your previous assertion regarding socrates allow you to infer that socrates is an element of the set that the class Mortal refers to, but nothing more than that.

Your other statement ?Mortal subClassOf hasYearOfDeath? is an illegal statement in OWL, i.e., a syntactic error. In OWL, you can say any of the following:

1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

Jos


Other choices will lead to other consequences.

?adila


On Jun 27, 2017, at 6:17 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos
_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/be0635be/attachment-0001.html>

------------------------------

Message: 15
Date: Tue, 27 Jun 2017 07:34:49 -0400
From: Adila Alfa Krisnadhi <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

Hi Jos,

See my response at the end.

> On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]> wrote:
>
> Hi Adila
>
> Thank you for your detailed reply. See my question below toward the end of you reply.
>
>
>
> 1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
> 1a. Mortal subClassOf hasYearOfDeath some C
> 1b. Mortal subClassOf hasYearOfDeath only C
> 1c. Mortal subClassOf hasYearOfDeath min n C
> 1d. Mortal subClassOf hasYearOfDeath max n C
> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>
> 2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
> 2a. Mortal subClassOf hasYearOfDeath some DR
> 2b. Mortal subClassOf hasYearOfDeath only DR
> 2c. Mortal subClassOf hasYearOfDeath min n DR
> 2d. Mortal subClassOf hasYearOfDeath max n DR
>
> Which expression did you intend to have?
>
> If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
> If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.
>
>
> Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they?re solving is ontology consistency problem. That is, the question: ?Is the input ontology consistent??
The question is equivalent to asking ?Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?? (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer ?Yes, the ontology is consistent? because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the reasoner would answer with ?yes?. Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don?t know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

?adila









-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/39d5be2c/attachment-0001.html>

------------------------------

Message: 16
Date: Tue, 27 Jun 2017 14:18:31 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

That's not possible. What would be the "default value"? Who decides on
the default value? And how would you define that in OWL? OWL is the base
language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the
definition of such an axiom needs a value and anything in Protege is
based on the allowed OWL axioms and other constructs only.


On 27.06.2017 12:53, Jos Lehmann wrote:
>
> Hi Lorenz
>
>
>
> I mean: asserting the property when creating the individual either
> with a default value (e.g. not asserted) or without a value at all (I
> know that is not possible in Prot?g?, but I am not sure why that is
> the case).
>
>
>
> In my example:
>
>
>
> ?         Why, when creating the individual socrates TypeOf Human,
> doesn?t socrates automatically get, for instance, hasLiteracyLevel
> (for the sake of the example, I am assuming this property is
> introduced on/defining of class Human) with a default value or no
> asserted value (for sake of the example, the property would range on a
> numeric scale 0 to 5)?
>
> ?         Also why, after deducing socrates TypeOf Mortal, doesn?t
> socrates get, for instance, hasYearOfDeath (for the sake of the
> example I am assuming this property is introduced on/defining of class
> Mortal) with a default value or no asserted value (the property would
> range on a calendar)?
>
>
>
>
>
> Thanks Jos
>
>
>
>
>
> *Von:*protege-user [mailto:[hidden email]]
> *Im Auftrag von *Lorenz Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 12:24
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically
> get assigned all properties of their class and superclasses?
>
>
>
> Automatically asserted? How? What would be the automatic value of
> `hasYearOfDeath`?
>
>
>
> On 27.06.2017 12:17, Jos Lehmann wrote:
>
>     Hi there
>
>
>
>     A general question: is there reference explaining why, when
>     creating an OWL individual (socrates) of a class (Human subClassOf
>     Mortal), all properties of that class and of its superclasses
>     (Mortal subClassOf hasYearOfDeath) are not automatically asserted
>     for the created individual? Is an implicit assertion made, i.e.
>     inconsistency arises only in case properties are asserted for the
>     individual that contradict properties stated in the
>     class/superclasses?
>
>
>
>     Thanks, Jos
>
>
>
>
>     _______________________________________________
>
>     protege-user mailing list
>
>     [hidden email]
>     <mailto:[hidden email]>
>
>     https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/cadeb9f0/attachment-0001.html>

------------------------------

Message: 17
Date: Tue, 27 Jun 2017 14:06:15 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Adila & Lorenz

Thank you for both your replies. The two parts of Adila's last reply marked in yellow below seem to me to answer my original question, i.e.


1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual

2.       such assertions are implicit, and the reasoner can be queried about them

I'd add: Prot?g? does not make such assertions explicit.

Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.

Thanks, Jos


----------------------------------------------------


Von: protege-user [mailto:[hidden email]] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 13:35
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi Jos,

See my response at the end.

On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.



1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they're solving is ontology consistency problem. That is, the question: "Is the input ontology consistent?"
The question is equivalent to asking "Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?" (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer "Yes, the ontology is consistent" because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
"(hasYearOfDeath some rdfs:Literal)(socrates)" and then check if the reasoner would answer with "yes". Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)" and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don't know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

-adila



Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 14:19
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.

On 27.06.2017 12:53, Jos Lehmann wrote:
Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/06aff8fa/attachment-0002.html>

------------------------------

Message: 18
Date: Tue, 27 Jun 2017 14:06:15 +0000
From: Jos Lehmann <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>, "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <A286D8DA9B2E3B4581355AFD9B0B39[hidden email]-luftfahrt.corp>

Content-Type: text/plain; charset="iso-8859-1"

Hi Adila & Lorenz

Thank you for both your replies. The two parts of Adila's last reply marked in yellow below seem to me to answer my original question, i.e.


1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual

2.       such assertions are implicit, and the reasoner can be queried about them

I'd add: Prot?g? does not make such assertions explicit.

Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.

Thanks, Jos


----------------------------------------------------


Von: protege-user [mailto:[hidden email]] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 13:35
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi Jos,

See my response at the end.

On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.



1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they're solving is ontology consistency problem. That is, the question: "Is the input ontology consistent?"
The question is equivalent to asking "Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?" (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer "Yes, the ontology is consistent" because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
"(hasYearOfDeath some rdfs:Literal)(socrates)" and then check if the reasoner would answer with "yes". Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)" and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don't know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

-adila



Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 14:19
An: [hidden email]
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.

On 27.06.2017 12:53, Jos Lehmann wrote:
Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn't socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn't socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/06aff8fa/attachment-0003.html>

------------------------------

Message: 19
Date: Tue, 27 Jun 2017 14:21:10 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Cc: "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

OWL RL does not support owl:allValuesFrom in a subclass expression [1] which makes the equivalence axiom working only in one direction.

Yup.

It is worth noting that the OWL 2 RL profile supports a restricted subset of OWL and will not produce all the inferences that reasoners such as HermiT and Pellet will. These reasoners support the full language. For the majority of ontologies these restrictions are not significant. See [1] for some details on the SWRLTab?s OWL 2 RL implementation..

Martin

[1] http://ceur-ws.org/Vol-849/paper_31.pdf


On 27.06.2017 04:06, Martin O'Connor wrote:

Can you send the ontology to me.

It is possible that the OWL 2 RL profile supported by the SWRLTab does not support this conclusion (though I think it should).

Martin

On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]<mailto:[hidden email]>> wrote:

Claire already shares her ontology.

The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.

The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.

With best regards,
Samson


On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email]<mailto:[hidden email]>> wrote:


I'm wondering how HemiT can infer this...

We still have the open world assumption, i.e. the conclusion that

:Apple1 rdf:type :SmallApple

is not possible - given that I did not overlook something.

Can you share the ontology?

On 26.06.2017 10:58, claire Qiu wrote:
Hi,
here is my modelling:
#    Object Properties
:hasObject rdf:type owl:ObjectProperty ;
           rdfs:subPropertyOf owl:topObjectProperty .
:hasSize rdf:type owl:ObjectProperty ,
                  owl:FunctionalProperty .

#    Classes
:Apple rdf:type owl:Class .
:HappyKid rdf:type owl:Class ;
          owl:equivalentClass [ rdf:type owl:Restriction ;
                                owl:onProperty :hasObject ;
                                owl:someValuesFrom :SmallApple
                              ] .
:Small rdf:type owl:Class .
:SmallApple rdf:type owl:Class ;
            owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:someValuesFrom :Small
                                                       ]
                                                       [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:allValuesFrom :Small
                                                       ]
                                                     ) ;
                                  rdf:type owl:Class
                                ] .

#    Individuals
:Apple1 rdf:type owl:NamedIndividual ,
                 :Apple ;
        :hasSize :Small1 .
:Jimmy rdf:type owl:NamedIndividual ;
       :hasObject :Apple1 .
:Small1 rdf:type owl:NamedIndividual ,
                 :Small .

SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)


After run the Drool, it cannot infer that Jimmy is a HappyKid.


But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.

Can someone please explain the differences?

Best,
Claire




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/47806224/attachment-0002.html>

------------------------------

Message: 20
Date: Tue, 27 Jun 2017 14:21:10 +0000
From: "Martin O'Connor" <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Cc: "[hidden email]"
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

OWL RL does not support owl:allValuesFrom in a subclass expression [1] which makes the equivalence axiom working only in one direction.

Yup.

It is worth noting that the OWL 2 RL profile supports a restricted subset of OWL and will not produce all the inferences that reasoners such as HermiT and Pellet will. These reasoners support the full language. For the majority of ontologies these restrictions are not significant. See [1] for some details on the SWRLTab?s OWL 2 RL implementation..

Martin

[1] http://ceur-ws.org/Vol-849/paper_31.pdf


On 27.06.2017 04:06, Martin O'Connor wrote:

Can you send the ontology to me.

It is possible that the OWL 2 RL profile supported by the SWRLTab does not support this conclusion (though I think it should).

Martin

On Jun 26, 2017, at 11:53 AM, Samson Tu <[hidden email]<mailto:[hidden email]>> wrote:

Claire already shares her ontology.

The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.

The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.

With best regards,
Samson


On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email]<mailto:[hidden email]>> wrote:


I'm wondering how HemiT can infer this...

We still have the open world assumption, i.e. the conclusion that

:Apple1 rdf:type :SmallApple

is not possible - given that I did not overlook something.

Can you share the ontology?

On 26.06.2017 10:58, claire Qiu wrote:
Hi,
here is my modelling:
#    Object Properties
:hasObject rdf:type owl:ObjectProperty ;
           rdfs:subPropertyOf owl:topObjectProperty .
:hasSize rdf:type owl:ObjectProperty ,
                  owl:FunctionalProperty .

#    Classes
:Apple rdf:type owl:Class .
:HappyKid rdf:type owl:Class ;
          owl:equivalentClass [ rdf:type owl:Restriction ;
                                owl:onProperty :hasObject ;
                                owl:someValuesFrom :SmallApple
                              ] .
:Small rdf:type owl:Class .
:SmallApple rdf:type owl:Class ;
            owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:someValuesFrom :Small
                                                       ]
                                                       [ rdf:type owl:Restriction ;
                                                         owl:onProperty :hasSize ;
                                                         owl:allValuesFrom :Small
                                                       ]
                                                     ) ;
                                  rdf:type owl:Class
                                ] .

#    Individuals
:Apple1 rdf:type owl:NamedIndividual ,
                 :Apple ;
        :hasSize :Small1 .
:Jimmy rdf:type owl:NamedIndividual ;
       :hasObject :Apple1 .
:Small1 rdf:type owl:NamedIndividual ,
                 :Small .

SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)


After run the Drool, it cannot infer that Jimmy is a HappyKid.


But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.

Can someone please explain the differences?

Best,
Claire




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user




_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/47806224/attachment-0003.html>

------------------------------

Message: 21
Date: Tue, 27 Jun 2017 16:23:44 +0200
From: Lorenz Buehmann <[hidden email]>
To: [hidden email]
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>
Content-Type: text/plain; charset="windows-1252"



On 27.06.2017 16:06, Jos Lehmann wrote:
>
> Hi Adila & Lorenz
>
>
>
> Thank you for both your replies. The two parts of Adila?s last reply
> marked in yellow below seem to me to answer my original question, i.e.
>
>
>
> 1.       the reasoner does not /explicitly/ derive assertions of
> properties from the class (or superclass) that classifies an individual
>
What? Inferencing by a reasoner makes implicit assertions explicit. Not
the other way around.
owl:hasValue can be used to infer property assertions from ac lass
definition: For example,

A subClassOf p value x
a1 type A
-> a1 p x

> 2.       such assertions are implicit, and the reasoner can be queried
> about them
>
The reasoner can be queried? Use the OWL API to query for something. Or
use the DL Query tab in Protege that makes use of an OWL reasoner.
>
>
>
> I?d add: Prot?g? does not make such assertions explicit.
>
If you run the reasoner from the menu command, some of the inferred
assertions will be shown in the Protege editor. I said "some" because
you can configure it in the preferences and moreover, for some
assertions it's even not intended in order to ensure some degree of
performance of the editor. In addition, you can export inferred axioms.
>
>
>
> Also, I am not sure how to query the reasoner within or without
> Prot?g?. If you can direct me at resources on how to learn that, that
> would help me.
>
>
>
> Thanks, Jos
>
>
>
>
>
> ----------------------------------------------------
>
>
>
>
>
> *Von:*protege-user [mailto:[hidden email]]
> *Im Auftrag von *Adila Alfa Krisnadhi
> *Gesendet:* Dienstag, 27. Juni 2017 13:35
> *An:* User support for WebProtege and Protege Desktop
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically
> get assigned all properties of their class and superclasses?
>
>
>
> Hi Jos,
>
>
>
> See my response at the end.
>
>
>
> On Jun 27, 2017, at 7:00 AM, Jos Lehmann
> <[hidden email]
> <mailto:[hidden email]>> wrote:
>
>
>
> Hi Adila
>
>
>
> Thank you for your detailed reply. See my question below toward the
> end of you reply.
>
>
>
>
>
>
>
> 1. If hasYearOfDeath is an object property (pointing to individuals),
> then you can state any of the following where n is a nonnegative
> integer, C is a class expression, which can be complex or atomic
> (including owl:Thing and owl:Nothing):
>
> 1a. Mortal subClassOf hasYearOfDeath some C
>
> 1b. Mortal subClassOf hasYearOfDeath only C
>
> 1c. Mortal subClassOf hasYearOfDeath min n C
>
> 1d. Mortal subClassOf hasYearOfDeath max n C
>
> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>
>
>
> 2. If hasYearOfDeath is a data property (pointing to literal values),
> then you can state any of the following where n is a nonnegative
> integer, DR is a data range (including datatypes).
>
> 2a. Mortal subClassOf hasYearOfDeath some DR
>
> 2b. Mortal subClassOf hasYearOfDeath only DR
>
> 2c. Mortal subClassOf hasYearOfDeath min n DR
>
> 2d. Mortal subClassOf hasYearOfDeath max n DR
>
>
>
> Which expression did you intend to have?
>
>
>
> If you chose 1a and pick owl:Thing for the class expression C, then
> together with the previous assertion and subclass axiom, you can infer
> that socrates is related to some (unnamed) object through hasYearOfDeath.
>
> If you chose 2a and pick rdfs:Literal for DR, then together with the
> previous assertion and subclass axiom, you can infer that socrates is
> related to some (unknown) literal value through hasYearOfDeath.
>
>
>
>
>
> Suppose I pick your second option above: would the reasoner assert for
> individual socrates the property hasYearOfDeath to some unknown
> Literal? As far as I can tell it does not/ would not.
>
>
>
> What reasoner are you using for this?
>
> For most OWL reasoners, such as Hermit or Pellet, the basic reasoning
> problem they?re solving is ontology consistency problem. That is, the
> question: ?Is the input ontology consistent??
>
> The question is equivalent to asking ?Does the input ontology have a
> model, i.e., an interpretation satisfying all of its axioms?? (model
> and interpretation here is in the sense of OWL Direct semantics).
>
>
>
> In our case, EVERY model of the set of three statements (individual
> assertion, subclass axiom, and axiom for 2a) would necessarily contain
> an instantiation of a binary relationship from socrates to some
> unknown literal. Hence, such a relationship is really inferred,
> meaning the aforementioned relationship MUST necessarily hold.
>
>
>
> Hermit and Pellet would derive that inference, but would not make an
> explicit statement about that relationship. Instead they will only
> return an answer ?Yes, the ontology is consistent? because they
> discover that the statements have a model and thus the relationship
> must hold.
>
>
>
> If you really want to check if the reasoner can derive such a
> particular relationship, then you need to ask it directly in the form
> of query answering.There are different ways to express the query. One
> of it would be asking the query
>
> ?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the
> reasoner would answer with ?yes?. Or you could ask the query
> "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is
> one of the answer.
>
>
>
> Unfortunately, I never explore Protege interface features for this
> task, if any, so I don?t know how to actually do it in Protege.
>
>
>
> Alternatively, you could check if a relationship from socrates to some
> literal value via hasYearOfDeath actually holds by using the
> consistency checking. You could do it by asserting that socrates is an
> instance of the class (not hasYearOfDeath some rdfs:Literal), in
> addition to the three previous statements. If after running the
> reasoner, it says that the ontology is not consistent, then the
> relationship is actually inferred.
>
>
>
> ?adila
>
>
>
>
>
>
>
> *Von:*protege-user [mailto:[hidden email]]
> *Im Auftrag von *Lorenz Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 14:19
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically
> get assigned all properties of their class and superclasses?
>
>
>
> That's not possible. What would be the "default value"? Who decides on
> the default value? And how would you define that in OWL? OWL is the
> base language of the things that you can edit in Protege.
>
> And you can not add a property to an individual without a value - the
> definition of such an axiom needs a value and anything in Protege is
> based on the allowed OWL axioms and other constructs only.
>
>
>
> On 27.06.2017 12:53, Jos Lehmann wrote:
>
>     Hi Lorenz
>
>
>
>     I mean: asserting the property when creating the individual either
>     with a default value (e.g. not asserted) or without a value at all
>     (I know that is not possible in Prot?g?, but I am not sure why
>     that is the case).
>
>
>
>     In my example:
>
>
>
>     ?         Why, when creating the individual socrates TypeOf Human,
>     doesn?t socrates automatically get, for instance, hasLiteracyLevel
>     (for the sake of the example, I am assuming this property is
>     introduced on/defining of class Human) with a default value or no
>     asserted value (for sake of the example, the property would range
>     on a numeric scale 0 to 5)?
>
>     ?         Also why, after deducing socrates TypeOf Mortal, doesn?t
>     socrates get, for instance, hasYearOfDeath (for the sake of the
>     example I am assuming this property is introduced on/defining of
>     class Mortal) with a default value or no asserted value (the
>     property would range on a calendar)?
>
>
>
>
>
>     Thanks Jos
>
>
>
>
>
>     *Von:*protege-user
>     [mailto:[hidden email]] *Im Auftrag von
>     *Lorenz Buehmann
>     *Gesendet:* Dienstag, 27. Juni 2017 12:24
>     *An:* [hidden email]
>     <mailto:[hidden email]>
>     *Betreff:* Re: [protege-user] Why don't OWL individuals
>     automatically get assigned all properties of their class and
>     superclasses?
>
>
>
>     Automatically asserted? How? What would be the automatic value of
>     `hasYearOfDeath`?
>
>
>
>     On 27.06.2017 12:17, Jos Lehmann wrote:
>
>         Hi there
>
>
>
>         A general question: is there reference explaining why, when
>         creating an OWL individual (socrates) of a class (Human
>         subClassOf Mortal), all properties of that class and of its
>         superclasses (Mortal subClassOf hasYearOfDeath) are not
>         automatically asserted for the created individual? Is an
>         implicit assertion made, i.e. inconsistency arises only in
>         case properties are asserted for the individual that
>         contradict properties stated in the class/superclasses?
>
>
>
>         Thanks, Jos
>
>
>
>
>
>         _______________________________________________
>
>         protege-user mailing list
>
>         [hidden email]
>         <mailto:[hidden email]>
>
>         https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
>
>     _______________________________________________
>
>     protege-user mailing list
>
>     [hidden email]
>     <mailto:[hidden email]>
>
>     https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/17e1f98c/attachment-0001.html>

------------------------------

Message: 22
Date: Tue, 27 Jun 2017 10:44:23 -0400
From: Adila Alfa Krisnadhi <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get     assigned all properties of their class and superclasses?
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

Hi,

I think my reply earlier was a little bit not precise and the use of explicit vs implicit was probably misleading.
So let me clarify below.

> On Jun 27, 2017, at 10:23 AM, Lorenz Buehmann <[hidden email]> wrote:
>
>
>
> On 27.06.2017 16:06, Jos Lehmann wrote:
>> Hi Adila & Lorenz
>>
>> Thank you for both your replies. The two parts of Adila?s last reply marked in yellow below seem to me to answer my original question, i.e.
>>
>> 1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual
> What? Inferencing by a reasoner makes implicit assertions explicit. Not the other way around.
> owl:hasValue can be used to infer property assertions from ac lass definition: For example,

What I meant was that when reasoners are used in conjunction with a user interface such as Protege, some of the logical consequences may not necessary be displayed. In fact, some ontologies may have infinitely many logical consequences even when restricted to the ontology?s signature symbols. Hence, it is normal if some of them are not displayed. So, I didn?t mean that it was not explicit in the way you described since of course reasoners make implicit assertions explicit.

>
> A subClassOf p value x
> a1 type A
> -> a1 p x

What is x here? A specific named individual?
I don?t think that this is necessarily what Jos intended. He just wanted to infer that a1 ?has a property? somewhat similar to the frame-based reading of object-oriented languages, and not necessarily inferring that a1 has a p-relation to specific individual x.


>
>> 2.       such assertions are implicit, and the reasoner can be queried about them
> The reasoner can be queried? Use the OWL API to query for something. Or use the DL Query tab in Protege that makes use of an OWL reasoner.

This may just be a minor misunderstanding.
Of course a reasoner can be queried, otherwise, how would you know the result of reasoning? The question is how. Using OWL API is one way to do it, that is, we fundamentally do not query the OWL API itself, but rather query the reasoner through OWL API.
Some reasoner such as Hermit provides other means to access the result of reasoning, e.g., command line (see http://www.hermit-reasoner.com/command.html <http://www.hermit-reasoner.com/command.html>).

regards,
?adila



>>
>> I?d add: Prot?g? does not make such assertions explicit.
> If you run the reasoner from the menu command, some of the inferred assertions will be shown in the Protege editor. I said "some" because you can configure it in the preferences and moreover, for some assertions it's even not intended in order to ensure some degree of performance of the editor. In addition, you can export inferred axioms.
>>
>> Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.
>>
>> Thanks, Jos
>>
>>
>> ----------------------------------------------------
>>
>>
>> Von: protege-user [mailto:[hidden email] <mailto:[hidden email]>] Im Auftrag von Adila Alfa Krisnadhi
>> Gesendet: Dienstag, 27. Juni 2017 13:35
>> An: User support for WebProtege and Protege Desktop
>> Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?
>>
>> Hi Jos,
>>
>> See my response at the end.
>>
>> On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email] <mailto:[hidden email]>> wrote:
>>
>> Hi Adila
>>
>> Thank you for your detailed reply. See my question below toward the end of you reply.
>>
>>
>>
>> 1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
>> 1a. Mortal subClassOf hasYearOfDeath some C
>> 1b. Mortal subClassOf hasYearOfDeath only C
>> 1c. Mortal subClassOf hasYearOfDeath min n C
>> 1d. Mortal subClassOf hasYearOfDeath max n C
>> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>>
>> 2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
>> 2a. Mortal subClassOf hasYearOfDeath some DR
>> 2b. Mortal subClassOf hasYearOfDeath only DR
>> 2c. Mortal subClassOf hasYearOfDeath min n DR
>> 2d. Mortal subClassOf hasYearOfDeath max n DR
>>
>> Which expression did you intend to have?
>>
>> If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
>> If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.
>>
>>
>> Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.
>>
>> What reasoner are you using for this?
>> For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they?re solving is ontology consistency problem. That is, the question: ?Is the input ontology consistent??
>> The question is equivalent to asking ?Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?? (model and interpretation here is in the sense of OWL Direct semantics).
>>
>> In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.
>>
>> Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer ?Yes, the ontology is consistent? because they discover that the statements have a model and thus the relationship must hold.
>>
>> If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
>> ?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the reasoner would answer with ?yes?. Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one of the answer.
>>
>> Unfortunately, I never explore Protege interface features for this task, if any, so I don?t know how to actually do it in Protege.
>>
>> Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.
>>
>> ?adila
>>
>>
>>
>> Von: protege-user [mailto:[hidden email] <mailto:[hidden email]>] Im Auftrag von Lorenz Buehmann
>> Gesendet: Dienstag, 27. Juni 2017 14:19
>> An: [hidden email] <mailto:[hidden email]>
>> Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?
>>
>> That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.
>>
>> And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.
>>
>>
>> On 27.06.2017 12:53, Jos Lehmann wrote:
>> Hi Lorenz
>>
>> I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).
>>
>> In my example:
>>
>> ?         Why, when creating the individual socrates TypeOf Human, doesn?t socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?
>> ?         Also why, after deducing socrates TypeOf Mortal, doesn?t socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?
>>
>>
>> Thanks Jos
>>
>>
>> Von: protege-user [mailto:[hidden email] <mailto:[hidden email]>] Im Auftrag von Lorenz Buehmann
>> Gesendet: Dienstag, 27. Juni 2017 12:24
>> An: [hidden email] <mailto:[hidden email]>
>> Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?
>>
>> Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?
>>
>>
>> On 27.06.2017 12:17, Jos Lehmann wrote:
>> Hi there
>>
>> A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?
>>
>> Thanks, Jos
>>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>
> _______________________________________________
> protege-user mailing list
> [hidden email] <mailto:[hidden email]>
> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/5c521d0a/attachment-0001.html>

------------------------------

Message: 23
Date: Tue, 27 Jun 2017 08:24:51 -0700
From: Samson Tu <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Question about Drool reasoning
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="windows-1252"

Actually, I just copy and pasted most of the ontology-defining email text (minus the swrl rule) to a file and loaded it in Protege. I only had to enter the swrl rule manually. I used Protege's explanation facility to see that "Jimmie is a HappyKid" could be inferred in two ways.

Thanks for pointing out that RL does not support owl:allValuesFrom.

With best regards,
Samson


> On Jun 27, 2017, at 1:23 AM, Lorenz Buehmann <[hidden email]> wrote:
>
> @Samson: Right, but not a complete document such that one could load it e.g. into Protege for debugging.
>
> Cheers,
>
> Lorenz
>
> On 26.06.2017 20:53, Samson Tu wrote:
>> Claire already shares her ontology.
>>
>> The property hasSize is functional. Given that Apple1 hasSize Small1 (of type Small), Apple1 is a SmallApple.
>>
>> The Drool-based SWRLTab should have concluded that Jimmie is a HappyKid w/o the equivalence definition of HappyKid. The Pellet reasoner uses the SWRL rule to make that conclusion.
>>
>> With best regards,
>> Samson
>>
>>
>>> On Jun 26, 2017, at 2:24 AM, Lorenz Buehmann <[hidden email] <mailto:[hidden email]>> wrote:
>>>
>>> I'm wondering how HemiT can infer this...
>>>
>>> We still have the open world assumption, i.e. the conclusion that
>>> :Apple1 rdf:type :SmallApple
>>>
>>> is not possible - given that I did not overlook something.
>>> Can you share the ontology?
>>>
>>> On 26.06.2017 10:58, claire Qiu wrote:
>>>> Hi,
>>>> here is my modelling:
>>>> #    Object Properties
>>>> :hasObject rdf:type owl:ObjectProperty ;
>>>>            rdfs:subPropertyOf owl:topObjectProperty .
>>>> :hasSize rdf:type owl:ObjectProperty ,
>>>>                   owl:FunctionalProperty .
>>>>
>>>> #    Classes
>>>> :Apple rdf:type owl:Class .
>>>> :HappyKid rdf:type owl:Class ;
>>>>           owl:equivalentClass [ rdf:type owl:Restriction ;
>>>>                                 owl:onProperty :hasObject ;
>>>>                                 owl:someValuesFrom :SmallApple
>>>>                               ] .
>>>> :Small rdf:type owl:Class .
>>>> :SmallApple rdf:type owl:Class ;
>>>>             owl:equivalentClass [ owl:intersectionOf ( [ rdf:type owl:Restriction ;
>>>>                                                          owl:onProperty :hasSize ;
>>>>                                                          owl:someValuesFrom :Small
>>>>                                                        ]
>>>>                                                        [ rdf:type owl:Restriction ;
>>>>                                                          owl:onProperty :hasSize ;
>>>>                                                          owl:allValuesFrom :Small
>>>>                                                        ]
>>>>                                                      ) ;
>>>>                                   rdf:type owl:Class
>>>>                                 ] .
>>>>
>>>> #    Individuals
>>>> :Apple1 rdf:type owl:NamedIndividual ,
>>>>                  :Apple ;
>>>>         :hasSize :Small1 .
>>>> :Jimmy rdf:type owl:NamedIndividual ;
>>>>        :hasObject :Apple1 .
>>>> :Small1 rdf:type owl:NamedIndividual ,
>>>>                  :Small .
>>>>
>>>> SWRL rule:  SmallApple(?x) ^ hasObject(?y, ?x) -> HappyKid(?y)
>>>>
>>>>
>>>> After run the Drool, it cannot infer that Jimmy is a HappyKid.
>>>>
>>>>
>>>> But, if I model HappyKid as a class: HappyKid isEquvilentTo hasObject some SmallApple, the Hermit reasoner can infer that Jimmy is a HappyKid.
>>>>
>>>> Can someone please explain the differences?
>>>>
>>>> Best,
>>>> Claire
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> protege-user mailing list
>>>> [hidden email] <mailto:[hidden email]>
>>>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>>
>>> _______________________________________________
>>> protege-user mailing list
>>> [hidden email] <mailto:[hidden email]>
>>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>>
>>
>>
>> _______________________________________________
>> protege-user mailing list
>> [hidden email] <mailto:[hidden email]>
>> https://mailman.stanford.edu/mailman/listinfo/protege-user <https://mailman.stanford.edu/mailman/listinfo/protege-user>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/150d6f93/attachment-0001.html>

------------------------------

Message: 24
Date: Tue, 27 Jun 2017 10:48:38 -0700
From: Samson Tu <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Help regarding the Classes present in
        PROV-O
Message-ID: <[hidden email]>
Content-Type: text/plain; charset="utf-8"

Hi,

Your question is really out of scope for the [hidden email] <mailto:[hidden email]>.

Had you checked the documentation comments associated with subclasses of Influence? For example, the Communication class has the comment:

An instance of prov:Communication provides additional descriptions about the binary prov:wasInformedBy relation from an informed prov:Activity to the prov:Activity that informed it. For example, :you_jumping_off_bridge prov:wasInformedBy :everyone_else_jumping_off_bridge; prov:qualifiedCommunication [ a prov:Communication; prov:activity :everyone_else_jumping_off_bridge; :foo :bar ].

The point is that an object property like prov:wasInformedBy is a binary relation allowing you to say only

you_jumping_off_bridge prov:wasInformedBy :everyone_else_jumping_off_bridge;

Therefore, if you want to qualify the relation with additional facts (e.g., the date of communication), the ?Communication? class reifies the prov:wasInformedBy relation, so that you can say, for example,

you_jumping_off_bridge prov:qualifiedCommunication
        [ a prov:Communication;
         prov:activity :everyone_else_jumping_off_bridge;
        :date ?2017-01-17?
        ... ].

See also [1]

With best regards,
Samson

[1] https://www.w3.org/TR/swbp-n-aryRelations/ <https://www.w3.org/TR/swbp-n-aryRelations/>


> On Jun 17, 2017, at 9:10 AM, mrinal pandey <[hidden email]> wrote:
>
> Dear all,
> I have created an Ontology, have implemented some rules in it, have also
> Imported the PROV-O Ontology of entity, agent and actvity and have thus
> embedded provenance descriptions to the same reading the PROV-DM and PROV-O
> primer of w3c consortium. However I  have a confusion here. I am unable to
> figure out how to implement Influence classes in like activity influence,
> agent influence and entity influence, despite reading the examples present
> in the PROV-O specification. Would thus request one and all to help me in
> implementing the same. It would be very nice if someone could tell me how to
> implement these classes, is it just by creating the instances of the same or
> is it some other way. I would greatly appreciate if someone could explain
> the same by the help of a small example implemented practically.I am getting
> confused as to when and how to implement classes and when an how to
> implement the object properties of the same.
> Refer to screenshot attached for further details.
> <http://protege-project.136.n4.nabble.com/file/n4668848/Protege_question.jpg>
>
>
>
> --
> View this message in context: http://protege-project.136.n4.nabble.com/Help-regarding-the-Classes-present-in-PROV-O-tp4668848.html
> Sent from the Protege User mailing list archive at Nabble.com.
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user

--
Samson Tu                                                      email: [hidden email]
Senior Research Engineer                              web: www.stanford.edu/~swt/
Center for Biomedical Informatics Research      phone: 1-650-725-3391
Stanford University                                          fax: 1-650-725-7944



-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/e1ac5d37/attachment-0001.html>

------------------------------

Message: 25
Date: Tue, 27 Jun 2017 11:22:38 -0700
From: Michael DeBellis <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <CALGFikf7A=6_cJwmkF7hyoMX1RMch_nEjb-_-7L_hJom9T=[hidden email]>
Content-Type: text/plain; charset="utf-8"

Jos,

OWL doesn't do default values. I think the reason is that it also doesn't
treat failure as negation. I.e., you can't assume that because there is no
value known that one doesn't actually exist. So given that you can't reason
about which objects should be given default values. Just because they don't
have values at that point in time doesn't mean they aren't there. This is
known as the Open World assumption which is different than the Closed World
assumption that many languages use. For example in Lisp nil is equivalent
to false.

Regarding your second question "how to query the reasoner" just a matter of
terminology but you don't query the reasoner. You query the ontology and
the reasoner makes changes to the ontology. There are many ways to query
the ontology. One way is to use SQWRL, its an extension of SWRL but just
for doing queries.

You can also use Protege to type DL queries. Go to Window>Tabs>DL Query and
you will see a new tab that lets you type DL Queries and see the results.
Note: if you use this pay attention to the check box in the lower right
corner that says "Query for" the default is that instances is not checked
in that box so the first time people use it (at least the first time I used
it) it can be confusing because you can give a query that returns a bunch
of instances but not see them because the Instances box isn't checked.

BTW, if you are interested in using SWRL and SQWRL here is a brief tutorial
I wrote that introduces them using a process modeling example:

http://symbolicshacker.blogspot.com/2017/06/swrl-process-modeling-tutorial.html

Cheers,

Michael

On Tue, Jun 27, 2017 at 7:06 AM, Jos Lehmann <
[hidden email]> wrote:

> Hi Adila & Lorenz
>
>
>
> Thank you for both your replies. The two parts of Adila?s last reply
> marked in yellow below seem to me to answer my original question, i.e.
>
>
>
> 1.       the reasoner does not *explicitly* derive assertions of
> properties from the class (or superclass) that classifies an individual
>
> 2.       such assertions are implicit, and the reasoner can be queried
> about them
>
>
>
> I?d add: Prot?g? does not make such assertions explicit.
>
>
>
> Also, I am not sure how to query the reasoner within or without Prot?g?.
> If you can direct me at resources on how to learn that, that would help me.
>
>
>
> Thanks, Jos
>
>
>
>
>
> ----------------------------------------------------
>
>
>
>
>
> *Von:* protege-user [mailto:[hidden email]] *Im
> Auftrag von *Adila Alfa Krisnadhi
> *Gesendet:* Dienstag, 27. Juni 2017 13:35
> *An:* User support for WebProtege and Protege Desktop
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically get
> assigned all properties of their class and superclasses?
>
>
>
> Hi Jos,
>
>
>
> See my response at the end.
>
>
>
> On Jun 27, 2017, at 7:00 AM, Jos Lehmann <Jos.Lehmann@bauhaus-
> luftfahrt.net> wrote:
>
>
>
> Hi Adila
>
>
>
> Thank you for your detailed reply. See my question below toward the end of
> you reply.
>
>
>
>
>
>
>
> 1. If hasYearOfDeath is an object property (pointing to individuals), then
> you can state any of the following where n is a nonnegative integer, C is a
> class expression, which can be complex or atomic (including owl:Thing and
> owl:Nothing):
>
> 1a. Mortal subClassOf hasYearOfDeath some C
>
> 1b. Mortal subClassOf hasYearOfDeath only C
>
> 1c. Mortal subClassOf hasYearOfDeath min n C
>
> 1d. Mortal subClassOf hasYearOfDeath max n C
>
> 1e. Mortal subClassOf hasYearOfDeath exactly n C
>
>
>
> 2. If hasYearOfDeath is a data property (pointing to literal values), then
> you can state any of the following where n is a nonnegative integer, DR is
> a data range (including datatypes).
>
> 2a. Mortal subClassOf hasYearOfDeath some DR
>
> 2b. Mortal subClassOf hasYearOfDeath only DR
>
> 2c. Mortal subClassOf hasYearOfDeath min n DR
>
> 2d. Mortal subClassOf hasYearOfDeath max n DR
>
>
>
> Which expression did you intend to have?
>
>
>
> If you chose 1a and pick owl:Thing for the class expression C, then
> together with the previous assertion and subclass axiom, you can infer that
> socrates is related to some (unnamed) object through hasYearOfDeath.
>
> If you chose 2a and pick rdfs:Literal for DR, then together with the
> previous assertion and subclass axiom, you can infer that socrates is
> related to some (unknown) literal value through hasYearOfDeath.
>
>
>
>
>
> Suppose I pick your second option above: would the reasoner assert for
> individual socrates the property hasYearOfDeath to some unknown Literal? As
> far as I can tell it does not/ would not.
>
>
>
> What reasoner are you using for this?
>
> For most OWL reasoners, such as Hermit or Pellet, the basic reasoning
> problem they?re solving is ontology consistency problem. That is, the
> question: ?Is the input ontology consistent??
>
> The question is equivalent to asking ?Does the input ontology have a
> model, i.e., an interpretation satisfying all of its axioms?? (model and
> interpretation here is in the sense of OWL Direct semantics).
>
>
>
> In our case, EVERY model of the set of three statements (individual
> assertion, subclass axiom, and axiom for 2a) would necessarily contain an
> instantiation of a binary relationship from socrates to some unknown
> literal. Hence, such a relationship is really inferred, meaning the
> aforementioned relationship MUST necessarily hold.
>
>
>
> Hermit and Pellet would derive that inference, but would not make an
> explicit statement about that relationship. Instead they will only return
> an answer ?Yes, the ontology is consistent? because they discover that the
> statements have a model and thus the relationship must hold.
>
>
>
> If you really want to check if the reasoner can derive such a particular
> relationship, then you need to ask it directly in the form of query
> answering. There are different ways to express the query. One of it would
> be asking the query
>
> ?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the
> reasoner would answer with ?yes?. Or you could ask the query
> "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one
> of the answer.
>
>
>
> Unfortunately, I never explore Protege interface features for this task,
> if any, so I don?t know how to actually do it in Protege.
>
>
>
> Alternatively, you could check if a relationship from socrates to some
> literal value via hasYearOfDeath actually holds by using the consistency
> checking. You could do it by asserting that socrates is an instance of the
> class (not hasYearOfDeath some rdfs:Literal), in addition to the three
> previous statements. If after running the reasoner, it says that the
> ontology is not consistent, then the relationship is actually inferred.
>
>
>
> ?adila
>
>
>
>
>
>
>
> *Von:* protege-user [mailto:[hidden email]] *Im
> Auftrag von *Lorenz Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 14:19
>
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically get
> assigned all properties of their class and superclasses?
>
>
>
> That's not possible. What would be the "default value"? Who decides on the
> default value? And how would you define that in OWL? OWL is the base
> language of the things that you can edit in Protege.
>
> And you can not add a property to an individual without a value - the
> definition of such an axiom needs a value and anything in Protege is based
> on the allowed OWL axioms and other constructs only.
>
>
>
> On 27.06.2017 12:53, Jos Lehmann wrote:
>
> Hi Lorenz
>
>
>
> I mean: asserting the property when creating the individual either with a
> default value (e.g. not asserted) or without a value at all (I know that is
> not possible in Prot?g?, but I am not sure why that is the case).
>
>
>
> In my example:
>
>
>
> ?         Why, when creating the individual socrates TypeOf Human,
> doesn?t socrates automatically get, for instance, hasLiteracyLevel (for the
> sake of the example, I am assuming this property is introduced on/defining
> of class Human) with a default value or no asserted value (for sake of the
> example, the property would range on a numeric scale 0 to 5)?
>
> ?         Also why, after deducing socrates TypeOf Mortal, doesn?t
> socrates get, for instance, hasYearOfDeath (for the sake of the example I
> am assuming this property is introduced on/defining of class Mortal) with a
> default value or no asserted value (the property would range on a calendar)?
>
>
>
>
>
> Thanks Jos
>
>
>
>
>
> *Von:* protege-user [mailto:[hidden email]
> <[hidden email]>] *Im Auftrag von *Lorenz
> Buehmann
> *Gesendet:* Dienstag, 27. Juni 2017 12:24
> *An:* [hidden email]
> *Betreff:* Re: [protege-user] Why don't OWL individuals automatically get
> assigned all properties of their class and superclasses?
>
>
>
> Automatically asserted? How? What would be the automatic value of `
> hasYearOfDeath`?
>
>
>
> On 27.06.2017 12:17, Jos Lehmann wrote:
>
> Hi there
>
>
>
> A general question: is there reference explaining why, when creating an
> OWL individual (socrates) of a class (Human subClassOf Mortal), all
> properties of that class and of its superclasses (Mortal subClassOf
> hasYearOfDeath) are not automatically asserted for the created individual?
> Is an implicit assertion made, i.e. inconsistency arises only in case
> properties are asserted for the individual that contradict properties
> stated in the class/superclasses?
>
>
>
> Thanks, Jos
>
>
>
>
>
> _______________________________________________
>
> protege-user mailing list
>
> [hidden email]
>
> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
>
>
>
> _______________________________________________
>
> protege-user mailing list
>
> [hidden email]
>
> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
>
> _______________________________________________
> protege-user mailing list
> [hidden email]
> https://mailman.stanford.edu/mailman/listinfo/protege-user
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/c186db5a/attachment-0001.html>

------------------------------

Message: 26
Date: Tue, 27 Jun 2017 18:45:44 +0000
From: Dave McComb <[hidden email]>
To: User support for WebProtege and Protege Desktop
        <[hidden email]>
Subject: Re: [protege-user] Why don't OWL individuals automatically
        get assigned all properties of their class and superclasses?
Message-ID:
        <[hidden email]>

Content-Type: text/plain; charset="windows-1252"

If you are interested in negation as failure and constraints in general, I'd recommend SHACL

https://www.w3.org/TR/shacl/


SHACL adds on to OWL, rather than replacing it.  The way we use it is to define open world meaning in owl, that way if you are harvesting data from the web you can take it as is (it's really pointless to try to constrain the web) but then you can have a separate repository for curated data.  Both repositories can share the same OWL and therefore share the same meaning and vocabulary, but only the curated repo has the constraints.


There are extensions to SHACL that provide defaults as well.


Dave McComb

Semantic Arts, Inc.


Shapes Constraint Language (SHACL)<https://www.w3.org/TR/shacl/>
www.w3.org
Abstract. This document defines the SHACL Shapes Constraint Language, a language for validating RDF graphs against a set of conditions. These conditions are provided ...





________________________________
From: protege-user <[hidden email]> on behalf of Michael DeBellis <[hidden email]>
Sent: Tuesday, June 27, 2017 12:22 PM
To: User support for WebProtege and Protege Desktop
Subject: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Jos,

OWL doesn't do default values. I think the reason is that it also doesn't treat failure as negation. I.e., you can't assume that because there is no value known that one doesn't actually exist. So given that you can't reason about which objects should be given default values. Just because they don't have values at that point in time doesn't mean they aren't there. This is known as the Open World assumption which is different than the Closed World assumption that many languages use. For example in Lisp nil is equivalent to false.

Regarding your second question "how to query the reasoner" just a matter of terminology but you don't query the reasoner. You query the ontology and the reasoner makes changes to the ontology. There are many ways to query the ontology. One way is to use SQWRL, its an extension of SWRL but just for doing queries.

You can also use Protege to type DL queries. Go to Window>Tabs>DL Query and you will see a new tab that lets you type DL Queries and see the results. Note: if you use this pay attention to the check box in the lower right corner that says "Query for" the default is that instances is not checked in that box so the first time people use it (at least the first time I used it) it can be confusing because you can give a query that returns a bunch of instances but not see them because the Instances box isn't checked.

BTW, if you are interested in using SWRL and SQWRL here is a brief tutorial I wrote that introduces them using a process modeling example:

http://symbolicshacker.blogspot.com/2017/06/swrl-process-modeling-tutorial.html

Cheers,

Michael

On Tue, Jun 27, 2017 at 7:06 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:
Hi Adila & Lorenz

Thank you for both your replies. The two parts of Adila?s last reply marked in yellow below seem to me to answer my original question, i.e.


1.       the reasoner does not explicitly derive assertions of properties from the class (or superclass) that classifies an individual

2.       such assertions are implicit, and the reasoner can be queried about them

I?d add: Prot?g? does not make such assertions explicit.

Also, I am not sure how to query the reasoner within or without Prot?g?. If you can direct me at resources on how to learn that, that would help me.

Thanks, Jos


----------------------------------------------------


Von: protege-user [mailto:[hidden email]<mailto:[hidden email]>] Im Auftrag von Adila Alfa Krisnadhi
Gesendet: Dienstag, 27. Juni 2017 13:35
An: User support for WebProtege and Protege Desktop
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?

Hi Jos,

See my response at the end.

On Jun 27, 2017, at 7:00 AM, Jos Lehmann <[hidden email]<mailto:[hidden email]>> wrote:

Hi Adila

Thank you for your detailed reply. See my question below toward the end of you reply.



1. If hasYearOfDeath is an object property (pointing to individuals), then you can state any of the following where n is a nonnegative integer, C is a class expression, which can be complex or atomic (including owl:Thing and owl:Nothing):
1a. Mortal subClassOf hasYearOfDeath some C
1b. Mortal subClassOf hasYearOfDeath only C
1c. Mortal subClassOf hasYearOfDeath min n C
1d. Mortal subClassOf hasYearOfDeath max n C
1e. Mortal subClassOf hasYearOfDeath exactly n C

2. If hasYearOfDeath is a data property (pointing to literal values), then you can state any of the following where n is a nonnegative integer, DR is a data range (including datatypes).
2a. Mortal subClassOf hasYearOfDeath some DR
2b. Mortal subClassOf hasYearOfDeath only DR
2c. Mortal subClassOf hasYearOfDeath min n DR
2d. Mortal subClassOf hasYearOfDeath max n DR

Which expression did you intend to have?

If you chose 1a and pick owl:Thing for the class expression C, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unnamed) object through hasYearOfDeath.
If you chose 2a and pick rdfs:Literal for DR, then together with the previous assertion and subclass axiom, you can infer that socrates is related to some (unknown) literal value through hasYearOfDeath.


Suppose I pick your second option above: would the reasoner assert for individual socrates the property hasYearOfDeath to some unknown Literal? As far as I can tell it does not/ would not.

What reasoner are you using for this?
For most OWL reasoners, such as Hermit or Pellet, the basic reasoning problem they?re solving is ontology consistency problem. That is, the question: ?Is the input ontology consistent??
The question is equivalent to asking ?Does the input ontology have a model, i.e., an interpretation satisfying all of its axioms?? (model and interpretation here is in the sense of OWL Direct semantics).

In our case, EVERY model of the set of three statements (individual assertion, subclass axiom, and axiom for 2a) would necessarily contain an instantiation of a binary relationship from socrates to some unknown literal. Hence, such a relationship is really inferred, meaning the aforementioned relationship MUST necessarily hold.

Hermit and Pellet would derive that inference, but would not make an explicit statement about that relationship. Instead they will only return an answer ?Yes, the ontology is consistent? because they discover that the statements have a model and thus the relationship must hold.

If you really want to check if the reasoner can derive such a particular relationship, then you need to ask it directly in the form of query answering. There are different ways to express the query. One of it would be asking the query
?(hasYearOfDeath some rdfs:Literal)(socrates)? and then check if the reasoner would answer with ?yes?. Or you could ask the query "(hasYearOfDeath some rdfs:Literal)(?X)? and check if ?X = socrates is one of the answer.

Unfortunately, I never explore Protege interface features for this task, if any, so I don?t know how to actually do it in Protege.

Alternatively, you could check if a relationship from socrates to some literal value via hasYearOfDeath actually holds by using the consistency checking. You could do it by asserting that socrates is an instance of the class (not hasYearOfDeath some rdfs:Literal), in addition to the three previous statements. If after running the reasoner, it says that the ontology is not consistent, then the relationship is actually inferred.

?adila



Von: protege-user [mailto:[hidden email]<mailto:[hidden email]>] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 14:19

An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


That's not possible. What would be the "default value"? Who decides on the default value? And how would you define that in OWL? OWL is the base language of the things that you can edit in Protege.

And you can not add a property to an individual without a value - the definition of such an axiom needs a value and anything in Protege is based on the allowed OWL axioms and other constructs only.

On 27.06.2017 12:53, Jos Lehmann wrote:
Hi Lorenz

I mean: asserting the property when creating the individual either with a default value (e.g. not asserted) or without a value at all (I know that is not possible in Prot?g?, but I am not sure why that is the case).

In my example:


?         Why, when creating the individual socrates TypeOf Human, doesn?t socrates automatically get, for instance, hasLiteracyLevel (for the sake of the example, I am assuming this property is introduced on/defining of class Human) with a default value or no asserted value (for sake of the example, the property would range on a numeric scale 0 to 5)?

?         Also why, after deducing socrates TypeOf Mortal, doesn?t socrates get, for instance, hasYearOfDeath (for the sake of the example I am assuming this property is introduced on/defining of class Mortal) with a default value or no asserted value (the property would range on a calendar)?


Thanks Jos


Von: protege-user [mailto:[hidden email]] Im Auftrag von Lorenz Buehmann
Gesendet: Dienstag, 27. Juni 2017 12:24
An: [hidden email]<mailto:[hidden email]>
Betreff: Re: [protege-user] Why don't OWL individuals automatically get assigned all properties of their class and superclasses?


Automatically asserted? How? What would be the automatic value of `hasYearOfDeath`?

On 27.06.2017 12:17, Jos Lehmann wrote:
Hi there

A general question: is there reference explaining why, when creating an OWL individual (socrates) of a class (Human subClassOf Mortal), all properties of that class and of its superclasses (Mortal subClassOf hasYearOfDeath) are not automatically asserted for the created individual? Is an implicit assertion made, i.e. inconsistency arises only in case properties are asserted for the individual that contradict properties stated in the class/superclasses?

Thanks, Jos





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user





_______________________________________________

protege-user mailing list

[hidden email]<mailto:[hidden email]>

https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]<mailto:[hidden email]>
https://mailman.stanford.edu/mailman/listinfo/protege-user


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-user/attachments/20170627/4be40804/attachment-0001.html>

------------------------------

Subject: Digest Footer

_______________________________________________
protege-user mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user


------------------------------

End of protege-user Digest, Vol 41, Issue 30
********************************************



_______________________________________________
protege-user mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user


_______________________________________________
protege-user mailing list
[hidden email]
https://mailman.stanford.edu/mailman/listinfo/protege-user