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

RE: Semantic Web Rule Language (SWRL) 0.5 released

From: Boley, Harold <Harold.Boley@nrc-cnrc.gc.ca>
Date: Thu, 27 Nov 2003 21:34:53 -0500
Message-ID: <10C94843061E094A98C02EB77CFC3287026DF700@nrcmrdex1d.imsb.nrc.ca>
To: www-rdf-rules@w3.org

Hi Drew,

this is in partial response to your questions, since I had no chance to
talk to the other authors over Thanksgiving.

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

RuleML since 0.8 (http://www.ruleml.org/indtd0.8.html) has used a type/role
distinction inspired by 'alternating' or 'striped' representations as used
in OO modeling and RDF. In the XML Concrete Syntax this is indicated by tags
without/with an underscore prefix. In the RDF Concrete Syntax, upper/lower
case is used. Thus, imp/_body (in XML) becomes Imp/body (in RDF). Perhaps we
should emphasize this by two namespaces ruleml ("rule markup language") vs.
ruledf ("rule description framework") to obtain ruleml:imp/ruleml:_body vs.
ruledf:Imp/ruledf:body, paralleling our swrlx vs. swrl namespaces. However,
we were discussing to perhaps *reduce* the number of namespaces by v 1.0
(an issue analogous to the 'adjacent' rdf and rdfs namespaces).

You wrote:
I am curious why explicit quantifiers are so conspicuously absent from
SWRL.  . . .

Omitting all (top-level) universal quantifiers has often been used as one
step for obtaining a clausal normal form in classical first-order logic, and
has been a convention in many (Horn) logic programming languages (but this
has nothing to do with the somewhat limited success of ISO Prolog as an LP
standard: http://www.cs.unipr.it/~bagnara/Papers/Abstracts/ALPN99a).

Besides LP, also mathematics has had a similar habit for named function
definitions, taken up by many equational/functional programming languages.
So, for defining square(x) = x*x Common Lisp uses (defun square (x) (* x x))
rather than something like (def square (lambda (x) (* x x))), with the
lambda
binding construct playing a role similar to a universal quantifier.

Of course, there are essential uses of universal quantifiers nested into
non-normalized formulas, and essential uses of lambda for anonymous
functions.
Continuing the Lisp analogy, if we don't have, and don't want, a named
square
function, then lambda in (defun sqlist (y) (mapcar #'(lambda (x) (* x x))
y))
is essential.

Since many formulas and functions, however, define rules and named
functions,
the above free-variable conventions are widespread. Should we still strive
for
uniformity between the top-level of formulas and nested parts for a
practical
language (this had already been attempted by (overly?) powerful, less spread
systems such as lambda Prolog, http://www.cse.psu.edu/~dale/lProlog/)?

Hard to tell! So I think we should put a version of your (DRS) suggestion
into
the SWRL (and RuleML, ...) issues lists.

Best,
Harold
Received on Thursday, 27 November 2003 21:37:42 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 2 March 2016 11:10:15 UTC