[jira] [Comment Edited] (RYA-295) Implement owl:allValuesFrom inference

["Jesse Hatfield (JIRA)" <ji...@apache.org>]

    [ https://issues.apache.org/jira/browse/RYA-295?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16092144#comment-16092144 ] 

Jesse Hatfield edited comment on RYA-295 at 7/20/17 9:00 PM:
-------------------------------------------------------------

In general, if we have{quote}:A owl:onProperty \:p .
:A owl:allValuesFrom :B {quote}
then this means:{quote}x is an A *if and only if*, for all y, *if* (x p y) *then* y is a B.{quote}
As described above, we can never deduce the second half ("for all y, if ... then") just from the data, because of the open-world assumption. Therefore the only implication we need to consider is
bq. *If* x is an A *then* for all y, *if* (x p y) *then* y is a B.
Equivalently:
bq. *If* there exists some x *such that* (x is an A) AND (x p y) *then* y is a B.
This is the same kind of expression we can derive from owl:someValuesFrom, described in [RYA-294], but in the reverse direction: inferring the object's type if there exist some subject who has it as a value.

We can use the same approach. In the inference engine:
{code}allValuesFromByValueType <- Map<valueType, Map<property, restrictionType)>
for (restrictionType, property) in propertyRestrictions:
    for valueType in query(property owl:allValuesFrom ?valueType):
        allValuesFromByValueType[valueType][property] <- restrictionType
...
getAllValuesFromImplying(type): // return (property, restriction type) pairs that would imply this type
    results <- List<(property, restrictionType)>
    for sufficientType <- type UNION getAllSubClasses(type):
        if sufficientType in allValuesFromByValueType:
            results.addAll(allValuesFromByValueType[sufficientType])
    return results{code}
And a visitor:
{code}meet(StatementPattern originalSP):
    if originalSP like (?object rdf:type :C1): // Assume the type in question is explicitly given in the query, not a variable
        node <- originalSP
        for (property, restrictionType) in inferenceEngine.getAllValuesFromImplying(C1):
            option <- InferJoin(StatementPattern(?subject, property, ?object), StatementPattern(?subject, rdf:type, restrictionType))
            node <- InferUnion(node, option)
        originalSP.replaceWith(node){code}


was (Author: jhatfiel):
In general, if we have{quote}:A owl:onProperty :p .
:A owl:allValuesFrom :B {quote}
then this means:{quote}x is an A *if and only if*, for all y, *if* (x p y) *then* y is a B.{quote}
As described above, we can never deduce the second half ("for all y, if ... then") just from the data, because of the open-world assumption. Therefore the only implication we need to consider is
bq. *If* x is an A *then* for all y, *if* (x p y) *then* y is a B.
Equivalently:
bq. *If* there exists some x *such that* (x is an A) AND (x p y) *then* y is a B.
This is the same kind of expression we can derive from owl:someValuesFrom, described in [RYA-294], but in the reverse direction: inferring the object's type if there exist some subject who has it as a value.

We can use the same approach. In the inference engine:
{code}allValuesFromByValueType <- Map<valueType, Map<property, restrictionType)>
for (restrictionType, property) in propertyRestrictions:
    for valueType in query(property owl:allValuesFrom ?valueType):
        allValuesFromByValueType[valueType][property] <- restrictionType
...
getAllValuesFromImplying(type): // return (property, restriction type) pairs that would imply this type
    results <- List<(property, restrictionType)>
    for sufficientType <- type UNION getAllSubClasses(type):
        if sufficientType in allValuesFromByValueType:
            results.addAll(allValuesFromByValueType[sufficientType])
    return results{code}
And a visitor:
{code}meet(StatementPattern originalSP):
    if originalSP like (?object rdf:type :C1): // Assume the type in question is explicitly given in the query, not a variable
        node <- originalSP
        for (property, restrictionType) in inferenceEngine.getAllValuesFromImplying(C1):
            option <- InferJoin(StatementPattern(?subject, property, ?object), StatementPattern(?subject, rdf:type, restrictionType))
            node <- InferUnion(node, option)
        originalSP.replaceWith(node){code}

> Implement owl:allValuesFrom inference
> -------------------------------------
>
>                 Key: RYA-295
>                 URL: https://issues.apache.org/jira/browse/RYA-295
>             Project: Rya
>          Issue Type: Sub-task
>          Components: sail
>            Reporter: Jesse Hatfield
>
> An *{{owl:allValuesFrom}}* restriction defines the set of resources for which, given a particular predicate and other type, every value of that predicate is a member of that type. Note that there may be no values at all.
> For example, the ontology may state that resources of type {{:Person}} have all values from {{:Person}} for type {{:parent}}: that is, a person's parents are all people as well. Therefore, a pattern of the form {{?x rdf:type :Person}} should be expanded to:
> {noformat}
> { ?y rdf:type :Person .
>   ?y :parent ?x }
> UNION
> { ?x rdf:type :Person }
> {noformat}
> i.e. we can infer {{?x}}'s personhood from the fact that child {{?y}} is known to satisfy the restriction.
> Notes:
> -We can infer "x is a person, therefore all of x's parents are people". But we can't infer "all of x's parents are people, therefore x is a person", because of the open world semantics: we don't know that the parents given by the data are in fact all of x's parents. (If there were also a cardinality restriction and we could presume consistency, then we could infer this in the right circumstances, but this is outside the scope of basic allValuesFrom support.) This differs with most other property restriction rules in that we can't infer that an object belongs to the class defined by the restriction, but rather use the fact that an object is already known to belong in that class in order to infer something about its neighbors in the graph (the types of the values).
> -The example above could be applied recursively, but to implement this as a simple query rewrite we'll need to limit recursion depth (and interactions with other rules, for the same reasons).



--
This message was sent by Atlassian JIRA
(v6.4.14#64029)