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

Re: A problem with OWL Validator

From: Jos De_Roo <jos.deroo@agfa.com>
Date: Sun, 15 Jun 2003 14:28:14 +0200
To: "Monika Solanki <monika" <monika@dmu.ac.uk>
Cc: semanticweb <semanticweb@yahoogroups.com>, www-rdf-interest@w3.org, www-ws@w3.org, www-ws-request@w3.org
Message-ID: <OFB048EB4C.F9642B80-ONC1256D46.0043EFC0-C1256D46.00448223@agfa.be>


Hi Monika, conceptually there should be no problem
to mix RDF instance data and OWL ontologies.
In my experience I even mix it with log: and math:
formulae (using N3) to find proofs etc...

--
Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/


                                                                                                                   
                    Monika Solanki                                                                                 
                    <monika@dmu.ac       To:     www-ws@w3.org, www-rdf-interest@w3.org, semanticweb               
                    .uk>                  <semanticweb@yahoogroups.com>                                            
                    Sent by:             cc:                                                                       
                    www-ws-request       Subject:     A problem with OWL Validator                                 
                    @w3.org                                                                                        
                                                                                                                   
                                                                                                                   
                    2003-06-15                                                                                     
                    12:56 PM                                                                                       
                                                                                                                   
                                                                                                                   




Hi,

I have an OWL file, in which I have included some instances as well. When I
parse the file without the instances, it does not give me any error,
however when I do it with  instances, it gives me loads of warning like,
Implicit Property, Undefined Resource, Invalid namespace. I fail to
understand if my ontology is wrongly written or is it wrong to include
instances in the same file. Has anyone come across such errors before.

Please Help.

Thanks

Monika

Roger L. Costello wrote:
     Jos De_Roo wrote:
          we tend to use RDF interpretation properties for that
          and math: properties and N3 conversion rules such as eg

          {?X eg:length-in ?Y} => {?X eg:length-cm (?Y 2.54).math:product}.
          {?X eg:length-cm ?Y} => {?X eg:length-in (?Y
          2.54).math:quotient}.

     [snip]

     Hi Jos,

     Does this have an XML syntax?  My interest is in how to express the
     mathematical relationships using an XML syntax.  /Roger



                              "Roger L. Costello"
                              <costello@mitre.org>        To:
          www-rdf-interest@w3.org
                              Sent by:                    cc:
          robin.berjon@expway.fr, "Costello,Roger L." <costello@mitre.org>
                              www-rdf-interest-requ       Subject:
          Proposed extensions to OWL?
                              est@w3.org


                              2003-06-14 01:20 PM



          Hi Folks,

          Yesterday I sent out a message asking about technologies to
          express
          mathematical relationships.  Robin Berjon responded with a very
          inte
          resting 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;de
          cimal"/>
             </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, dep
          ending 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


--
>**<>**<>**<>**<>**<>**<>**<>**<>**<>**<
Monika Solanki
De Montfort University
Software Technology Research Laboratory
Hawthorn building, H00.18
The Gateway.
Leicester LE1 9BH, UK

phone: +44 (0)116 250 6170 intern: 6170
email: monika@dmu.ac.uk
web: http://www.cse.dmu.ac.uk/~monika/
>**<>**<>**<>**<>**<>**<>**<>**<>**<>**<
"NOTE: The information transmitted is intended only for the person or
entity to which it is addressed and may contain confidential and/or
privileged material. Any review, retransmission, dissemination or other use
of, or taking of any action in reliance upon this information by persons or
entities other than the intended recipient is prohibited. If you received
this in error, please contact the sender and delete the material from any
computer"
Received on Sunday, 15 June 2003 08:28:32 GMT

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