Re: Representation of SWRL expressions in OWL-S

On Feb 6, 2005, at 1:18 PM, David Martin wrote:

> Drew McDermott wrote:
>>> [Manshan Lin]
>>>
>>> Can we use SWRL to define universal quantifier?
>>> For example,
>>> all (x) ( A(x) and P(a,x) ) (B(x)) can be defined as
>>> ( A(x) and P(a,x) ) implies (B(x)) .
>>> In this case, "x" is an universal variable.
>> The main point to keep in mind is that Owl-S must _quote_ SWRL
>> expressions, i.e., label them as XML literals, not to be taken as RDF
>> by any RDF inference engine looking at them.  The reason for this is
>> that much of the neat hierarchical structure in a typical
>> XML-ification of RDF is an illusion.  You must always keep in mind
>> that the hierarchy evaporates when the XML is turned into triples.
>> Hence any subset of the triples that can be reassembled into a
>> meaningful expression _will_ be reassembled.  So if SWRL expressions
>> occur unquoted, they will be asserted just as surely as if they had
>> occurred all by themselves.  Your intent may be to use, say, a
>> headless rule as a formula whose role in context is to be a
>> precondition, but in fact that rule will gain its freedom and be
>> interpreted as an actual assertion.
[snip]
> Drew -
>
> I'm glad you've made such a clear statement regarding the need to 
> quote SWRL expressions.
>
> Currently this is making us a little crazy at SRI, in the context of 
> work on the Protege-based OWL-S editor.  There is now a SWRL editing 
> capability in the OWL plugin, and it turns out that we could integrate 
> much more easily with the SWRL editor if SWRL expressions were *not* 
> quoted in OWL-S.

If we moved to a headless or bodiless rule formulation, it should be 
some what easier to integrate. You just need to treat the XMLLiteral as 
if it were a document of sorts.

> So there's a desire to revisit this whole issue.  I'd like to start by 
> understanding better whether there is a clear story about how SWRL is 
> supposed to be used with OWL in general.  So let's forget about OWL-S 
> for the moment.  Based on what you've said, it appears that SWRL 
> expressions pretty much must *always* be quoted.

SWRL is always (currently) *encoded* in RDF (if you are trying for a 
same-syntax semantic extention). There is no special syntax support for 
it (yet). So, like DRS, you have object level assertions about the 
*syntax* of expressions *and* you have either bridge axioms (like in 
OWL-Full) or you actually kill the object level assertions (as in 
OWL-DL). In the latter case, you no longer have a true "same syntax, 
semantic extension", but an extended (if horribly clunky) syntax. That 
is, actually, what I believe you have in current swrl. See, for 
example,

"""In this section we present an RDF concrete syntax for the rules. It 
is straightforward to provide such an RDF concrete syntax for rules, 
but the presence of variables in rules goes beyond the  RDF Semantics. 
We do not yet know if the intended semantics of the resultant RDF 
graphs can be described as a semantic extension of RDF."""

Indeed, I would say that its unknown if there is a non-paradoxical 
extension of RDF that could work for this. It was *very* difficult to 
get OWL to align to the degree that it does.

> That is, if they are going to be loaded in a KB with other RDF / OWL 
> stuff, and the KB used for reasoning in a RDF-based reasoner, there's 
> always going to be a serious potential for confusion, because, as you 
> say, the hierarchical structure is not meaningful to the reasoner.  
> (By RDF-based reasoner, I just mean any reasoner that works off of the 
> triples according to their normal semantics.)

Yes, but that's eeeeeeevil anyway :) See the thread starting:
	http://lists.w3.org/Archives/Public/www-rdf-logic/2004Dec/0008.html

Watch me go nuts:
	http://lists.w3.org/Archives/Public/www-rdf-logic/2005Jan/0006.html

> I'd like very much to know what the inventors of SWRL think about 
> this, and also what the developers of the Protege-based SWRL editor 
> have to say.  Isn't it fair to say that if you want to use a RDF-based 
> reasoner, that all uses of SWRL should be quoted?

They should be a syntactic extention, so, in that sense, invisible to 
an RDF reasoner, so, in that sense, quoted.

> But then, if that's the case, it's impossible to claim that SWRL is 
> layered on OWL in a meaningful or useful way.

If SWRL were a syntactic extension to OWL, which it could easily be, 
there is a quite sensible and useful sense in which it would be layered 
on owl...every OWL kb would be a legal SWRL KB.

However, there is a separate point about why *we* quote SWRL. We quote 
SWRL because we use SWRL *differently* than the "normal" use of swrl. 
So we are quoting (in part) so that you can use swrl kbs to describe 
services. (For example, preconditions can be, and often *are* false. If 
we use the empty whatever syntax, then we would have inconsistent kbs. 
Plus we have funky variable binding restrictions. Etc. etc. etc.)

> I'd very much appreciate any clarity that anyone can offer on these 
> points.  In particular, what envisioned uses of SWRL allow you to 
> proceed *without* quoting?

I would say, None. As I said, it's not clear that there would be a 
non-systematically paradoxical embedding of swrl into OWL a la OWL-Full 
into RDFS. And it's clearly not useful at all. Really. It causes a ton 
of pain for no gain.

>  And if there are any, how do the semantics of RDF allow for that?

It doesn't. (Ok, I speak a tad strongly, but really, this is not a path 
worth taking. The sooner the Denizens of the Semantic Web realize that 
and the W3C stops its senseless propaganda in favor of this misbegotten 
chimerical constraint, the better off we'll all be.)

(I speak as someone who's used a number of RDF and OWL systems, who's 
implemented or contributed to the implementation of several of each, 
and who's studied these standards extensively. I've taught at least two 
classes that have spent a good deal of time on the layering issue. I've 
worked on ontologies  and end user tools. I've designed extensions to 
OWL. I speak on the basis of this accumulated experience.)

(I'll also observe that even the die hards, once they get significant 
implemenation experience, back off from the radical approach.)

Cheers,
Bijan Parsia.

Received on Monday, 7 February 2005 17:18:02 UTC