Re: Cardinality in the open world

I'm going to presume throughout that we're talking OWL DL. I don't  
believe there are any difficulties with transferring it to OWL Full,  
but hey.

On Apr 8, 2005, at 9:44 PM, Paul Gearon wrote:

> On 08/04/2005, at 10:49 PM, Bijan Parsia wrote:
[snip]
> Now that I've finished being flippant, I still don't accept a "type"  
> of "minCardinality(1)", at least in this system (OWL)

This is an insignificant syntactic/notational variant.

>   I do however, accept a type of "Restriction" which "has a" minimum  
> cardinality of 1.

What's the difference.

> Since restrictions are used to describe the class,

What class?

>  then I took this to be TBox.

You're still wrong here.

http://www.w3.org/TR/2004/REC-owl-semantics-20040210/syntax.html#2.2

Even in owl lite:
	
	type ::= classID
        		| restriction

So an individual can be of type restirction without an intervening  
class definition.

"In the OWL DL abstract syntax types can be general  descriptions,  
which include class IDs and OWL Lite restrictions as well as other  
constructs
type  ::= description "

from:
	http://www.w3.org/TR/2004/REC-owl-semantics-20040210/ 
syntax.html#2.3.2.2

"description ::= classID
             | restriction
             | 'unionOf(' { description } ')'
             | 'intersectionOf(' { description } ')'
             | 'complementOf(' description ')'
             | 'oneOf(' { individualID } ')'"

So an individual can directly be "of type" an arbitrary class  
expressions.

Thus class expressions can be part of abox assertions.

Class expressions are also part of tbox expressions. The tbox consist  
of definitions and constraints. These are all universally quantified  
conditionals.

[snip]
>> 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.

http://www.w3.org/TR/2004/REC-owl-semantics-20040210/syntax.html#2.1

"""An OWL ontology in the abstract syntax contains a sequence of   
annotations, axioms, and facts....Ontologies incorporate information  
about classes, properties, and individuals"""

So, in OWL, the ontology is not the TBox.

> Unfortunately, OWL mixes this a little, because statement like:
>   <MyClass> <rdf:type> <owl:Class>
> are obviously ABox.

In all DL systems they are.

> In fact, since all of OWL gets written in RDF it's like expressing  
> TBox information with ABox assertions.

That's a separate problem. In OWL DL (in the reverse of the  
transformation to triples) all those syntax triples disappear. The abox  
corresponds to:
	http://www.w3.org/TR/2004/REC-owl-semantics-20040210/syntax.html#2.2
the tbox to:
	http://www.w3.org/TR/2004/REC-owl-semantics-20040210/syntax.html#2.3

> Anyway, I thought that defining a class as a subtype of a restriction  
> with cardinality was all TBox.

Yes. Fortuneately in all my abox examples I didn't do taht.

> 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 can directly assert a class expression of an individual.

In either case, it doesn't matter. I can mix ground and universally  
quantified statements freely. This is normal in first order logics. In  
most logics, actually.

> I do concede that the OWL statement asserts a property  
> (minCardinality) on the restriction,

You conflate syntax with significance. In OWL DL that "asserting a  
property" has no assertional significance. In owl full, of course, it  
does.

>  but I was under the impression that the assertion of this property  
> was just the RDF way of expressing a higher order concept.

Er....No. OWL is first order all the way. Even owl full.

> Am I wrong in thinking that it is possible to express TBox information  
> in RDF?

Well, in OWL DL, the tbox *and* class expressions are *encoded* in RDF  
(I wouldn't say they are *expressed*). In OWL Full, they are also so  
encoded, and their encoding also has assertional force.
[snip]

> 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.

Perhaps not every interlocutor you enconuter enjoys being manipulated,  
or enduring being presumed to require goading to produce "solid  
responses", esp. when they have shown good faith with extensive  
answers.

> (It's also cathartic to vent my frustration in that way).  :-)

Many of us vent. But you persist in venting throughout a discussion.

> 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,

I really wish you'd make the "next leap". I can get inconsistency even  
if all my classes are satisfiable. Take the following tbox statements:

B disjointWith A.

Take the following two abox statements.

x:B.
x:A.

There are no unsatisfiable classes in my ontology. Strangely enough my  
ontology is inconsistent!!!

How do you explain this puzzling fact?

Now imagine just this abox:

x:min(3,P)
x:max(1,P)

(This is DL notation, it is equivalent to x type owl:restriction blah  
blah blah.

I can use abstract notation:

Individual(x type(restriction(P, minCardinality(3) ))
Individual(x type(restriction(P, maxCardinality(1) ))

Note that I've only used facts, no axioms.

>  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).

You do need further constraints.

You do not have a closed world.

It is not like XML schema or most data validation constraints.

> 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.

You can, but not like you thought. This is in fact how reasoners work  
(for some value of "some kind of counting mechanism).

> The final mechanism of entailment cannot use minCardinality either.

Oh piffle.

> 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.

Sure. But you still fail to grasp some basic points (e.g., about class  
expressions in the abox/facts).

> 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.

minCardinality is just syntactic sugar for existentials. Even  
minCardinaly greater than 1.

>  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,

Examples? I mean, I have a reasoner that can reason with all of owl (if  
not all of it at once; now that shoiq is cracked that will change).

> 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,

I would like to know the other 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.

Well since that is *still not true*, and since that was more than you  
originally thought...well...you see where I'm going :)

> 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?

If we're still trying to get you to understand the logic, I strongly  
suggest you read chapter 2 of the DL handbook, to clear up your  
abox/tbox/class expression confusions.

It will also explain some stuff about how to reason with cardinality  
restrictions (if I recall correctly).

If you want modeling discussions, we can go there.

Cheers,
Bijan Parsia.

Received on Saturday, 9 April 2005 03:54:26 UTC