W3C home > Mailing lists > Public > public-rif-wg@w3.org > January 2007

Re: [UCR] ISSUE-12 and ACTION6198 (semantic web rule language) - and also the SPARQL topic

From: Dave Reynolds <der@hplb.hpl.hp.com>
Date: Wed, 10 Jan 2007 10:57:47 +0000
Message-ID: <45A4C6AB.5000207@hplb.hpl.hp.com>
To: axel@polleres.net
CC: RIF WG <public-rif-wg@w3.org>

Axel Polleres wrote:

>> First, SPARQL query was just an example of what you might want in a 
>> semantic web rule language.
> 
> What I meant to say is: SPARQL's CONSTRUCT, has already quite a lot 
> (probably not all, but it is a start) what a rules language on top of 
> OWL/RDF would need, and for many users, this might be sufficient as a 
> starting point for writing SW rules.

I don't disagree. There's a reasonably close correspondence with simple 
JenaRules in terms of expressivity (though differences in syntax). Well, 
at least if you omit the negation-as-failure bits of each side.

I'd rather have a more rule-like outer syntax and use the same N3/Turtle 
syntax for the expressions; but that's just sugar.

>> Second, this discussion was about whether all RIF dialects are 
>> automatically semantic web rule languages and the fact that the 
>> working group doesn't want to endorse a specific semantic web dialect. 
> 
> In this sense, I might have left the topic a bit... but my worry was 
> that: At least for most uses I can imagine for a rules language on top 
> of RDF/OWL, ie. what I understand as a useful starting point for an SW 
> rules language, SPARQL CONSTRUCT statements, read as rules, seem to be 
> more than enough syntaxwise. Alignment with RIF dialects, or at least 
> the definition of which RIF dialect this corresponds to would thus be 
> desirable IMO.

To align with a dialect you need the semantics of course, in particular 
how you deal with the negation-as-failure implicit in OPTIONAL when you 
generalize to a rule language, plus how to handle FILTER. There's design 
freedom there. It would be easy to define a SPARQL rule semantics that 
aligned with production rules or possible pick a different approach and 
align with an LP dialect.

>> You seem to be proposing a specific dialect.
> 
> Not at all, What I say is that if we clearly define a dialect 
> corresponding to SPARQL what more or less is expressible by CONSTRUCT 
> statemants (if we allow RDF triples being inferred in the rule head and 
> SPARQL queries in the rule body, this is more or less what we get 
> anyway), then we even have a starting point for an agreed syntax of a 
> semantic web rules language already.

Agreed, though as I say not a uniquely defined starting point.

You could equally well start from N3, after all that's where the 
expression syntax comes from and log:implies is essentially SPARQL 
construct.

> I don't say that it is a task of 
> RIF to further elaborate or extend this in the future, but it
> a) would be a nice joint work with the DAWG to go for such a joint 
> solution towards a lighteight SW rules language on top of SPARQL.

I don't see how such joint work offers any benefit to DAWG, especially 
in the current circumstances. If RIF were to take the SPARQL expression 
syntax and use it in a rule language then it would make sense for it to 
ask DAWG to check over the use of the syntax. That sort of involvement 
might be more practical than joint work.

> b) would fulfill the requirement to provide the foundations for dialects 
> to use as an SW rules language IMO.

There is no such requirement. The proposal that there should be such a 
requirement was rejected.

> What I am proposing is simply to collaborate on the topic of a SW rules 
> language with the DAWG, since this seems to me at the moment the most 
> promising path to get some viable suggestion for a people to write down 
>  RDF rules without the need to introduce another new syntax for it. My 
> idea was more that e.g. the two WGs could produce a joint document in 
> this sense as a "by product" as none of the two claims to be chartered 
> towards standardizing "the" SW rules language, but users still need a 
> way to write them down.

Users already have ways of writing down such rules - SWRL, N3 etc. The 
question that a different rules working group might have addressed would 
have been to create a (or a set of) standardized one(s). We've spent 
some time discussing how far RIF will go in that direction with largely 
negative results.

In particular the bit that you seem particularly keen on, the user 
friendly syntax, is the bit that seems to be most clearly outside RIF.

So a variant on your proposal is that a group of us could informally go 
off and work out what a simple RDF rules language based on the SPARQL 
expression syntax might look like. Then we could take the results back 
to RIF and use it as a test case for RIF dialects and work out how to 
exchange the resulting rule language via RIF. This might well be a 
worthwhile thing to do but I think the result and indeed the group 
itself would have no formal standing within RIF. From RIF's point of 
view this would be just another client language - no different from N3, 
JenaRules or whatever that might want to be exchanged over RIF.

Dave
Received on Wednesday, 10 January 2007 12:03:29 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Tuesday, 2 June 2009 18:33:35 GMT