[Top] [All Lists]

Re: [ontolog-forum] Universal and categories in BFO & DOLCE

To: "'[ontolog-forum] '" <ontolog-forum@xxxxxxxxxxxxxxxx>
Cc: rick@xxxxxxxxxxxxxx
From: "Rich Cooper" <rich@xxxxxxxxxxxxxxxxxxxxxx>
Date: Wed, 7 Sep 2011 13:02:14 -0700
Message-id: <51A37EE2FB6B4F1BAE4DBF073874DD38@Gateway>

Dear John,


But all such tools result in a HIERARCHY, not a LATTICE.  I want a method that works as a LATTICE of types as in ontology. 


My question was how to find the interesting combinations of old types so that MULTIPLE INHERITANCE can be construed without inconsistency. 


Consider words like get, set, put which have multiple conceptual counterparts, I think you mentioned there are more than 600 WordNet entries for these polysemous three.  A single TYPE object designed to implement PUT, in all its polysemous glory, could be constructed from MULTIPLE other object TYPEs that represent the various semantic interpretations normally given to that word, so that a SINGLE TYPE can interpret all 600+ meanings by determining the context in which said PUT is used, and implement its proper semantic interpretation by choosing which edge in the lattice to traverse to call the specialized subTYPE with the correct semousness. 


Can you explain how such a SINGLE TYPE can be constructed without inconsistencies?





Rich Cooper


Rich AT EnglishLogicKernel DOT com

9 4 9 \ 5 2 5 - 5 7 1 2


-----Original Message-----
From: ontolog-forum-bounces@xxxxxxxxxxxxxxxx [mailto:ontolog-forum-bounces@xxxxxxxxxxxxxxxx] On Behalf Of John F. Sowa
Sent: Wednesday, September 07, 2011 11:02 AM
To: ontolog-forum@xxxxxxxxxxxxxxxx
Cc: rick@xxxxxxxxxxxxxx
Subject: Re: [ontolog-forum] Universal and categories in BFO & DOLCE


On 9/7/2011 12:31 PM, Rich Cooper wrote:

> Generalization removes a property or method from the old type

> to create a new type, while specialization adds a property or

> method to the old type to create the new type, by definition.


Those two operations can be expressed in logic.  For example,

the property P could be defined as a conjunction of other properties

(or attributes or features or facets or whatever you want to call them):


    P = p1 & p2 & ... & pN


If you remove a property from P, you get a more general property Q

that is implied by P:  If P, then Q.


If you add another property to P, you get a more specialized

property R that implies P:  If R, the P.


Basic principle:  More general properties are true of a larger

number of cases, and more specialized properties are true of

a smaller number of cases.


The more special case implies the more general case.  But you

can use logics with more operators than just conjunction.


> ... many programming languages (Delphi) also restrict type

> constructors to only have singular inheritance which avoids

> the very possibility of introducing consistency errors.


That is a brute-force method.  It's better to use development

tools that are guaranteed to ensure all and only the valid

generalizations.  There are many such tools.


> But what about languages with multiple inheritance (C++ etc)

> where the new type is a combination of old type properties

> and methods, given that the specific new type definition

> ALSO leaves out some of the properties and methods of the

> old types?  That would make a lattice rather than a hierarchy.

> The problem is that the constructors might introduce

> inconsistencies...


What you need are better development tools that don't introduce

inconsistencies *and* can detect and eliminate any inconsistencies

that may be lurking.


If you recall the earlier discussions with Rick Murphy, he was

recommending methods based on intuitionistic logic that generate

combinations that are computationally efficient to check.


Description logics use a different choice of operators that

also generate combinations that can be checked automatically.


Another computational method, which uses a logic that is a subset

of both DLs and intuitionistic logic, is Formal Concept Analysis

(FCA).  The only operator that FCA methods use for defining

properties is conjunction.  That creates a very a simple logic

that supports highly efficient tools.


In fact, many people use FCA tools to verify that ontologies

defined in OWL are consistent.  But you can also use FCA tools

to *generate* the definitions automatically.  See




You can find more info about using FCA to check consistency

of OWL ontologies by typing three keywords to Google:


    FCA OWL concept


You need the word 'concept' to avoid many extraneous hits.


Important caveat:  these logics (DLs, intuitionistic logic, and FCA)

are *subsets* of FOL.  They are useful for defining the hierarchy

(whether you call it type, concept, generalization, or subsumption).

But they are *not* general purpose knowledge representation languages.

You need more general logics in order to specify everything you need

to say (or to program).





Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/ 

Config Subscr: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/ 

Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx

Shared Files: http://ontolog.cim3.net/file/

Community Wiki: http://ontolog.cim3.net/wiki/

To join: http://ontolog.cim3.net/cgi-bin/wiki.pl?WikiHomePage#nid1J


Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/  
Config Subscr: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/  
Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/ 
To join: http://ontolog.cim3.net/cgi-bin/wiki.pl?WikiHomePage#nid1J    (01)

<Prev in Thread] Current Thread [Next in Thread>