W3C home > Mailing lists > Public > public-owl-wg@w3.org > November 2007

Re: UFDTF Metamodeling Document

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Fri, 30 Nov 2007 07:58:56 -0500 (EST)
Message-Id: <20071130.075856.59097684.pfps@research.bell-labs.com>
To: conrad.bock@nist.gov
Cc: public-owl-wg@w3.org

From: "Conrad Bock" <conrad.bock@nist.gov>
Subject: RE: UFDTF Metamodeling Document
Date: Thu, 29 Nov 2007 15:49:19 -0500

> Peter,
> 
>  >  > I should have said work in the OWL 1 tooling.  
> 
>  >  Well, perhaps it would be better to say that this works with tools
>  >  that handle supersets of OWL DL or tools that handle OWL Full.
>  >  However, although existing practice on extensions can be a good
>  >  input to extending a recommendation, there may be good reasons not
>  >  to use the this practice.
> 
> OK, I just would want to avoid people concluding that the DL reasoners
> won't work on this superset of DL, which would be a natural conclusion.
> They work and to mind its reasonable that they do, see below.
> 
> As long as we're being precise in wording, I wouldn't say a language has
> "metamodel facilities" if it doesn't have these capabilities.  

Which capabilities?

> Simply
> making direct instances of owl:class, then instantiation those instances
> is not metamodeling.  The "meta" means to to use a language to model
> other languages, including by extending other languages.

Well, then OWL Full doesn't have metamodelling.  Perhaps some other term
should be used, but metamodelling has been used for quite some time in
KR for the ability to treat classes (and properties) as objects.

>  >  That would be useful, but it would also be useful to know which
>  >  version of Protege, Racer, Pellet, TopBraid, and JENA are involved,
>  >  and what is being passed to the reasoner.  (For example, it may be
>  >  that Protege is converting to OWL DL and thus that Racer isn't
>  >  handling this ontology.)
> 
> See http://www.w3.org/2007/OWL/wiki/OWLMetamodelingExample1.

Thanks, I've run this through Protege directly.  I'll send out a
separate message on it.

>  >  > The tools behave how I'd expect them to, ie, instances of
>  >  > subclasses of owl:Class are instances of owl:Class, so it's
>  >  > natural that they'd behave consistently with "direct" instances of
>  >  > owl:Class.
> 
>  >  Well, they are certainly not behaving how I expect them to.  I
>  >  expect OWL DL tools to report "syntax" violations when given inputs
>  >  that are not in OWL DL.
> 
> Sure, but I would claim the standard overreached.  There's no reason for
> OWL to declare that all extensions of DL are not DL, when it has no way
> of knowing what those extensions are.  Some of them might well be
> outside DL, others not.  The tools vendors fortunately ignored or didn't
> notice this overly broad restriction in the standard.

Huh?   There is indeed a need for the OWL DL recommedation to state what
is in OWL DL and what is not.  If the OWL Dl recommendation doesn't say
this then how is one to know how to write ontologies in OWL DL?

>  >  Well, to determine whether the input can be correctly translated
>  >  into a DL style, there would have to be some determination of
>  >  whether the initial ontology made semantic sense.  This could
>  >  involve lots of things, including checking that values of isAbstract
>  >  are acceptable.
> 
> But the extensions are the language extender's problem, not the DL
> reasoner's.  The language extender should provide checking and
> translation to DL as part of supporting the extension.

I'm not saying that the checking is the province of any DL reasoner.
Depending on the specifics of the extension, it may be possible to
employ a DL reasoner for some DL to perform the check, or it may be
necessary to use a more powerful reasoner, or it may be possible to use
some simpler method, or it may even be impossible to determine.

>  >  > It would be handy, of course, to apply DL at the "meta" level to
>  >  > check that instances of owl:Class or its subclasses satisfy their
>  >  > types, but it wasn't what is immediately needed.
> 
>  >  Why not?  Consider an ontology in which the meta-level was
>  >  semantically incoherent.  Should this incoherency be ignored?  If
>  >  so, then what is the use of the metalevel?  If not, then the
>  >  checking could be very complicated.  Even picking out simple
>  >  patterns/languages for which it is easy to check inhcoherency is not
>  >  easy.  (Just look at the early history of Description Logics for
>  >  several examples.)
> 
> Sure it might be needed, just not as the highest priority, at least as
> far as my applications are concerned.  And see above about whose
> responsibility checking extensions is.

Well, yes it is the responsibility of the language designer to pick a
reasonable language.  However, it can easily turn out that even simple
meta-level languages require complex reasoning.


>  >  >  >  	SubClass( <umlclass> ... )
>  >  >  >  	ClassAssertion( <umlclass> uml:Class )
> 
>  >  >  >  You can even add information to the UML classes by adding
>  >  >  >  information to the ClassAssertion axiom.
> 
>  >  > What is "..." in the SubclassOf axiom?
> 
>  >  The necessary condition for <umlclass>, as in the OWL 1.1 
>  >  specification.
> 
> Where is the axiom for uml:class being a subclass of owl:class?  That
> would be metamodeling, see above.

There is none in either OWL DL or OWL 1.1.  Why does there need to be
one?  If the class has visibility on both the instance and the class
level then that is metamodelling also, of a sense.

> Conrad

peter
Received on Friday, 30 November 2007 13:15:31 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Tuesday, 8 January 2008 14:13:27 GMT