From: Jeremy Carroll <jjc@hplb.hpl.hp.com>
Date: Fri, 15 Mar 2002 12:38:52 -0000
To: <www-webont-wg@w3.org>
Message-ID: <JAEBJCLMIFLKLOJGMELDOEGECDAA.jjc@hplb.hpl.hp.com>
```

Amazingly, at the telecon last night, I saw the light ...

Overview
========

I will take a deeply solipsistic view of Peter's entailment(s) [1] and his
paradox [2], and give negative answers to all of them, including the

I will for each, give an equivalent, and in my view, as useful, an
entailment, that solipsistically holds.

I will discuss how these entailments might fit with a workable query system.

I will then discuss why the answers are more appealling to me from an
implementation point of view, particularly from the Jena API [3] viewpoint.

I work in a framework roughly equivalent to Peter's SWOL [4] with radical
solipsism.

=================
"nothing necessarily exists."
In this framework all the sets that Peter sees as necessarily existing have
only a contingent existence. Thus all the entailments fail, but equivalent
non-trivial entailments in which existence of the sets is added as a premise
hold.

This allows us to isolate OWL consequences from set theoretic consequences
which I think is in general a plus.

Entailments
===========

A: { Person, Student } = { Student, Person }
--------------------------------------------

Peter:
[[[
:John a _:1 .
:_1 owl:intersectionOf ( :Person :Student ) .

should entail

:John a :_2 .
:_2 owl:intersectionOf ( :Student :Person ) .
]]]

Solipsistically NO, :_2 does not necessarily exist.

But

:John a :_1 .
:_1 owl:intersectionOf ( :Person :Student ) .
:_2 owl:intersectionOf ( :Student :Person ) .

solipsistically entails

:John a :_2 .

Note that this entailment still captures the essence of the identity that
the previous entailment embodied.

B: { Person, Student } = { Student, Person, Student }
-----------------------------------------------------

Peter:
[[[
:John a :_1 .
:_1 owl:intersectionOf ( :Person :Student ) .

should entail

:John a :_2 .
:_2 owl:intersectionOf ( :Student :Person :Student) .
]]]

Solipsistically no, set :_2 is not known to exist.

But

:John a :_1 .
:_1 owl:intersectionOf ( :Person :Student ) .
:_2  owl:intersectionOf ( :Student :Person :Student) .

solipsistically entail

:John a :_2 .

--------------------------

Does

[empty]

entail

_:1 rdf:type owl:Restriction .
_:1 owl:onProperty rdf:type .
_:1 owl:maxCardinalityQ "0" .
_:1 owl:hasClassQ _:2 .
_:2 owl:oneOf _:3 .
_:3 owl:first _:1 .
_:3 owl:rest owl:nil .
_:1 rdf:type _: 1 .

Solipsistically no.

One way we can get a paradoxical set as a consequent of an entailment is to
have such a paradoxical set as an antecedent. All that says is that madness
follows from madness, which is well known GIGO.

Query
=====
Given a system with the following asserted:

:John a :_1 .
:_1 owl:intersectionOf ( :Person :Student ) .

:_2 owl:intersectionOf ( :Student :Person ) .
(
or for that matter
:_3 owl:intersectionOf ( :Person :Student ) .
)
first should add the existence statements
:_2 owl:intersectionOf ( :Student :Person ) .

to the system, and then ask the query
:John a :_2

Asking the more general query on the original knowledge base

:John a WHAT?

replies the finite set of possibilities

WHAT = owl:intersectionOf ( :Person :Student ) .
WHAT = :Person
WHAT = :Student

If the query system asserts
:_2 owl:intersectionOf ( :Student :Person ) .
WHAT = owl:intersectionOf ( :Student :Person ) .

will be replies.

A non-solipsistic view may result in the infinite uninteresting and

WHAT = owl:intersectionOf ( :Person :Student ) .
WHAT = owl:intersectionOf ( :Person :Student :Student ).
WHAT = owl:intersectionOf ( :Person :Student :Student :Student ).

...

So solipsism seems more useful for query.

Given the knowledge base

<John> a <Person> .
<John> a <Student> .

the query

<John> a WHAT

will only produce the two answers, and not start working through the set

The Jena API
============

From the HP group's point of view the major contribution of Jena is the API
design.
Particularly worthy (IMO) is the API into the triples, the RDF Graph
(unfortunately misnamed as "Model", following the Stanford API, which
follows M&S).

The underlying programming abstraction of this API is that there is a set of
triples and you can access these triples in a triple oriented fashion. One
way of accessing (at some level the only way) is to iterate through them (or
those that match some selection criterion).

Our planned OWL implementation is to reuse the same successful API, and to
slot underneath a new inferrencing implementation (the API will need some
refactoring).
The inferrencing implementation will dynamically (lazily) apply closure
rules.

A worry is that the finite graphs that it currently deals with may become
infinite.
If any constructive set theory is part of OWL then we may have that even an
empty graph of base facts expands to an infinite set of (uninteresting)
inferred facts.

Using this API it is very natural to ask give me all the triples that have
<foo> as subject and <type> as predicate.

It will not be:
- difficult to implement
- and unhelpful to all users

if the correct answer is at least

owl:oneOf ( <foo> )
owl:oneOf ( <foo> <foo> )
owl:oneOf ( <foo> <foo> <foo> )

....

solipsism provides better answers and a more usable system, and hence a more
useable language.

Jeremy (of course I don't exist either :) ).

PS I didn't know what solipsism meant either, my manager suggested the word.
I think he intended thw word as a disparagement. (We *do* have a higher
class of manager at HP Labs).

[1] Student Person entailments
http://lists.w3.org/Archives/Public/www-webont-wg/2002Jan/0025.html
http://lists.w3.org/Archives/Public/www-webont-wg/2002Jan/0028.html

http://lists.w3.org/Archives/Public/www-webont-wg/2002Jan/0099.html

[3] Jena Model API

ml

see particularly (possibly incorrectly entered URL fragment)