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
Sincerely,
Rich Cooper
EnglishLogicKernel.com
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
http://www.upriss.org.uk/fca/fca.html
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).
John
_________________________________________________________________
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