RE: RIF Working Group needs namespace name for xpath "op"

Hello,

This is an e-mail sent in reply to the thread starting here [1].

I am a member of the RIF working group and involved with the technical
design of the language.

RIF is a logical language for exchanging rules over the Web, essentially
based on predicate logic.  As such, the main building blocks of the
language are constants, functions, and predicates. Predicates are
essentially relations.
Constants and functions may only be used inside predicates. Different
predicates may be composed using logical connectives such as and, or,
and implication.
Therefore, RIF is a relational language (in contrast to, e.g., xpath,
which is a functional language).

Most of the predicates, functions, and constants used in rules are
provided by the user, so RIF cannot say how they should be interpreted.
However, in any practical rule language (including RIF) there are some
"built-in" predicates and functions, which have a defined meaning.
These built-ins are typically concerned with concrete data values (e.g.,
integers, strings), and include such things as numeric comparison and
substring matching.

Now, XML schema defines a number of built-in datatypes that are of
interest to RIF.  In the interest of reusing existing standards and
since using XML schema built-in datatypes is generally recommended for
semantic Web languages (e.g., RDF and OWL), we decided to use XML schema
built-in datatypes for the representation of concrete values in RIF.
Since we want to enable users to manipulate and compare concrete data
values, we want to include built-in functions and predicates that work
on XML schema built-in datatypes.

The "XQuery 1.0 and XPath 2.0 Functions and Operators" document defines
a number of functions and a number of comparators on XML schema built-in
datatypes.  Since we are interested in reusing existing standards and
avoiding duplication of effort, we want to adapt a number of these
functions and comparators to our context (e.g., a comparator with an
xsd:boolean return value becomes a built-in predicate in RIF) and use
them in RIF.
Since RIF is a Web language, we want to use IRIs to identify these
built-ins.  Now, the "XQuery 1.0 and XPath 2.0 Functions and Operators"
document defines IRIs for a number of the functions and comparators, but
not for all of them.  For example, the numeric-add function does not
have an IRI. So, our problem is: which IRIs should be used to refer to
such functions and comparators?


It has been suggested in the thread starting with [1] that we could add 
specific symbols (e.g., >) to our language for such "IRI-less" functions 
and comparators.  However, I do not really see a justification for 
adding symbols to the language for specific built-in functions, but use 
IRIs for others.  I think the language should be uniform and use IRIs to 
identify any built-in predicate or function.
Finally, if we were to introduce the same symbols for functions and 
comparators as xpath does, the operators are polymorphic, which is 
undesirable for us because we want to RIF processors to be able to see 
from a rule sets which datatypes and built-ins it needs to support to 
process the ruleset, and polymorphic operators would require processors 
to implement all the underlying data types and built-ins.

Best, Jos

[1] http://lists.w3.org/Archives/Public/public-qt-comments/2008Mar/0021.html
-- 
                           debruijn@inf.unibz.it

Jos de Bruijn,        http://www.debruijn.net/
----------------------------------------------
One man that has a mind and knows it can
always beat ten men who haven't and don't.
    -- George Bernard Shaw