Re: [ontolog-forum] The Open world assumption shoe does not always fit -

[Pat Hayes <phayes@xxxxxxx>]

At 6:31 PM -0400 6/26/08, Ogbuji, Chimezie wrote:

> Hey, Pat.  Comments
> below

       

>       I would disagree about this case being the exception. 
>Negation as failure can be validly used to infer from a
>failure if the data is controlled (which is especially the
>case with well-designed experiments where it would be
>irresponsible to to do otherwise).
>
>
>What are you referring to by "well-designed experiments"?

"Well-designed experiments" is probably not a useful characterization,
so let me try again.  Let's say you are nurse performing a history and
physical assesment on a patient in order to make entries into his/her
medical record and one of the questions you ask *routinely* is whether
or not the patient has a particular symptom/problem: headaches for
instance.  If the patient says: "no", and you are conforming to default
negation as part of a subsequent analysis, then it would seem sufficient
to not make any assertion about the existence of a headache.  Otherwise,
you would need to be able to either infer that the patient doesn't have
a headache (provably false) *or* have an explicit assertion of absence:

I.

_:a a cpr:patient

II.

_:a a cpr:patient
_:a a cpr:PersonWithoutHeadache

Juat as an aside, its hardly fair to this in RDF which doesn't have negation of any kind.

> My point is that, in the first model you *can* infer that the
> patient
> doesn't have a headache because the assertion is missing and you
> *know*
> that the question was asked.

Well, let me push on this. Lets suppose that whoever wrote the record did indeed know this, and they used the 'if I don't say it, its false' strategy, saving themselves some work. But now, this is all written down in RDF. Send this RDF somewhere else, where someone else reads it. How do they know that its OK to use NAF on this RDF? The RDF itself doesn't describe the nurse's data-recording conventions, and it doesn't say that its a closed world with respect to having headaches. All it does is not refer to headaches at all. There might be any number of reasons for this. Maybe the nurse just didn't think about headaches, maybe (like my wife's endocrinologist) the doctor just didn't consider headaches to be in his focus of attention. Maybe this RDF was extracted from a larger data set by a SPARQL query which didn't happen to refer to headaches. In general, you *don't* know anything more than what is *explicitly told* to you. At any rate, that has to be the ground assumption of an ontology engine, especially in a Web setting where you have absolutely no control over what happened to the data while it was on its way to you, and nobody is under any obligation to tell you.

> The assumption that knowledge is
> *always*
> incomplete seems (to me) to not account for situations where the data
> is
> indeed complete specifically because the process of collecting it
> is
> controlled.

But if that completeness is not somehow recorded as part of the data, then all the control in the world isn't going to justify a later or distant process of *inference*. Because this control - or its effects on what the data say - is itself part of the information that this inference needs to rely on. Its not enough to just be careful; you have to record the fact that you are being careful along with the carefully controlled results of your carefulness.

> >OK, but that does not ensure that if P is not asserted, then
> >it is known to be false. In fact, rather the opposite.
>
> But it does ensure this - precisely as part of the requirements at
> the
> point where the data is collected.  My general point is that
> where you
> have decent control over the quality of
> the data in general or at least
> in the process of how it is populated, default negation can be a
> useful
> tool for allowing a person doing analysis to make (safe)
> assumptions
> from the absence of data.

Modify that to: if the person doing the analysis knows that decent control, etc. , and I will agree.

> >You can make such inferences validly only when you have some
> >reason to suppose that if the proposition were true, the
> >content would not be missing.
>
> Right, the reason in this case would be knowledge of the expectations
> of
> how the data is collected.
> >I don't mean to deny that such
> >circumstances do exist, in some cases with an explicit warrant
> >for the entailment, but they are certainly not the usual case.
> >The usual case is that your knowledge is incomplete. Our
> >knowledge of almost everything is incomplete.
>
> Certainly, but I'm simply pushing back (slightly) on what often is
> the
> typical argument against non-monotonic inference: the claim
> that
> knowledge is *always* incomplete
> regardless of how you come about it.

There is a kind of Web Doctrine that SWeb methods must be monotonic because the Web is open-ended and you might get more information later, after you make any inference. But this is more of a kind of methodological justification than a serious factual claim, I think.

>       without the burden of classic negation, which requires
>a significant amount of effort

>Nonsense. There is no 'burden' of classical negation. Negation
>IS classical negation. If you conclude that P is false, and
>express this using a negation connective, you are using
>classical negation. (If your *conclusion* from a failure to
>prove P is that P is not proven, then your reasoning is
>completely classical also; but then you are only concluding
>failure, not negation from failure.)

The burden I was refering to, is the difference between the simple (and
controlled) absence of assertions and needing to either conclude that
the assertion is false (via inference) or having to express it
explicitely (i.e. I. versus II. From the above example with the patient
and his/her headache).  Note, I'm pushing back slightly on what often
seems like unadulturated dogma, not trying to be dogmatic myself :)

Well, OK, but give me a little bit of CL/IKL slack and I'll axiomatize your carefulness principle for you so that your nurse doesn't have to do any extra work. Let suppose there are some data recording protocols which work the way you sketch above. We can actually describe them:

(forall ((X protocol) (D Dataset) P)(if

        (and (ama:CompletableProtocol X)(ama:ConstructedUsing X D)(:CompletionPropIn P X))

        (forall ((s charseq))(if (P (s))(member s D) ))

))

                      

Now all your dutiful nurse has to record is that her records were constructed using a protocol which is Completable wrt the property of having a headache, which is no doubt itself recorded in the home ontology describing the protocol:

LowCostMeds:method1 :a ama:CompletableProtocol .

LowCostMeds:HasAHeadache :CompletionPropIn LowCostmeds:method1 .

so the nurse just has to record her data in an RDF graph with a URI like

SacreBleu:1263Xf5-220807

and include in the graph the self-referring assertion

SacreBleu:1263Xf5-220807 ama:ConstructedUsing LowCostMeds:method1 .

(which is actually going to be done by her computer) and now all the no-headache conclusions follow by classical reasoning.

        (either having a large amounts of assertions about
>class disjointedness, etc. or requiring explicit assertions
>about the absence of data)
>
>
>You have to say what is true in order to draw reliable
>conclusions from it.

Or, alternatively, you control the process of how the data is populated
in order to draw (simple) conclusions that don't require significant
inference. No?

Well, provided that you somehow record the fact that this process was used, so that the right conclusions can be drawn from the data. And then, if you do this right (cf above) its all classical reasoning again.

> >This can be done in tedious ways or, with
> >the right notations and conventions, more compactly. You
> are
> >reacting against some of the more
> tedious notational results
> >of using simple textbook logics. But if you want to be able to
> >infer, from the fact that something is in a class A, that it
> >is not in another class B, then you must have some way to know
> >that A and B are disjoint. Because if they aren't, that
> >conclusion is not valid. No amount of grumbling about
> >classical negation is going to get over that basic fact.
>
> I'm not grumbling about it, I'm just trying to demonstrate that
> there
> are situations where default negation (by itself) is a responsible
> means
> to conclude the absence of some assertion.

I don't agree. If you do the data recording responsibly, it always comes out as classical reasoning. And its never responsible to use NAF unless you know that the data justifies closed-world reasoning. BUt if you know this, it should be recorded somehow as part of the data: and if it is, then the reasoning isn't using NAF any more, but classical negation. Operationally it feels the same, but its all classical logic (which is a very nice thing, btw, as this is the only logic with a universally agreed semantics.)

Pat

-- 

---------------------------------------------------------------------
IHMC               (850)434 8903 or (650)494 3973   home
40 South Alcaniz St.       (850)202 4416   office
Pensacola                 (850)202 4440   fax
FL 32502                     (850)291 0667    cell
http://www.ihmc.us/users/phayes      phayesAT-SIGNihmc.us
http://www.flickr.com/pathayes/collections

_________________________________________________________________
Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/  
Subscribe/Config: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/  
Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/ 
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx    (01)