RE: OWL-S: Parameter modeling

Bijan,

 

My comments are inline.

 

Best regards

 

Stephane Fellah

Web Chief Architect

 

PCI Geomatics

490, Boulevard St Joseph

Hull, Quebec

Canada J8Y 3Y7

Tel: 1 819 770 0022 Ext. 223

Fax 1 819 770 0098

Visit our web site:  www.pcigeomatics.com

 

 

 

-----Original Message-----
From: Bijan Parsia [mailto:bparsia@isr.umd.edu] 
Sent: Friday, July 02, 2004 10:25 AM
To: Stephane Fellah
Cc: public-sws-ig@w3.org
Subject: Re: OWL-S: Parameter modeling

 

 

On Jul 2, 2004, at 11:05 AM, Stephane Fellah wrote:

 

>

> Hi,

>

> I have a question related to parameter modeling in OWL-S. Prior to  

> version 1.0, parameter,input,output,precondition,effect where modeled


> as rdf:Property, then there have been changed to become owl:Class.

 

Yes.

 

>  I cannot find the rationale of the change in the documentation of the


> ontology and in the mailing list.

 

There are a lot of features of a parameter that need to be modeled  

(name, type, parameterType, binding, etc.). Given that we now have  

processes as instances and a pattern of modeling the features of a  

process as linked individuals, the move is natural.

 

It's also probably necessary to be OWL-DL friendly.

 

(Stephane) Please note that I am not an expert in DL, so please point me
out where my reasoning is wrong. 

rdf:Property is the class of RDF properties. rdf:Property is an instance
of  <http://www.w3.org/TR/rdf-schema/#ch_class#ch_class> rdfs:Class. So
theorically, owls:parameter, a subclass of rdf:Property can have
properties specific to Parameter (name,description, binding...)

 

 

> I have found the former version more practical, because the range of  

> the parameter (called parameterType in OWL-S 1.0,1.1) can naturally be


> expressed as the range of the property.

 

Yes, that's convenient, however, largely insufficient in the long haul.


(Parameters are somewhat different than properties.) Also, that doesn't


work for processes as instances, I believe, at least no happily.

 

(Stephane) I consider parameter as a property with a specific role. 

Thus I assume it is a subclass of RDF Property with additional
properties.

The most important property of a Parameter is its range (which is called
parameterType in owl-s 1.x). For me parameterType = range or is a
subproperty or range.  

 

 

> A parameter description should have a number of properties: unique  

> name,  description, type (datatype, or a owl:class), and optionally a


> set of constraints (enumeration of single values, interval with  

> specific resolution, or a mix of both). You can think a parameter as  

> an OLAP dimension, in dimension modeling.

 

er...this pushes us to classes, I think.

 

(Stephane) Property is a Class also, thus can be extended by properties.

 

> To express the properties of image scale operator (process),you may  

> describe the scaleX parameter the following way:

>

> <owl:DatatypeProperty rdf:id="scaleX">

>     <rdfs:subPropertyOf  

> rdf:resource="http://www.daml.org/services/owl-s/0.9/ 

> Process.owl#parameter"/>

>     <rdfs:domain rdf:resource="http://www.foo.com#ScaleOperator"/>

>     <rdfs:range
rdf:resource="http://www.w3.org/2001/XMLSchema#float"/>

>     <parameterName>scaleX</parameterName>

>     <description>scale in X</description>

> </owl:DatatypeProperty>

 

The last two properties, in OWL-DL, would have to be  

"AnnotationPropertie" and thus have no meaning to a reasoner. You  

cannot classify properties based on such metaproperties (in OWL DL).  

Etc. Having lots of subproperties like this (especially with global  

restrictions) also strikes lots of people as ugly or unfortunate. In  

certain circumstances it can make reasoning much more difficult (and  

certain can avoid the sweet spot of a lot of currently optimized  

implementations).

 

(Stephane) Why the last two properties would have to be
AnnotationProperties ? Does the definition below not valid in OWL-DL ? I
declare the metadata property as a datatypeProperty, not an
annotationProperty. 

You are right when you say that my last two properties are
metaproperties. Does this mean I am in second-order predicate logic ?
(Once again I am not expert). Why current validator would not work in
this case ? 

 

> You can declare parameterName in the following way:

>

>  <owl:DatatypeProperty rdf:ID="parameterName">

>     <rdfs:domain  

> rdf:resource="http://www.daml.org/services/owl-s/0.9/ 

> Process.owl#parameter"/>

>     <rdfs:range  

> rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>

>   </owl:DatatypeProperty>

>

>

> When a operator is used, you can directly use the parameter property:

>

> <ScaleOperator rdf:id="myScaleOp">

>    <scaleX>1.43</scaleX>

>    <scaleY>1.43</scaleY>

> </ScaleOperator>

 

But this binds to a particular value. I don't understand how you would  

model variable binding.

 

(Stephane) This represent an instance of a process with the parameter
bound to some value. ParameterValue does not need to be model as a
class. It the Object/Literal part of the triple. This notation is very
useful to perform the lineage of a complex process (think about a
complex image processing chaining task). The operator wants to keep
track of the parameters applied at each step. Using my approach this
would have a compact syntax.

 

To find all the parameters values of a process, you have to search in
the ontology, which properties are subproperties of parameter.

 

 

> I have found this approach much more readable than the current  

> approach used in OWL-S 1.0 and 1.1. Moreover it can bind nicely to  

> Process Object.

>

> Is there any problem for OWL-S to use this approach. Are we in 2nd  

> order predicate logic here ?

 

Not necessarily. Check out the RDF Semantics, the LBase document, and  

the RDF compatible model theory in the OWL Syntax and Abstract Syntax  

document. You might also look at hilog.

 

(Stephane) These documents are too theorical for me, and I may not
understand all the details of DL theory. Do you have a short answer for
this. Is it second order predicate logic or not ? Is it OWL-Full or not
?

 

> Does the existing OWL inference engine work this way ? Are we still in


> OWL-DL ?

 

Some for the former, depends for the latter.

 

> I would like you to discuss the pro and cons of each approach. Thanks


> in advance.

 

Part of our current approach is to be somewhat consistent in our  

modeling style. Reifying certain sorts of relations (like parameter)  

has advantages in a language with inexpressive relation modeling  

constructs. It's a bit like building and abstract syntax tree.

 

(Stephane) I think both approaches are valid. However I think the first
approach (pre-1.0) modeling parameter as property is more natural and
readable than the second one (Parameter as class).  

 

 

Cheers

 

Stephane