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

Re: What do the ontologists want

From: Jonathan Borden <jborden@mediaone.net>
Date: Tue, 15 May 2001 19:12:11 -0400
Message-ID: <11a301c0dd94$7992b550$0a2e249b@nemc.org>
To: "pat hayes" <phayes@ai.uwf.edu>
Cc: <www-rdf-logic@w3.org>
pat hayes wrote:

>
> >In any case, the ability to create a reference to something has proven
> >itself useful in my practical experience.
>
> Sure, but be careful what you mean by 'reference'. A pointer to a
> position in a data structure is one kind of reference; a name
> denoting an entity is a different notion of reference. Both are
> useful, but trouble ensues if you use one for the other carelessly.
> Quotation creates a name (of a character string), not a pointer.

The issue regarding the distinction between names and addresses has been
often addressed. It is not clear to me that one can support making an
absolute distinction. Frequently 'pointers' are used as names and names as
pointers, especially in the markup world.

>
> >The reason I have suggested that quotation be implemented in a fragment
> >identifier syntax is that URI references are how we refer to things on
the
> >web, and a statement is one of the things we might want to refer to.
>
> I confess to still not knowing what a URI is supposed to be beyond a
> URL, and not believing what I have read about them. URLs are file
> addresses, a species of pointer, and those I do understand. URLs do
> not denote what they point to. The relationship between a URL and the
> file it locates is not the same as that between a logical name and
> what it denotes (for example, the locatee is not determined relative
> to an interpretation, but is fixed by the operational circumstances.)

I agree that there currently exists alot of fuzziness in this regard. I am
in the process of trying to clean this up by providing a (hopefully) logical
framework. http://www.rddl.org/SchemaAlgebra is a work in progress
addressing some of these issues. Statements 10 - 20 address URI related
terms.

Specifically:

A URI identifies a Resource. A URI is resolved to a set of Entities (i.e.
documents)
A fragment identifier may generally have 3 forms (see another work in
progress http://www.rddl.org/fragment-syntax ):

1: a name
2: a numeric address e.g. child sequence /1/2/3
3: a scheme based selector e.g. XPath, XPointer

A "URI Reference" contains a URI + fragment identifier. A URI Reference
identifies an Abstract Node in general and a specific Node within each
specific entity. (this complexity is due to the fact that each entities
returned on URI resolution may have different media types e.g. with content
negotiation)

The "name" format of a fragment identifier identifies a node by name (e.g.
an SGML/XML ID). The selector format identifies a node by query (e.g. an
XPath)

For example

http://example.org/foo#bar

identifies the _node_

<ex:foo id="bar" />

in the document:

<example>
    <ex:foo id="bar" />
    <ex:foo id="baz" />
</example>

(assuming the media type = "application/xml")

now suppose the media type = "application/rdf+xml"

<rdf:RDF>
    <rdf:Description rdf:ID="baz">
        <ex:foo rdf:ID="baz" rdf:resource="#bop">
    </rdf:Description>
</rdf:RDF>

the same URI identifies the statement:

[ex:foo #baz  #bop]

The URI: http://example.org/foo#triple(ex:foo <#baz> <#bop>)

identifies this exact same statement.

>
> >Quotation is related to query and in the same way as XPath serves as a
> >simple query language for XML,
>
> I beg to differ. XPath provides a way to refer to a position within
> an expression, which is exactly what quotation does not provide.
> Quotation simply refers to the quoted expression as an atomic whole,
> and provides no way to access its structure, syntax, parts or
> anything else.

Not true. Quotation allows perfectly good access to structure and syntax.
For example:

'(says 'Jon '(isColor 'sky 'blue))

what is the problem with access to structure?

> If you want to do that, you need something like
> quasi-quotation (an extended form of quotation invented by WVO Quine
> which allows quantification over substrings inside quoted
> expressions),

exactly.

> and if you want to be able to refer to the *content* of
> quoted expresions, then you also need something that maps between
> descriptions of expressions (such as quoted strings) and the actual
> expressions that those descriptions describe; what is usually called
> a truth-predicate.

Perhaps we are using different meanings for the term quotation. So far I am
talking about using quotation in the simplified stripped down version of RDF
that my initial post to this thread defined. This stripped down version of
RDF currently exists purely at the syntactic level.

Generally the 'something' that maps a character string to an actual
expression is called a parser/evaluator.

Bottom line: in order to be useful, quotation
> needs to be supercharged and be supplemented with truth-predicates
> (or principles of reflexion, or various other exotic pieces of
> linguistic machinery).

My assumption is that DAML+OIL intends generally to provide an acceptable
semantic meaning to RDF (abstract syntax) statements.

>
> >an RDF path language might serve as a simple
> >query language for RDF. For example:
> >
> >?x says "The sky is blue"
>
> OK, if you bear in mind that this really does mean only that ?x says
> a certain string of characters. It (quite literally) says absolutely
> nothing about skies being blue, not even that ?x said that. If you
> want to say that ?x asserts that the sky is blue, you need something
> which can map back from the quoted string "The sky is blue" to
> whatever proposition that quoted string is asserting in whatever
> language ?x is talking in.

why not:

(says ?x '(isColor 'sky 'blue))

or in the triple fragment id syntax:

#triple(:says ?x <#triple(:isColor :sky :blue)>)


note: as a _query_ this quotation universally quantifies x (assuming the
'universe' is the current database)

in an analogous fashion to an XPath which returns an XML node set on
execution, this would return a set of statements on execution.

>
> I'm not saying that this can't all be done. I am saying that it is
> exotic, not simple, and requires elaborate syntactic and semantic
> machinery to be done without producing paradoxical results.

If this stuff were easy we'd all be home now.

Jonathan Borden
The Open Healthcare Group
http://www.openhealth.org
Received on Tuesday, 15 May 2001 20:02:17 UTC

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