Re: Logic and Using The Semantic Web Toolbox

>   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