Re: DRS guide -- usage scenario ?

On Jan 14, 2004, at 5:56 PM, Adrian Walker wrote:

> Drew --
>
> Interesting DRS guide..... 
>
> I'm a bit vague however about what you will actually dowith formulae 
> encoded in RDF.  If you ship them around the Web, that seems to imply 
> that anyone receiving them has to have a suitable theorem prover / 
> reasoner.

Yes.

>   So, do you ship that too ?  In DRS? 

Probably not.

>  If so, then the recipients need perhaps to unwrap ontology RDF and 
> the prover RDF to get strings like the ones Bijan suggested?

Not necessarily.

First, rumor was wrong. I didn't suggest strings per se, at least, not 
seriously. I suggested using literals and I, for one, would rather use 
fairly rich literals, with structure. Perhaps even something RDFy :)

In any of these cases, something more than generic RDF or OWL 
processing will be needed. At some point, one will have to *interpret* 
that syntax, if one wants to reason with it (or do a range of other 
processing).

(To see and example, look at the transformation table from triples to 
abstract syntax in the OWL Syntax and Abstract Semantics, and the 
extension of that table in SWRL.)

[snip]

So, specifically, I take some exception to the following passage from 
the guide:

"""The arguments against using strings are pretty clear: Staying within 
RDF
allows a processor to determine that a formula refers to a resource, 
even when it
can’t tell or doesn’t care what it says. An XML/RDF/OWL syntax checker 
will
do useful things with DRS notation, checking that the parens balance, 
that only
formulas occur inside connectives, and so forth. Finally, the extra 
conciseness
of strings is certainly attractive, but the advantage shrinks when we 
use non-
XML-based versions of RDF."""

I think that interesting structured literals can do a fair bit. 
Granted, it will require some extension, but the extension might be 
quite minor. (Especially, if the literals are RDF/XML.)

Note that there are no conciseness advantages, except in that the graph 
won't have reified triples all over the place. Instead, they might be 
stuffed in a literal :)

I believe triples in a literal are "dark" (to the parent graph) as 
well. This might have some advantages.

One advantage of literals is that they (might be suitibly extended to) 
integrate different notations, while clearly delimiting where and how 
you are switching notations.

I don't put this forth as settled opinion, just as a possibility. Extra 
work has to be done in either case.

Hmm. Here's an interesting thought that I'm surprised I have: I think I 
don't agree with Drew's claim:

"""An XML/RDF/OWL syntax checker will
do useful things with DRS notation, checking that the parens balance, 
that only
formulas occur inside connectives, and so forth"""

I believe that an XML checker can do useful things with XML literals 
already, though it may be a bit tricky to get XMLSchema to do it 
cleanly (mostly because it seems a bit hard to get an arbitrary schema 
for RDF/XML, but that means that we probably should encourage RDF 
parsers to support Schema validation of XMLLiterals). As for using RDF 
and OWL to do syntax, well, my thought (and recent experience supports 
this thought) is that most of the time it's better to use a more 
specific formalism, like, say, a grammar. It's largely a question of 
supporting the right defaults.

Some of this underscores an earlier post of mine on rdf-rules that it 
would be nice not to burden the Rules working group with a no-syntax 
extension requirement.

Received on Wednesday, 14 January 2004 21:24:53 UTC