XML [SCL] Issues and proposals (details)

[Tanel Tammet]

Hi,

Since the XML & RDF issues seemed to heat up - sort of -
I'd again stress some points for having an XML language
for SCL, different from RDF. This does not mean avoiding
RDF, quite the opposite: IMHO a "semantic translation"
should be into RDF, not SCL-XML.

Here are some arguments against the _direct_ translation
mechanism from SCL-lisp into RDF:

- As far as I understand, suggested translation of SCL to
   RDF does not preserve logical equivalence: once you
   start encoding N-ary predicates as triplets, you introduce
   new predicates. Satisfiability/unsatisfiability is preserved,
   of course, but logical equivalence is not.

- Again, if I understand it correctly, nested and-s, or-s,
   implications etc would have to be flattened in RDF.
   First, this sometimes means an exponential growth in the size
   of the formula. Second, there are many different ways to
   flatten, some good in one situation, others in other
   situations.

- RDF as a standard input language would just not cut it in
   several logic-using communities. It would probably not be
   much used in the automated theorem proving community
   and the verification community: hardcore logic people
   explicitly thinking about logical formulas as logic.

   Some of the reasons were given above: for example, in case
   you have a formula encoded in RDF, it would be fairly hard
   to get it back intact into the original form with N-ary predicates.

- Translation schema
   SCL <-> SCL-XML <-> several other XML-s, incl RDF
   seems to be simpler than
   SCL <-> RDF <-> several other XML-s


This said, I do completely agree with a strong need for RDF
translation, but I suggest getting RDF via SCL-XML language
which would be as close to SCL-lisp as possible.

Injecting scl-lisp (with all the parentheses etc) as unchanged
strings into XML tag parameters will not make anything simpler: you
still need to parse scl-lisp, inside these strings. What will
you gain from XML around SCL-lisp?

IMHO SCL-XML should be a trivial encoding of lisp syntax.
It should not take into account semantic issues (for example,
it should not distinguish predicate and function symbols,
should not have any special treatment for equality, etc etc).

For a "semantic translation" we could well use RDF: it is
there already, with lots of distinguishing possibilities etc.

RDF users would probably feel happier writing converters
from/to XML, not lisp. If we have a trivial, standardised
XML representation, then a few basic SCL-lisp <-> SCL-XML
implementations would suffice. People can then modify and hack
converters between SCL-XML and RDF. I'd guess that whichever SCL-RDF
encoding we will design, quite many developers will not
like the encoding. They'll prefer modifying it or creating
their own. It would be easiest to do so if we present
a default nonsemantical SCL-lisp <-> SCL-XML translation plus
a default semantical SCL-XML  <-> RDF translation.


Regards,
          Tanel Tammet