W3C home > Mailing lists > Public > www-rdf-rules@w3.org > November 2003

Re: Semantic Web Rule Language (SWRL) 0.5 released

From: Drew McDermott <drew.mcdermott@yale.edu>
Date: Wed, 26 Nov 2003 18:12:40 -0500 (EST)
Message-Id: <200311262312.hAQNCeH22819@pantheon-po03.its.yale.edu>
To: www-rdf-rules@w3.org


   [Mike Dean]
   The Joint US/EU ad hoc Agent Markup Language Committee [1]
   is pleased to announce the initial release [2] of SWRL:  A
   Semantic Web Rule Language Combining OWL and RuleML.

   Please direct comments to www-rdf-rules@w3.org.

Comments: 

In some places ruleml:_body is written ruleml:body.  Is that typo or a
subtle yet profound distinction?


I am curious why explicit quantifiers are so conspicuously absent from
SWRL.  Granted, it's very easy to add them, as we do in DRS.  With
explicit quantifiers, example 6.1-2 becomes


<swrl:Variable rdf:ID="x"/>
<swrl:Variable rdf:ID="y"/>
<swrl:Variable rdf:ID="z"/>
<drs:Forall>
   <drs:bound_vars>
      <drs:binds rdf:resource="#x"/>
      <drs:binds rdf:resource="#y"/>
      <drs:binds rdf:resource="#z"/>
   </drs:bound_vars>
   <ruleml:Imp> 
     <ruleml:body rdf:parseType="Collection">
       <swrl:classAtom> 
	 <swrl:classPredicate rdf:resource="&ulan;Artist"/> 
	 <swrl:argument1 rdf:resource="#x" />
       </swrl:classAtom>
       <swrl:classAtom> 
	 <swrl:classPredicate rdf:resource="&aat;Style"/> 
	 <swrl:argument1 rdf:resource="#y" />
       </swrl:classAtom>
       <swrl:individualPropertyAtom> 
	 <swrl:propertyPredicate rdf:resource="&aatulan;artistStyle"/> 
	 <swrl:argument1 rdf:resource="#x" />
	 <swrl:argument2 rdf:resource="#y" />
       </swrl:individualPropertyAtom>
       <swrl:individualPropertyAtom> 
	 <swrl:propertyPredicate rdf:resource="&vra;creator"/> 
	 <swrl:argument1 rdf:resource="#x" />
	 <swrl:argument2 rdf:resource="#z" />
       </swrl:individualPropertyAtom>
     </ruleml:body>
     <ruleml:head rdf:parseType="Collection"> 
       <swrl:individualPropertyAtom> 
	 <swrl:propertyPredicate rdf:resource="&vra;style/period"/> 
	 <swrl:argument1 rdf:resource="#z" />
	 <swrl:argument2 rdf:resource="#y" />
       </swrl:individualPropertyAtom>
     </ruleml:head> 
   </ruleml:Imp> 
</drs:Forall>


But it strikes me as so foolish to let free variables (interpreted as 
universally quantified) be such a dominant case that ethics compels me
to object.  

The only argument I can see for making free variables (and, for that
matter, "rules") be the only top-level structures in SWRL is this:
Prolog forces all formulas to be rules; Prolog uses only free
variables (modulo hacks like "bagof"); therefore, if we follow these
conventions our language will become powerful and admired like Prolog.
This is cargo-cult logic, as far as I can see.

The counterarguments are these:

1. The free-variable case is easily expressible in terms of the
   bound-variable case.  Indeed, that's the way logicians do it.

2. There are lots of contexts where you absolutely need quantifiers.
   For instance, in the discussion on the closed-world assumption, Dan
   Connolly mentioned this example:

   this log:forAll :x.
   {:x :homePage log:includes { :x a :Vegetarian }}
   => { :x a :Vegetarian}.

   There is clearly a difference between this and 

   this log:forAll :x.
   {:x :homePage log:includes { this log:forAll :x {:x a :Vegetarian }}}
   => { :x a :Vegetarian}.

   which _does not mean the same thing_ as:

   {?x :homePage log:includes {?y a :Vegetarian }}
   => { :?x a :Vegetarian}.

   (This rule fires if _there exists_ a ?y that ?x claims is a
   Vegetarian.) 

I probably have the syntax and semantics of "this log:forAll" screwed
up, but the only point I'm trying to make is that the explicit
quantifier allows us to make distinctions that are sometimes important
to make.

3. Existential quantifiers are omitted completely from SWRL.  You can
   make do with Skolem terms in most cases, but then you have to admit
   arbitrary functional terms into the language, a step that SWRL
   hasn't taken yet.

Hmm, another argument in favor of the limitations on SWRL is perhaps
that it keeps things from getting too complicated.  But, as I've
argued many times, this is a pointless and infeasible goal.  [Stop
here to skip tedious repetition of standard McDermott flame.]  It's
pointless because notation users who want a slightly more flexible
syntax can be assumed to know what they're doing.  It's infeasible
because, if the standard is inadequate, people will make up their own
exensions.  In the long run, the standard will have to expand to
include the good stuff in those extension.  This might be an argument
against premature standardization --- let people experiment and see
what emerges.  But for expressing the syntax of logical languages,
there are really no serious open questions.  Bertrand Russell solved
all the outstanding problems a hundred years ago.

-- 
                                   -- Drew McDermott
                                      Yale Computer Science Department
Received on Wednesday, 26 November 2003 18:12:44 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:53:11 GMT