[RIF] Mapping of DVL and WRL into condition language of extensible design

Find attached my reaction to action item
http://www.w3.org/2005/rules/wg/track/actions/20

best,
axel

-- 
Dr. Axel Polleres
email: axel@polleres.net  url: http://www.polleres.net/

This addresses action item:
http://www.w3.org/2005/rules/wg/track/actions/20

Here is a try for mapping WRL and the language of DLV into the
condition language proposed by Harold Boley et al.
 As for features of the languages/systems, please refer to my previous analysis
of the two languages in terms of RIFRAF, see
http://lists.w3.org/Archives/Public/public-rif-wg/2006May/0197
http://lists.w3.org/Archives/Public/public-rif-wg/2006May/0198


Again, I will use
  --> comment axel: 
to preceed concrete comments/suggestions on the proposal.


============================================================================
I will go through the basic condition language and the proposed extensions:

A.1 Basis: Positive Conditions +
A.2 Extension: Negative Conditions

I take the extended version of basic syntax with
negation as a starting point:

  Data     ::= value
  Ind      ::= object
  Var      ::= '?' name
  TERM     ::= Data | Ind | Var | Expr
  Expr     ::= Fun '(' TERM* ')'
  Atom     ::= Rel '(' TERM* ')' | TERM '=' TERM
  LITFORM ::= Atom | 'Neg' Atom | 'Naf' Atom | 'Naf' 'Neg' Atom
  QUANTIF  ::= 'Exists' Var+ '(' CONDIT ')'
  CONJ     ::= 'And' '(' CONDIT* ')'
  DISJ     ::= 'Or' '(' CONDIT* ')'
  CONDIT   ::= LITFORM | QUANTIF | CONJ | DISJ

[WRL] The language of WRL coincides with the proposed language
modulo additional frame-based syntax: The language is also an 
ontology language and allows syntactical constructs inherited 
from F-Logic, even schema-level statements in conditions
such as:
- checking attribute filler assertions:  'hasValue'
- subconcept relationship assertions: 'subConceptOf'
- membership assertions: 'memberOf'
- schema assertions on attribute ranges: 
    'ofType' (constraining, LP style)
    'impliesType (inferring, OWL style)
as well-as (built-in) comparison operators in conditions.
 If these notions are not to be covered in RIF itself, 
we have to define canonical mappings in terms of designated binary and 
ternary relations, e.g. a naive such mapping for the respective 
keywords occurring in conditions would be:

1) a[b hasValue c]   <--> wrl:hasValue(a,b,c)
2) a memberOf b      <--> wrl:memberOf(a,b)
3) a subConceptOf b  <--> wrl:subConceptOf(a,b)
4) a[b impliesType c] <--> wrl:impliesType(a.b.c)
5) a[b ofType c]      <--> wrl:ofType(a,b,c)

Note that the designated relations wrl:hasValue, 
wrl:subConceptOf, wrl:memberOf , wrl:impliesType, and wrl:ofType carry
additional semantics which may be axiomatized, as indicated at 
http://www.w3.org/Submission/WRL/, Section 3.4.

As for objects vs. values:
Datatyped values are distinguished in WRL by designated function
symbols, values can be number, strings or functional terms,
object ids are IRIs.

--> comment axel: From the current condition proposal, it is not yet
clear how values and objects are to be disdinguished syntactically. This
needs refinement, for instance, by adopting the WRL proposal or by
distinguishing literal values as in RDF.

[DLV] has a very simple condition language, namely comma-separated
lists of possibly default negated body literals. This fit's directly
into in the proposal, taking the subset of function-free LITFORMS
and replacing:
  'And' <--> ','
  'neg' <--> '-' (strong negation)
  'naf' <--> 'not' (default negation)

DLV does not make a disctinction between objects and values.

--> comment axel: BTW: For a later stage syntax shall also allow
negation in front of non-atomic conditions, IMO.

A.3 Extension: Resource Conditions

[WRL] Supports a basic, extensible set of built-in functions and built-in
relations.

[DLV] Allows definition of builtins which may have different possible
binding patterns associated.

--> comment axel: As for extensions A.3 (builtin's and conditions)
as already mentioned before, I'd suggest that it shall be possible to
define allowed binding pattterns for such builtins, as well as choices
between infix,prefix and postfix notation for binary builtins: This
turns out to be useful, e.g. for < (nobody wants to write '<(X,Y)').

--> comment axel: Furthermore, the syntax for such built-in relations
shall in a second phase allow set-valued built-ins such as aggregates
(count,min,max,avg), i.e. built-ins, which do not only accept certain
bound values as input, but also the extension of a relation), see DLVHEX
for a proposal on a general syntax/semantics for this.

A.4 Extension: Resource Conditions

[WRL] no. WRL has an RDF syntax and is compatible with most of RDF.
   In this way, RDF statements such as basic graph patterns can
   easily be seen as conditions in the rules, although a concrete mapping
   to SPARQL is yet undefined.

[DLV] no. However, RDF access is allowed in the DLVHEX extenstion via a 4ary  
  built-in predicate taking a URL as argument and having S,P,O as 
  "output" parameters. This could be extended to take a SPARQL query 
  instead of the URL.

A.5 Extension: Ontology Conditions

[WRL] partially. WRL accepts ontology conditions using its own ontology
language; including schema-level statements.
Additionally, OWL-DLP conditions are accepted, modulo the mapping between OWL
and WRL.

[DLV] no. Hovewer, the DLVHEX extension allows bidirectional access 
 (i.e. more than querying only) to OWL via dl-predicates. 
  i.e. factual knowledge (ABOX) can be added to the OWL KB before querying.

--> comment axel: Since the extension of OWL querying suggested in DLV
has a clearly defined and intuitive semantics, it might be worthwhile to
adopt it as a slight extension of the query-only interfacing.

B. Extension: RIF Horn Rule Language

[WRL] yes.

[DLV] yes.


C. Extension: RIF Production and Reaction Rule Languages

[DLV] no.

[WRL] no.