But all such tools result in a HIERARCHY, not a
LATTICE. I want a method that works as a LATTICE of types as in
My question was how to find the interesting
combinations of old types so that MULTIPLE INHERITANCE can be construed without
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 AT EnglishLogicKernel DOT com
9 4 9 \ 5 2 5 - 5 7 1 2
[mailto:ontolog-forum-bounces@xxxxxxxxxxxxxxxx] On Behalf Of John F. Sowa
Sent: Wednesday, September 07, 2011 11:02 AM
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
> method to the old type to create the new type, by
Those two operations can be expressed in logic.
the property P could be defined as a conjunction of
(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
a smaller number of cases.
The more special case implies the more general case.
can use logics with more operators than just
> ... many programming languages (Delphi)
also restrict type
> constructors to only have singular inheritance
> the very possibility of introducing consistency
That is a brute-force method. It's better to use
tools that are guaranteed to ensure all and only the
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
> and methods, given that the specific new type
> 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
What you need are better development tools that don't
inconsistencies *and* can detect and eliminate any
that may be lurking.
If you recall the earlier discussions with Rick
Murphy, he was
recommending methods based on intuitionistic logic
combinations that are computationally efficient to
Description logics use a different choice of operators
also generate combinations that can be checked
Another computational method, which uses a logic that
is a subset
of both DLs and intuitionistic logic, is Formal
(FCA). The only operator that FCA methods use
properties is conjunction. That creates a very a
that supports highly efficient tools.
In fact, many people use FCA tools to verify that
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
of OWL ontologies by typing three keywords to Google:
FCA OWL concept
You need the word 'concept' to avoid many extraneous
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
But they are *not* general purpose knowledge representation
You need more general logics in order to specify
everything you need
to say (or to program).
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