Re: OWL 2 SS&FSS spec. - overly overloaded grammar/object terminology

Dear Ian,

Ian Horrocks wrote:
> Dear Daniel,
> Thank you for your comment
> <>
> on the OWL 2 Web Ontology Language last call drafts.
> The structure of OWL ontologies is defined using UML. In the text, 
> Functional Syntax is used to refer to the UML structures. 

Where is the correspondence between the Functional Syntax and
the UML structures specified?

 > The purpose of
> the narrative explanations and examples is to provide informal and 
> intuitive explanations. 

If the correspondence between the Functional Syntax and the UML
structures is not defined elsewhere, then those "narrative"
explanations need to be normative definitions, don't they?
(Something does.)

(Actually, see the "** Ah--maybe that points out the problem ..." part

> This may sometimes involve relatively informal 
> use of the Functional Syntax, but we feel that this informality is 
> justified in making the document more approachable. 

It might seem more approachable at first glance, but the multiple
approximations in the wording actually make it much _harder_ to
follow--the reader has to disambiguate many terms even in a single

If the text were a little more wordy but more accurate (e.g.,
"the class denoted by the class expression 'xxx( yy )' contains
individuals" rather than "the class expression 'xxx( yy )' contains
individuals"), then if one didn't understand a sentence the first
time, one could simply re-read it and pay attention to every wording
step along the way.

However, the way things are now, when you try to re-read things
_more_ carefully to tease out the intended meaning, you see more and
more  ambiguity, and can be _less_ and less sure about what each word
means and can be _less_ and less sure about what the specification
really meant to specify.

 > Those needing formal
> definitions can and should refer to the UML and to the "Complete 
> Grammar" Appendix [1].

But the Complete Grammar appendix specifies only the _syntax_ of the
Functional Syntax, and not its semantics--the correspondence to the
objects specified in UML.  If that appendix is the _only_ normative
definition of the Functional Syntax, then obviously something is
missing in the specification.

> We were aware of the possible confusion between UML classes/instances 
> and ontology classes/instances and were careful to ensure that we 
> explicitly say "UML Class" or "instance of UML Class" whenever we are 
> referring to the former. 

Doesn't your next paragraph (below) contradict that?  (You say (below)
that "class expression" in the quote from the spec refers to instances
of the UML class, but the quote from the spec shows that it does not
in fact explicitly say "UML Class" or "instance of UML Class.")

 > We now explicitly mention this, as well as
> clarifying some other issues related to the use of UML, in Section 2.1 
> [2]. To review these changes please refer to the relevant diff [3].
> For example, when we say "An intersection class expression 
> ObjectIntersectionOf( CE(1) ... CE(n) ) contains all individuals that 
> are instances of all class expressions CE(i) for 1 ≤ i ≤ n", we are 
> referring to ontology class expressions (that is, instances of the UML 
> class ClassExpression), ...

That ("we are referring to ... instances of the UML class
ClassExpression") doesn't seem to be correct.  Consider the first
occurrence of "class expression" there--in what way can a class
expression contain individuals?

If that first "class expression" really does refer to an instance
of the (UML-specified) ClassExpression class, specifically, the
ObjectIntersectionOf class instance class specified by that quoted
syntax "ObjectIntersectionOf( CE(1) ... CE(n) )" then:

Such instances do _not_ contain individuals:

- The (UML-specified) ObjectIntersection class has no aggegration or
   composition relationship, or even any associations with, the
   (UML-specified) Individual class, so the (UML-level)
   ObjectIntersection class does not in any sense "contain" any
   UML-level individuals.

- Clearly, that _UML_-level class instance does not contain a
   _syntax_-level string or an _ontology_-level individual (an
   individual contained in the class described by the class

Isn't it really the (ontology-level? logic-level?) _class_
represented by _class_expression_ (the (UML-level) ClassExpression
instance and/or the (syntax-level) ClassExpression non-terminal
instance) that _contains_ individuals?

** Ah--maybe that points out the problem more clearly:

It's _not_ the ambiguity between the level of the UML and the level
of the syntax (which closely follows the UML) that is the main
problem (and possibly that ambiguity isn't a problem, since the
syntax and the UML correspond closely).

The main problem is the ambiguity between the ontology-statement
level (i.e., the syntax, the UML classes, and the represented
axioms/etc.) and the level of the classes, individuals, etc.,
described by the ontology-statement level.

That's why "class expression ... contains individuals" doesn't
make sense:  A class expression describes/denotes/etc. a class, and
a class can contain individuals, but the class expression doesn't
contain any individuals.  Writing that one does causes confusion.

> [3] 
> Please acknowledge receipt of this email to 
> <> (replying to this email should 
> suffice). In your acknowledgment please let us know whether or not you 
> are satisfied with the working group's response to your comment.

I think* I agree with the changes reflect in the differences shown at

(* allowing for having misread the wording since I'm looking at it
with the HTML tags visible)

I think I'm (at least partially) satisfied regarding the ambiguity
between the syntax and UML levels.

I'm not yet satisfied regarding the ambiguity between the
UML level (syntax/UML/constructs) and the logic level (classes,
individuals, etc.).

(Plain text sometimes corrupted to HTML "courtesy" of Microsoft Exchange.) [F]

Received on Wednesday, 16 September 2009 17:02:48 UTC