Re: (Round 2) Proposed Extensions to OWL

> That is why I prefer to use an abstract Tranformation thing that could be
> specialized for one to one length comparisons, for example.  Better not to
> have to remodel when we hit other cases, within reason of course.
>

I have been watching this discussion with interest and I think the above is 
an important point.

I'm not certain I have a point here, but it is good to bounce back and 
forth from what we "KNOW" and what we "WANT" in a problem solving debate 
like this.

[KNOW] I'm no expert in this field but I think that at the moment one can 
express equivalence in owl only for comparing RDF triples.

[WANT] I think we need: a way of expressing equivalence between more 
complex graph structures than simple triples and also for similarly 
entailing equivalent graph structures.

(diagramatically this is:

resource#1 --> length --> resource#X --> value --> 2.5
				             --> unit_of_measure --> cm

- ontologies answer questions for "is cm the same as centimetre?"

resource#2 --> length --> resource#Y --> value --> 1
				             --> unit_of_measure --> inch

and we want to express that these graphs are equivalent for our application 
that should happen to care,
so we could lose one modelling - inches, say - and have no material loss of 
information if our application was to be using metric, say.

Also, that we can entail one from another means we need a transformation 
mechanism i.e. one that can generate the necessary triples for
inches-compatible applications, from the cm-based triples.

The transformation is of the portion of the graph that extends from 
resource#X or resource#Y and is applied via a rule that says somthing 
like:if you want to entail triples that have inch instead of cm then you 
have to
1. inspect the unit_of_measure's value
2. find it's transform operation re the unit_of_measure you require (ie 
apply a "divide by 2.5" mathematical operation) - and this could be 
expressed in the rdf/xml in ways discussed in this thread
3. find the value to which to apply this transform operation (ie the 
literal value of the 'value' property above).

It is up to the application to do the mathematical processing for the 
conversions - perhaps rdf api's have/will get this built in? - but the 
important bit is to be able to express equivalence/entailment over 
something more complex than binary graph structures - and p'haps owl is the 
place to do this, I don't know.

ie Note here: multiply *what* by 1.609344 - with a view to a generic 
approach to these types of problems you can't lose that bit of the graph:

<owl:Class rdf:ID="MilesLength">
	<con:conversion>
		<con:ConversionFunction>
			<con:origin rdf:resource="#MilesLength"/>
			<con:target rdf:resource="#KilometerLength"/>
			<con:transform>{something meaning multiply by 1.609344}</con:transform>
		</con:ConversionFunction>
	</con:conversion>
<owl:Class>


Nikki

----------------------
NJ Rogers, Technical Researcher
(Semantic Web Applications Developer)
Institute for Learning and Research Technology (ILRT)
Email:nikki.rogers@bristol.ac.uk
Tel: +44(0)117 9287096 (Direct)
Tel: +44(0)117 9287193 (Office)

Received on Thursday, 3 July 2003 06:46:50 UTC