Re: Logic and Using The Semantic Web Toolbox

From: pat hayes <phayes@ai.uwf.edu>
Date: Mon, 4 Dec 2000 16:15:26 -0600
Message-Id: <v0421010cb651b76d7ba5@[205.160.76.86]>
To: Drew McDermott <drew.mcdermott@yale.edu>

```>   Pierre-Antoine CHAMPIN wrote:
>
>      So you admit that (wins Bush election2000) does not have the same
>   role when written alone, or as a nested expression.
>
>      In the language you use, every outer parenthesis-pair makes an
>   assertion ; inner parenthesis-pairs do not.
>
>      In RDF, each arc of the graph makes an assertion. If you want to
>   quote an arc without asserting it, you need to write/express it (in
>   the graph) not as an arc. The chosen solution is reification.
>
>I realize this is the model.  I don't understand the rationale for it,
>or why the issue has already been decided.  (I also don't understand
>why reification solves the problem; if it's supposed to be beyond my
>control whether all subgraphs of G are asserted whenever I assert G,
>why isn't it beyond my control to prevent the assertion of expressions
>that are named without being uttered?)

Reification does not solve the 'problem'. (I use scare quotes because
it is a non-problem.) It would be just plain wrong to think that by
writing a non-atomic expression such as:
(implies (wins Bush election2000)(crumbles World-civilisation))
one is thereby *mentioning* (as opposed to using) its sub-expressions.

There are two distinctions here: between the content of an expression
and the act of asserting that content; and between an expression and
a description of that expression. One can make the first distinction
without getting involved in the second distinction. Every human
language in the world does this. If you say, "The man you saw
yesterday was Chinese", you are referring to a person, not mentioning
the noun phrase "The man you saw yesterday".

>I suspect that what happened was that (a) people thought the graph
>model was cool; (b) they realized it has this bug (where's the top of
>it?); and (c) they decided to try to do without the notion of "top of
>the graph."  AI went through all this twenty years ago, but for some
>reason no one opted for this solution, as far as I know.

Hey, philosophers went through all this over a century ago, and they
got it right. There is a distinction between a graph, and the
node-arc-node triples which constitute the graph. Graphs can indeed
have top nodes, reflecting the fact that top-level expressions can be
clearly and unambiguously distinguished from subexpressions.
Semantics is about content, and as far as this is concerned there is
no need to make the distinction, so that all expressions are treated
alike - they mean the same thing/express the same content, whether or
not they are subexpressions of a larger expression. But only
top-level expressions get *asserted*. That is, to claim that a
sentence is true, one writes it as a top-level expression. (That's in
the usual model of language. In many machine ontology systems, to
assert something one has to enclose it in an 'assertion wrapper' of
some kind.) Subexpressions of larger expressions are not asserted
(but they have the same meaning that they would have if they were
asserted.) This is often described by calling the top-level
expressions 'forms'. Every form is an expression, but not all
expression tokens are forms. Again, nothing mysterious here: all
human languages are like this. If you say: "If he comes here again, I
will phone the police", you are not asserting that he will come here
again, right?

According to Pierre-Antoine, the RDF designers thought that every
component of every expression had to be a form. I hope he is wrong,
because  that would have been a very, very,VERY bad decision. Such a
bad decision, in fact, that it would be less trouble to junk it now,
abandon RDF and start over, than it will be to try to continue with
it. This is like deciding to build airplanes out of lead.

> The usual
>solutions are:
>
>(a) Introduce extra structure into the graph to indicate where the
>actual syntactic boundaries are.  One way is the "partitioned
>networks" of Gary Hendrix  Another is Stuart Shapiro's SNePS model,
>which I believe is the one most thoroughly worked out.  I'm not an
>expert in this area, but I think there are several experts involved in
>this discussion.

John Sowa's conceptual graphs (CGs) are another example, more recent
and considerably more elegant. (SNePS tries to be able to express
anything that can be said in English, a very tall order.)
But this degree of complexity is needed only to indicate scope
boundaries of quantifiers. If there are no bound variables in the
language, one can treat the data model as a simple graph (in fact, a
directed acyclic graph.)

>(b) Relegate the graph model to secondary status.  The primary model
>is in terms of strings, and the graphs are introduced as
>implementation details (for indexing purposes, or to provide
>special-purpose inference algorithms).  This is what CYC does.

Or, one can get to a very RDF-ish description by thinking of the
abstract syntax of the linear language as an abstract algebraic
structure, and then representing it as a directed graph. This avoids
the intricacies of partitioned semantic networks and SNePS, and seems
to have all the advantages of the linear notation (unambiguous
parsing, clear syntactic structure, guaranteed linearizability)
without the disadvantages (idiosyncratic notation, remoteness from
the 'abstract' data model).

>Maybe these approaches are just too hopelessly uncool for the
>hyperwired web.

Well, if it is cool to be hopelessly wrong, then you might be right.

Pat

---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu
http://www.coginst.uwf.edu/~phayes
```
Received on Monday, 4 December 2000 17:13:52 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 2 March 2016 11:10:33 UTC