W3C home > Mailing lists > Public > www-rdf-logic@w3.org > February 2001

Re: universal languages

From: Drew McDermott <drew.mcdermott@yale.edu>
Date: Mon, 5 Feb 2001 13:52:17 -0500 (EST)
Message-Id: <200102051852.NAA04807@mr3.its.yale.edu>
To: connolly@w3.org
CC: drew.mcdermott@yale.edu, www-rdf-logic@w3.org

   > > Should the language have types?  I think the answer is a strong Yes,
   > but many AI languages have used sets instead.  The difference is that
   > types behave more like a syntactic restriction on variables and
   > predicates, whereas sets are objects in the domain.

   er... the PCC/PCA work
     http://www.w3.org/DesignIssues/Logic#PCA
   shows that stuff I want to do can be
   done with typed lambda calcluclus. I'm guessing, but I
   suppose that's sorta what you mean by types. I have no idea
   whether the same stuff can be done without types.

   Folks have been asking about model-theoretic semantics for
   RDF; when considered as a cut-down FOPC, that's easy enough
   to do in terms of regular old ZF-set theory and such.
   I went looking for model-theoretic semantics for typed
   lambda calculus and found hairballs.
   Is that what you mean by sets? i.e. sets in the model theory?
   Or sets ala RDF Classes?

There are two alternative lines of descent from Russell and Whitehead:
set theory and type theory.  The former avoids paradoxes by careful
axioms, the latter by requiring that all formulas are well-typed.  Set
theory uses less machinery, but the resulting mathematical economy is
of little relevance to us (in my opinion).

By set I mean "RDF class," i.e., a collection of objects referred to
by terms in the theory.  (The model theory has its own requirements.)

   > > Should the language have functions?  They are often very handy.  In
   > PDDL, for instance, we have recently added functions that denote
   > fluents, so that volume_in(tank3) might denote the time-varying amount of
   > fluid in tank3.

   PDDL? pointer?

My web page: http://www.cs.yale.edu/~dvm, follow link to "Planning
Domain Definition Language."  (It's currently being revised by the
committee organizing the 2002 planning competition.)

   > Some of the participants in a the discussion assume that
   > intensionality = quotation.  It's true that quotation is one way to
   > implement intensionality, but it's not the only way.  The other is
   > just to use possible-world semantics.

   pointer?

Hughes and Cresswell, Intro. to Modal Logic

Robert Moore's 1995 Logic and Representation, which I haven't read,
but appears to contain a recent update of his classic Ph. D. thesis
from the 70s on possible-world semantics for belief and action.

Ernie Davis's book on knowledge representation may talk about possible
worlds.  I'm pretty sure it goes into the quotation idea in some
detail.  (His student Leora Morgenstern wrote a thesis on the
subject.)

The key idea behind possible worlds is to analyze believes(a, p) as 
"In all possible worlds consistent with what agent a believes, p is
true."  It may seem as if we have to quote p to make it into a term,
but we don't.  We just treat it as denoting a function from possible
worlds to truth values.  In fact, all propositions are such
functions.  So "believes" is a function from 
     (agents, prop) ->  prop

where prop = worlds -> truth-values

and believes(a, p) is true in world W if in all worlds W' "accessible
to W" such that W' is consistent with what a believes, p is true in
W'.

We need to toss in an accessibility relation so that we can control
the quantification.  So we can say things like

believes(Fred, believes(Mary, faithful(Fred)))

The accessibility relation, and the property "consistent with what a
believes" are just given.  (The usual semantic move.)  These entities
must be constrained by various axioms, such as

    believes(a, p) -> believes(a, believes(a, p))

which is true if the accessibility relation is transitive.

   > I don't understand the power of "triples."  Doesn't XML already have
   > "triples"?  If I say
   > 
   > <foo u="x">
   >    <baz v="y"/>
   > </foo>
   > 
   > isn't there a triple x-baz-y?

   The nodes in that triple aren't URIs.

   >  What's the big deal?

   Well... triples look like an important primitive when
   your (my) background is in the Web, where links
   have two ends and a type. The subject-verb-object thing
   seems to be an important primitive in human communication
   (cf Chomsky). RFC822 header fields have
   the same property/value structure, with an implicit
   subject. Likewise library catalog cards. OOP programming uses
	   object.prop = value
   all the time.

   Triples are an idiom that show up all over the place,
   in my experience. They look like a pretty important
   and useful modelling primitive.

   I think the object/property/value will continue to
   be an important idiom for communication with users,
   whether or not it continues to be The Ultimate Primitive
   in a universal language for the web.

Ah, from this remark and those made by others, I begin to understand a
bit what the appeal of triples is.

   > Let me repeat the problem: If RDF is just a mechanism for describing
   > the syntax of some other language, then it's irrelevant.

   Not totally; you have to have some syntax to put in email
   and to put into and out of tools. There's a certain
   investment in software and wetware in RDF. Maybe not
   indispensable, but not irrelevant either.

I guess my objection goes like this: I've got nothing against binary
relations.  If there were a good reason, I would even go along with
eliminating everything *but* binary relations.  But everyone
acknowledges that we need something else (quantifiers, types,
statements about statements, etc.), so we must be able to put
something else around the binary relations.  Here's where we run into
trouble.  Using binary relations to *describe* something else does
*not* succeed in wrapping that something else around the binary
relations.  It just shifts us to talking about a completely different
language, or, more often, *not* talking about it.

   [Jonathan Borden:]
   I view RDF as simply a mechanism to represent directed graphs whose nodes
   and arcs are labelled with URIs -- no more -- no less. As a language naked
   RDF is capable of describing such labelled directed graphs.

   On top of that, the presumption is that one can layer logical statements.

The first point is not quite true; the second is obscure.

If the purpose is to represent graphs on URIs, then the question
becomes whether the contents of a KR system is essentially a graph, or
essentially a set of sentences.  Through the ages (or at least the
last forty years), people have been attracted to the graph idea, but
sooner or later they give up on it.  The development of Cyc is a
classic example.  It started off as a semantic network, but eventually
switched to being a variant of predicate calculus.  You can still have
graphs, for indexing or algorithmic purposes, but they're not the
primary notation.  The reason is that it's just too clumsy to do
semantics on a graph.  

If you insist that we really do need to represent graphs (say, to
encode knowledge about a telephone switching network), then you might
want to consider RDF as a graph-description sublanguage of our target
language.  But you still have to give up the idea that the truth value
of a subgraph is independent of its context.  If I describe
Friedrich's beliefs about the French telephone system, I do not
thereby describe the French telephone system.

I don't know what is meant by "layering logical statements" on RDF,
unless it means describing another language in RDF, which, as I said
above, is not very productive.

                                             -- Drew McDermott

P.S.  I'm about to disappear for a while for a medical reason, not
because I've run out of things to say!
Received on Monday, 5 February 2001 13:52:20 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:38 GMT