Re: Cardinality in the open world

On 08/04/2005, at 10:49 PM, Bijan Parsia wrote:
>>   The open world assumes that they could exist.  ie. the existence of 
>> these statements is unknown.
>
> Er....*extensions* to the current kb (i.e., things not in the 
> deductive closure) don't matter to determining the consistency of the 
> kb. How could they?

Well up until my last email I thought they could.  I understand better 
now.

>>>> True.  However, I would distinguish that as an inconsistency in the 
>>>> TBox data.
>>>
>>> But it can occur where there is no tbox.
>>>
>>> 	a:minCard(1)
>>> 	a:maxCard(0)
>>>
>>> No tbox. (The ":" means "type"). It's awkward to write this in RDF 
>>> or RDF/XML, but so much is :)
>>
>> Now this I don't understand.  In OWL the domain of minCardinality is 
>> a Restriction.
>
> And, if we're going to suffer with that syntax, a Restriction is a 
> Class, so something can be of type cRestriction.
>
>> Saying something has a "type" of minCardinality(1) makes no sense to 
>> my understanding of the term.
>
> Then you need some fixes to your understanding :)

OK then... fix it.  :-)

Now that I've finished being flippant, I still don't accept a "type" of 
"minCardinality(1)", at least in this system (OWL).  I do however, 
accept a type of "Restriction" which "has a" minimum cardinality of 1.

Since restrictions are used to describe the class, then I took this to 
be TBox.

The remainder of the email is repeating the same points, so I'll jump 
ahead a bit.

>> and I understand TBox information to be meta-information.  Perhaps 
>> you'd like to correct this view?
>
> I've tried :)

I hadn't seen it before now.  Only comments that something isn't TBox.

So looking at what you say at this point...

> abox == ground assertions involving one or two place formulas. I.e., 
> type assertions and role/property assertions. In your type assertions, 
> you can have arbitrarily complex formula.
>
> tbox == universially quantified conditionals and biconditionals (which 
> can contain further universal and existential quantifiers of very 
> specific sorts

I've always taken the ontology to be TBox.  Unfortunately, OWL mixes 
this a little, because statement like:
   <MyClass> <rdf:type> <owl:Class>
are obviously ABox.  In fact, since all of OWL gets written in RDF it's 
like expressing TBox information with ABox assertions.

Anyway, I thought that defining a class as a subtype of a restriction 
with cardinality was all TBox.  ie. for all instances of this class 
there exists at least x objects of this property.

It looks like a universal quantifier, which makes me think that it's 
TBox, so I can't see the conflict with what you've just said.

I do concede that the OWL statement asserts a property (minCardinality) 
on the restriction, but I was under the impression that the assertion 
of this property was just the RDF way of expressing a higher order 
concept.  Am I wrong in thinking that it is possible to express TBox 
information in RDF?

> Sigh. At this point, i really suggest you change your methodology. I 
> mean, given your misundertanding on the above point (i.e., that an 
> unstatisfiable class meant a contradictory ontology), don't you think 
> you should check the rest of your understanding? Especially when your 
> conclusion is so strong and so implausible (i.e., there's an excellent 
> prima facie case against your conclusion based on the fact that people 
> demand cardinality, systems implement it, most if not all expressive 
> dls have it, etc. etc.)
>
> What the open world doesn't give you easily is validation of your 
> data. I.e., knowing that something is card(3, P) doesn't mean you'll 
> know *which* three things  I'm Ped at. There are lots of scenarios 
> where just knowing I'm min3,P isn't going to help me (e.g., 
> determining what data goes on the wire for a web service call). This 
> is true for lots of things in owl, disjunction for example. Knowing 
> that you are male or female doesn't mean I have any knowledge of 
> *which* you are (where as, generally, knowing that a value is of a 
> union type string or integer generally *does* mean that you know, or 
> at least, can force the issue.)
>
> Notice the vast difference between "isn't useful for foo", or even , 
> "isn't useful for this wildly common and popular case foo" and "isn't 
> useful".

A lot of your email takes exception to my statement that minCardinality 
is not useful.  I'll confess that I intentionally use strongly written 
statements like "this is useless" to get a solid response.  (It's also 
cathartic to vent my frustration in that way).  :-)

I'll explain my position.  I'm interested in getting a computer to do 
with with OWL and RDF.  From a computer's point of view, there are 
three simple things it can do (there may be more complex things, but 
I'll stick to this for now).  The first is to store data.  The second 
is to check that data is consistent according to some set of rules.  
The third is to entail new data.

Storing data is easy (efficiency is another story, but that's for 
another mailing list).

Consistency is important, when possible.  So when is minCardinality 
able to be used as a tool here?   As we've discussed, it is possible to 
see that minCardinality is being used inconsistently when it is used to 
describe unsatisfiable class, and an instance of that class is 
described.  It cannot be used as a tool to discover inconsistency in 
the number of times a predicate gets used (this is contrary to the 
intuition of most people who start using OWL).

I started out with an expectation that I could use minCardinality for 
consistency checking using some kind of counting mechanism.  I've now 
come to understand that this was wrong.

The final mechanism of entailment cannot use minCardinality either.  
While this constraint tells me that something exists, it says nothing 
about *what* exists (which is a point I knew, even though you've 
repeated it here).  While useful information for a person, as a tool 
for performing an operation in a computer, I can't see where this 
knowledge takes me.

Maybe I'm being a bit closed minded.  People can use existential 
quantifiers in logic formulae to derive other expressions.  Perhaps 
that is something minCardinality can (and should) be used for now.  
That is so far beyond the scope of what I've been looking at that I 
failed to consider it.  (embarrassed grin here)

When you've said that if minCardinality is useless then so too is the 
rest of OWL, I have not found this to be the case at all.  Other 
expressions in OWL provide some very useful tools for consistency 
checking and entailment, much of which has already been defined (though 
I've seen different papers and the w3c site sometimes defining 
different things... I won't get into that today).  I was just expecting 
to use minCardinality in a similar way, but the more I looked at it, 
the less I found that I could.  I could only do consistency checks with 
it when finding things like uninstantiable classes.

Finally I came here in the hope that I would find that I was wrong, and 
that I *could* start counting statements and use this as the basis of 
consistency checking.  Instead I came here to discover I was wrong, but 
that I still can't count anything.  :-)

So now I know that minCardinality gives me some information about the 
system, but I'm not sure what I can get a computer to do with it.  
That's what I'm here to discover.  Any suggestions please?

Regards,
Paul Gearon

Received on Saturday, 9 April 2005 01:45:11 UTC