W3C home > Mailing lists > Public > www-rdf-logic@w3.org > May 2004

Re: Concrete and abstract domains disjointness

From: <Bernardo.Cuenca@uv.es>
Date: Mon, 10 May 2004 19:24:16 +0200 (CEST)
To: Pat Hayes <phayes@ihmc.us>, www-rdf-logic@w3.org
Message-ID: <5374587163cuengrau@uv.es>


 Hi,

 The integration of datatypes in OWL DL is based on the so-called type 
system approach for integrating datatypes in description logics. The 
main motivation behind this approach is to combine an expressive 
description logic with a type system in such a way that reasoning 
remains decidable and such that DL reasoners can be easily extended to 
handle datatype information. Other main reason is modularity: the DL 
reasoner treats the type checker (the type system reasoner) as a black 
box that, given a conjunction of datatypes is able to determine whether 
the conjunction is or not satisfiable.

 In order to achieve these goals, 
  - The abstract and concrete domains must be kept disjoint and the 
concrete domain represents the domain of all the datatypes in the type 
system
  - The Description logic is enriched with a new set of constructors 
that allow to represent the information involving datatypes. These 
constructors are the restrictions on datatype properties (existential, 
value and number restrictions). Datatype properties must also be kept 
disjoint from the object properties 
 - Only unary predicates can be used in those restrictions (actually 
this condition can be relaxed and the datatype constructors in the DL 
language can be extended such that n-ary datatype predicates can be 
used)
 - The datatype predicates (for ex. greater or equal than,...) are 
supposed to be defined by the type system, and not by the DL language
 

 There are other approaches for integrating datatypes in description 
logics. For example, the concrete domain approach allows the use of 
more expressive constructors in the DL. In OWL you cannot represent 
concepts like the set of people whose salary is higher than the salary 
of his/her parents. Actually, the datatype support in OWL is fairly 
inexpressive. The concrete domain approach provides increased 
expressivity but the integration of expressive description logics with 
datatypes following that approach happens to be undecidable.

 For a detailed discussion on datatype integration in DL, you can visit 
Carsten's Lutz and Jeff Z. Pan home pages. 

 Regards

 Bernardo Cuenca Grau
 Maryland Information and Network Laboratories
 College Park, Maryland, USA

> 
> >Hello,
> >
> >Can somebody explain some formal reason why the concrete and abstract
> >domains (i.e. the datatype and individual sets) have to be disjoint 
in OWL
> >DL?
> 
> The rationale that was offered at the time was basically that 
> datatypes can introduce arbitrarily complex conditions on class 
> definitions, so that to allow datatyped values into a non-datatype 
> class means that a (complete) reasoner might have to incorporate 
> arbitrarily complex reasoning about domains defined by external means 
> and this would infect the entire DL reasoning, with potentially 
> disastrous effects on efficiency and even decideability. For example, 
> allowing xsd:integer values into normal classes in effect adds 
> arithmetic to the DL, since these values are required by the semantic 
> conditions to be real, honest-to-God integers, and it is then 
> possible to set up restrictions so that to determine class membership 
> might require arbitrarily complex arithmetic calculations, eg the 
> identity of two individuals might depend on whether a complex 
> diophantine equation has one or two solutions. For a more prosaic 
> example, the RDF built-in datatype rdf:XMLLiteral would require that 
> every reasoner be able to deal with class reasoning over the domain 
> of normalized XML documents, so that identity might depend on whether 
> or not two XML documents normalized appropriately, eg  if {a, b, 
> XMLdoc1, XMLdoc2} has cardinality 3.
> 
> By restricting datatypes to datatype classes, the problem is kept 
> within manageable bounds and can often be farmed out to external 
> reasoners specialized for each datatype, since datatype reasoning can 
> be largely kept separate from reasoning about individuals.
> 
> >Is there a description logic that drops this restriction?
> 
> I do not know, but others might.
> 
> I think that this is not really so much a DL-specific restriction as 
> one which was imposed on what might be called general 
> reasoner-engineering grounds. That is, one could make out a case for 
> this style of restriction independently of the logical nature of the 
> non-datatype part of the system. The SWRL proposal for example treats 
> datatyping as a matter to be handled by 'built-ins', ie function 
> calls to external evaluators, which is a similarly motivated 
> separation of datatype value handling from (in this case) rule 
> processing.
> 
> Pat Hayes
> 
> >
> >
> >Many thanks,
> >
> >Dimitrios A. Koutsomitropoulos
> >
> >Computer & Informatics Engineer
> >Postgraduate Researcher
> >High Performance Information Systems Laboratory
> >
> >  Contact
> >  e-mail: kotsomit@hpclab.ceid.upatras.gr
> >  work:  +30 2610 993805
> >  fax:    +30 2610 997706
> >  http://www.hpclab.ceid.upatras.gr
> 
> 
> -- 
> ---------------------------------------------------------------------
> IHMC	(850)434 8903 or (650)494 3973   home
> 40 South Alcaniz St.	(850)202 4416   office
> Pensacola			(850)202 4440   fax
> FL 32501			(850)291 0667    cell
> phayes@ihmc.us       http://www.ihmc.us/users/phayes
> 
> 
Received on Monday, 10 May 2004 13:24:59 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 2 March 2016 11:10:42 UTC