W3C home > Mailing lists > Public > www-rdf-interest@w3.org > June 2003

Re: Proposed extensions to OWL?

From: Roger L. Costello <costello@mitre.org>
Date: Sun, 15 Jun 2003 07:00:45 -0400
Message-ID: <3EEC51DD.D64D5960@mitre.org>
To: www-rdf-interest@w3.org
CC: robin.berjon@expway.fr, "Costello,Roger L." <costello@mitre.org>

Hi Folks,

The more that I think about this problem, the more convinced I am that
adding something like a conversionFactor attribute is the right way to
go, e.g.,

    <owl:DatatypeProperty rdf:ID="length-in">
       <owl:equivalentProperty rdf:resource="#length-cm"
            owl-x:conversionFactor="length-in/value() = 
                                    length-cm/value() / 2.54"/>
       <rdfs:range rdf:resourse="&xsd;decimal"/>
    </owl:DatatypeProperty>

Let me explain.  Consider the meaning of this:

    <owl:DatatypeProperty rdf:ID="a">
       <owl:equivalentProperty rdf:resource="#b"/>
    </owl:DatatypeProperty>

It says that "a and b represent the same type of thing (they are
equivalent), with a conversionFactor of 'equality'". 

That is, implicitly, the definition is stating this:

    <owl:DatatypeProperty rdf:ID="a">
       <owl:equivalentProperty rdf:resource="#b"
                   owl-x:conversionFactor="a/value() = b/value()"/>
    </owl:DatatypeProperty>

"Given an instance of a and an instance of b, they can be considered
equivalent *provided* the value of 'a' equals the value of 'b'."

Thus,

    <owl:DatatypeProperty rdf:ID="length-in">
       <owl:equivalentProperty rdf:resource="#length-cm"
            owl-x:conversionFactor="length-in/value() = 
                                    length-cm/value() / 2.54"/>
       <rdfs:range rdf:resourse="&xsd;decimal"/>
    </owl:DatatypeProperty>

"Given an instance of length-in and an instance of length-cm, they can
be considered equivalent *provided* the value of length-in equals the
value of length-cm / 2.54"

In other words, a "conversionFactor" is implicit in this definition:

    <owl:DatatypeProperty rdf:ID="a">
       <owl:equivalentProperty rdf:resource="#b"/>
    </owl:DatatypeProperty>

I propose that we make the "conversionFactor" explicit, so that more
sophisticated mathematical relationships can be expressed.  Also, I
propose that xPath be leveraged to express the relationships. 
Comments?  /Roger

P.S. I looked at RuleML and feel that it is not appropriate for this
problem.  RuleML gives a way to state inferences.  In this problem, I am
not trying to state an inference.  I am merely trying to assert
equivalence (by a conversion factor).


"Roger L. Costello" wrote:
> 
> Hi Folks,
> 
> Yesterday I sent out a message asking about technologies to express
> mathematical relationships.  Robin Berjon responded with a very
> interesting idea.  I would like to get your thoughts on it, and see if
> collectively we can come up with something cool.
> 
> First I will show you a slightly modified version of Robin's proposal,
> then I will show Robin's original proposal.
> 
> Robin's Idea Slightly Modified
> 
> The idea is to extend OWL and base the solution on xPath.
> 
> Suppose that I would like to state that these two properties are
> equivalent via a conversion factor:
> 
>      length-in, length-cm
> 
> i.e., length in inches, and length in centimeters
> 
> The conversion factor is:
> 
>     length-in = length-cm / 2.54
>     length-cm = length-in * 2.54
> 
> With today's OWL here is how you would define these properties:
> 
>    <owl:DatatypeProperty rdf:ID="length-in">
>       <rdfs:range rdf:resourse="&xsd;decimal"/>
>    </owl:DatatypeProperty>
> 
>    <owl:DatatypeProperty rdf:ID="length-cm">
>       <rdfs:range rdf:resourse="&xsd;decimal"/>
>    </owl:DatatypeProperty>
> 
> The proposal is to extend OWL to allow you to assert that these two
> properties are equivalent by the above conversion factor.  Here's how it
> might look:
> 
>    <owl:DatatypeProperty rdf:ID="length-in">
>       <owl:equivalentProperty rdf:resource="#length-cm"
>                         owl-x:conversionFactor="current() * 2.54"/>
>       <rdfs:range rdf:resourse="&xsd;decimal"/>
>    </owl:DatatypeProperty>
> 
>    <owl:DatatypeProperty rdf:ID="length-cm">
>       <owl:equivalentProperty rdf:resource="#length-in"
>                         owl-x:conversionFactor="current() / 2.54"/>
>       <rdfs:range rdf:resourse="&xsd;decimal"/>
>    </owl:DatatypeProperty>
> 
> where:
>    owl-x is an OWL eXtension namespace,
>    current() is the xPath function referring to the current node.
> 
> Now let me show you Robin's idea:
> 
> Robin's idea is also to base the solution on xPath. Here's what Robin
> said:
> 
> "For instance:
> 
> <foo:PropertyEquivalence from='measure:inch'
>                           to='measure:cm'
>                           convert='$in_1 * 2.54'/>
> 
> <foo:PropertyEquivalence from='measure:cm'
>                           to='measure:in'
>                           convert='$in_1 div 2.54'/>
> 
> would allow you to declare that the following are equivalent:
> 
> <geo:Distance>
>    <measure:inch>2</measure:inch>
> </geo:Distance>
> 
> <geo:Distance>
>    <measure:cm>5.08</measure:cm>
> </geo:Distance>
> 
> You could allow for multiple inputs to your binding:
> 
> <foo:PropertyEquivalence
>                   from='size:width/measure:meter
> size:length/measure:meter'
>                   to='size:surface/measure:squareMeter'
>                   convert='$in_1 * $in_2'/>
> 
> and perhaps equivalentize, depending on whether it makes sense in that
> context:
> 
> <flat:Bedroom>
>    <size:width><measure:meter>4</measure:meter></size:width>
>    <size:length><measure:meter>5</measure:meter></size:length>
> </flat:Bedroom>
> 
> <flat:Bedroom>
>    <size:surface>
>      <measure:squareMeter>20</measure:squareMeter>
>    </size:surface>
> </flat:Bedroom>
> 
> so that given the first you could still query for flat:Bedrooms that
> are larger than 20sqm.
> 
> You may need to throw in stuff from EXSLT Math if you want more than
> XPath provides."
> 
> ....
> 
> Okay, those are the two ideas thus far.  What do you think?  Feel free
> to add your own ideas.  If this whole approach is bad, feel free to say
> so. The intent here is to brainstorm.  If these conversion rules are
> better stated using another technology (e.g., RuleML) please say so.
> /Roger
Received on Sunday, 15 June 2003 07:02:24 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:51:59 GMT