Re: Thoughts on abstract syntax

Chris Welty wrote:
> 
> 
> <chair hat off>
> Trying to put some order to my thoughts on the subject:
> 
> We decided at a recent telecon to continue developing an abstract syntax 
> side-by-side with the current BNF. 
> I think it would be productive to agree as a group with Paul's 
> suggestion that we will produce an abstract syntax in some form (asn06, 
> OWL, RDFS, ...), a meta-model (in UML), a human readable syntax (in BNF) 
> and an XML syntax.  We can agree do to this and then later we can decide 
> which of them are normative.  The charter indicates the XML syntax 
> shoudl be normative, but doesn't preclude us from making any others 
> normative, too. Also, we may find we want the meta-model to be the 
> abstract syntax or vice-versa.
> 
> I think most people agreed that these various forms are isomorphic, 
> modulo a technical limitation here and there (to be explored).
> 
> As anyone who has ever done any kind of modeling knows, when you try to 
> maintain more than one artifact that is supposed to describe *the same 
> thing* you always end up with a maintenance problem keeping them in 
> synch.  Thus it seems it would be productive to agree as a group that 
> one of these will be the "primary" object of maintenance in our work 
> (note that this is not the same as being normative) and the others 
> either generated automatically through some tools (ideal) or by human 
> effort.
> 
> Choosing the abstract syntax as the primary (though, again, perhaps 
> non-normative) syntax appeals to me because it allows us to focus on 
> certain aspects of RIF while postponing others.  For example, we need to 
> consider in Phase 1 how to integrate RDF into RIF (to the extent it is 
> compatible with the CORE semantics).  How will this be done?  RDF only 
> allows binary predicates, and treats unary predication as a special kind 
> of binary predicate, e.g. the atom P(A) in a rule language would be 
> expressed as type(A,P) in RDF.  Do we define a mapping from RDF triples 
> into RIF syntax, or does RIF carry RDF triples as RDF?  We also need to 
> consider how to transmit RDF data as ground atoms in RIF.  Are we going 
> to invent our own special RIF syntax for RDF triples, or are we going to 
> invent a special RDF syntax for higher-arity predicates, or are some of 
> our ground atoms going to be in RDF and the rest in our own syntax, or 
> something else?  Are rules going to look different than ground atoms? 
> etc etc.  We have not really begun to discuss the alternatives here.

[*] Comment out of line since this is not the main point of your message.

> By working at the level of an abstract syntax, we can postpone that 
> decision and work on the current issues.  It seems to me that we would 
> need to directly address these questions if we are to have hope of a BNF 
> syntax, and that the current BNF syntax already biases us away from some 
> of the options for handling RDF (not to mention OWL) which we haven't 
> discussed (it is biased because radical changes to the syntax would be 
> needed if we went with some of the approaches).  In an abstract syntax, 
> we say something like
> 
> Atom::
>  Predicate: term
>  Args: list of term
> 
> GroundAtom::
>  Args: NonVariableTerm
> 
> etc., without committing to a particular decision on how RDF ground 
> atoms are to be treated specifically.  We all know rules will have atoms 
> in them and that the atoms may contain variables, etc., and there is 
> considerable work that can be done without dealing with the specific 
> problem of rdf-ground-atoms now.

Agreed with concentrating on the abstract syntax for now.

There are some issues of RDF mapping which can be expressed at the 
abstract syntax level (e.g. whether RDF predicates map to rule 
predicates and if so whether variables are allowed in the predicate 
position).

> Note of course that there are already a slew of other issues like the 
> RDF one I use here that could have the same impact on a concrete (e.g. 
> BNF) syntax, but far less impact on an abstract syntax.

Agreed.

[*] We certainly haven't decided anything but we have had at least had 
some discussion on these issues - first at f2f1 (captured in the wiki by 
Jos, Peter et al) then more recently both Axel and I included RDF 
mappings in our worked examples [1][2] which led to some discussion at f2f4.

Dave

[1] http://www.w3.org/2005/rules/wg/wiki/UC8_Worked_Example
[2] http://www.w3.org/2005/rules/wg/wiki/UC10_Worked_Example

Received on Wednesday, 29 November 2006 22:44:55 UTC