[SCL] The semantics of "semantics"

[John F. Sowa]

Chris and Jim,

There are some interesting issues in these notes, and I'll make
some selective extractions of points to comment on.

CM> But I do want to point out that I don't *think* there was as much
 > of a mismatch between me and Tanel on this point as you suggest.
 > He was clearly using the term "semantics" in a way that is common
 > in the theorem proving, ontology, and Sem Web communities -- as
 > something more syntaxy in orientation -- and, although it is not
 > the way I would use the term talking with you or Pat, I was trying
 > to follow suit.

That's a good point.  In a way, that is closer to the Frege-Russell
tradition, which was much more syntaxy.  There are precedents for it,
but that approach makes it harder to talk about syntax-independent
equivalents.

CM> My question to Tanel was simply how RDF was to be used for any sort
 > of "semantic translation" of an SCL-conformant language when it is not
 > capable of providing the "semantics" (i.e., axioms) for a term that
 > an SCL language is capable of providing.  What he was calling
 > semantics just looked like quotation to me.

I wasn't sure what he was referring to, and that is why I suggested
that we avoid using the word "semantics".

In reading Jim's note, I can see that the phrase "on top of" can also
be confusing, depending one where your center of gravity happens to be.

Another source of confusion is that both RDF and OWL take advantage of
the fact that XML has powerful metalanguage features.  XML inherited
that power from SGML's use as a markup language for describing any
feature of any object language that might happen to reside in the
character strings nestled between the tags.  When extensibility
was emphasized for XML, those mechanisms were applied to the tags 
themselves.  That gives you tremendous power, but it can also leave
you with a queasy feeling about what it means.

<aside>
This discussion reminds me of a cartoon by R. Crumb, which featured
the guru character named Mr. Natural:

   Frantic disciple:  Mr. Natural, Mr. Natural, what do it all mean?

   Mr. Natural:  It don' mean sheeeeeit.

See the attached JPG file for a picture of Mr. Natural.
    <aside>
        This comment is not intended to cast any aspersions
        on any aspect of RDF or the W3C or any of the works
        and pomps.
    </aside>
</aside>

JH> 1) RDF is a document language that has a meaning of its own.  Thus,
 > if I say http://www.cs.umd.edu/users/hendler rdf:about "james Hendler"
 > it carries some sort of assertional meaning (and the model theory for
 > that meaning is a document Pat has edited [1])

Actually, Pat's model theory is very simple and classical.  It just
looks different from what Tarski wrote because Tarski was talking
about a very different syntax.  But Pat's model theory is very, very
similar to what Peirce did for existential graphs and what I've been
doing for conceptual graphs.  That is not surprising, since RDF is
equivalent to the subset of EGs and CGs that uses only conjunction
and the existential quantifier.  If you add negation and a mechanism
for showing scope, you have full FOL (which is what Peirce did to
make EGs equivalent to the algebraic notation for predicate calculus).

In short, I don't see any problem in relating the RDF model theory
to the SCL model theory.

JH> 3) One can use the RDF or OWL languages and their own MTs to develop
 > languages that use, rather than extend, this semantics.  For example,
 > I could state...

That example shows how the XML facilities are used as a metalanguage
to define a new syntactic construction called "rule".  I agree that
the syntax, by itself, doesn't give you a model theory.

JH> The use of this, of course, is that now I can have files that have
 > many instances of this thing called rule that can be "semantically"
 > checked for some sort of well-formedness, even if the properties are
 > defined in different files and linked together (i.e. if I discover a
 > rule with two consequents or no antecedents, etc. I know it is not a
 > "rule" as defined here, whereas if I find a antecedent in one file and
 > the consequent in some other one, I can determine it may be a rule
 > since it meets the requirements expressed above).

I agree that such checking is important, but I would call it "syntatic"
checking rather than "semantic" checking.  Well-formedness is a
prerequisite for semantics, but it is not a substitute for semantics.

JH> The use of this, of course, is that now I can have files that have
 > many instances of this thing called rule that can be "semantically"
 > checked for some sort of well-formedness, even if the properties are
 > defined in different files and linked together (i.e. if I discover a
 > rule with two consequents or no antecedents, etc. I know it is not a
 > "rule" as defined here, whereas if I find a antecedent in one file and
 > the consequent in some other one, I can determine it may be a rule
 > since it meets the requirements expressed above).

If you replace the word "semantically" with "syntactically", then I
would agree completely.  Furthermore, I don't see any problem with the
fact that there are multiple files.   Compilers, link editors, and
pointers to multiple files with multiple parts of a compilation have
been in routine use for programming languages and operating systems
for over 40 years.  There is no fundamental difference between having 
those files on the same machine or on machines scattered across the
galaxy.  And exactly the same techniques that are used to link
multiple subprograms can be used to "link" multiple parts of a logical
specification.

I agree that most logicians don't usually think in terms of compilers
and link editors, but anyone with comp. sci. background would have no
problem putting the ideas together.

JH> I could imagine all or some of SCL being described with relation to
 > any or all of these uses of RDF.  Note also that RDF is quite
 > different from XML [NOTE: Do you mean SCL?] in all of the above -
 > it has no MT and thus one first has to invent one for one's own domain
 > to make it work.

Not exactly.  I would say that the default model theory for RDF is
the one that Pat presented in ref (1).  That is a very classical model
theory, which fits into the SCL model theory as a simple subset.
Problems can occur, however, if somebody introduces new vocabulary
with terms such as "not" or "imply" and expects them to have some
meaning similar to what they mean in English (or a logician's dialect
of English).

And this problem is not limited to RDF.  Very similar problems arise
in SQL, since every collection of tables in a relational database
can be considered to represent a version of logic restricted to just
existence and conjunction.  That is in fact the default assumption,
which is used as the basis for the SQL query language, which can be
used to express any statement in FOL (with the assumption of negation
as failure).

In fact, SQL can be considered a superset of RDF, since any collection
of RDF triples can be stored in a single table with three columns.
People have been relating SQL to versions of logic for years in
things called "deductive databases".  All that work could be used
for relating RDF to logic -- there's very little difference in
theory, although it is important to check all the nitty gritty details.

JH>  This has some advantages (i.e. SCL could be defined from scratch
 > without having to sit on top of another MT)

I don't know what that means.  SCL doesn't "sit on top of another
model theory".  Model theory is simply a method for defining the
truth value of any particular SCL statement.

JH> but also some disadvantages, particularly with respect to the third
 > use above, as creating an XML "language" only allows for syntactic
 > verification, and allows no automated semantic checks with respect to
 > a "model" being defined,

That's not a problem.  That is a statement of why RDF and OWL need SCL.

JH> and also requires a locality of reference that RDF doesn't.

As I said above, locality of reference is not a problem.  It has been
handled quite nicely for 40 years by the programming language community,
and very similar techniques can be applied to any language in the SCL
family (which I believe could include RDF).  We have been talking about
the use of "modules" for CL/SCL, and each web page could be represented
by an SCL module.

A comment on one of Chris's comments that I heartily endorse:

CM> Recall that SCL is not itself a language, but a framework that
 > specifies an entire class of languages; roughly speaking, SCL is
 > to a particular SCL-conformant language like KIF what Boolean Algebra
 > is to a specific algebra like the powerset algebra over the set of
 > natural numbers.

I am quoting this only to emphasize it.  Unlike XML, which has an
implementation, on top of which other languages can be implemented,
SCL is only a framework.  One doesn't "implement" anything "on top of"
SCL.  One only uses SCL as a "framework" for specifying other
languages, such as KIF or CGIF, which do have implementations.

By making RDF or OWL an SCL-compliant language, they automatically
inherit the formal semantics of the SCL framework.  That is why I
have chosen to make CGIF an SCL-compliant language -- it simplifies
my job of defining CGs and it enables CGIF and KIF to be completely
interoperable.

John
-------------- next part --------------
A non-text attachment was scrubbed...
Name: natural.jpg
Type: image/jpeg
Size: 9794 bytes
Desc: not available
Url : http://philebus.tamu.edu/pipermail/scl/attachments/20030116/d2f87a6b/natural.jpg