[Top] [All Lists]

Re: [ontolog-forum] Re Foundation ontology, CYC, and Mapping

To: "[ontolog-forum]" <ontolog-forum@xxxxxxxxxxxxxxxx>
From: "John F. Sowa" <sowa@xxxxxxxxxxx>
Date: Sun, 28 Mar 2010 10:39:12 -0500
Message-id: <4BAF7820.9020103@xxxxxxxxxxx>
Mike, Doug, Pavithra, and Kevin,    (01)

For the very abstract notions that arise at the upper levels of
an ontology, it is difficult to find (or coin) meaningful and
easy-to-remember words that are not already loaded with conflicting
and misleading connotations.    (02)

MB> Surely if everything in an ontology is defined as a subtype of
> the universal class of "Thing" then the whole ontology is predicated
> on the notion of individuals rather than observations.    (03)

The word 'thing' has connotations of being object-like, not event-like,
property-like, set-like, or proposition-like.  I would prefer to use
an unpronounceable symbol for the top node.    (04)

If you must have a pronounceable word, I suggest the technical term
'Entity', which has fewer familiar connotations.  When people ask for
a definition.  I recommend one axiom that is true of everything:    (05)

    (Ax)Entity(x).    (06)

This axiom is so general that it says nothing specific, but it does
provide a pronounceable term for the most general node at the top.    (07)

DF> I would use the term "Individual" at the broadest level to refer
> to things that do not themselves have instances.    (08)

The words 'individual' and 'class' create the same kinds of problems
as the word 'thing':  they are used in too many misleading and often
conflicting ways.  The word 'class' in OWL does not have the same
meaning as the word 'class' in Java or the English word 'class' in
biology, education, or set theory.    (09)

I suggest that such words be used as technical terms only for the
specific languages for which they are defined.  It's very dangerous
to equate a technical term in one language with a technical term
in another language that happens to have the same spelling.    (010)

In Common Logic, it's possible to represent the classes of languages
such as OWL with monadic relations.  But in CL, they wouldn't be
called 'classes' - they would be called 'monadic relations'.  Since
CL allows quantifiers to range over relations, the following axiom
would allow anything, including relations, to be called entities:    (011)

    (forall (x) (Entity x))    (012)

DF> The "patterns" John Sowa discusses are narrower still.    (013)

I was trying to avoid any kind of technical terminology, so I tried
to use an informal English word without stating any definition.    (014)

DF> He is referring to a subclass of Individual that has spatio-
> temporal physical extent (a highly useful subclass of Individual)
> which, also, can be sensed in some way.    (015)

Yes.  That is how I used it in that example, because I wanted to
talk about any kind of observable, and the most general word I
could think of is 'pattern'.    (016)

PK> In this example Class would be frog,  Kermit would be the
> instantiation.    (017)

In that example, I was trying to avoid as many assumptions as
possible.  I deliberately talked about the character string
"Kermit" rather than "the frog Kermit".    (018)

Using the terminology of Common Logic, I would say that the
example I gave represented the English word 'frog' by a relation
and the name 'Kermit' by the character string "Kermit".  I didn't
mention individuals, classes, or instances.    (019)

If you want to extend that example with the notion of entities
and names, I would suggest the following statement in CLIF:    (020)

    (exists (e n)
       (and (entity e) (frog e) (name e n) (spelling n "Kermit"))    (021)

Following is a very literal translation to English:    (022)

   There exist e and n, e is an entity, e is a frog,
   a name of e is n, and the spelling of e is "Kermit".    (023)

And following is a more normal kind English:    (024)

    Some entity is a frog whose name is spelled "Kermit".    (025)

The CLIF statement and both English translations avoid words
like 'class', 'individual', or 'instance'.  In fact, they
avoid all metalevel terminology of any kind.    (026)

I'm not against using metalevel terminology.  But people keep
arguing forever about classes, types, individuals, instances,
attributes, properties, characteristics, etc., etc., etc.
You can cut through all those arguments by asking two very
simple questions:    (027)

  1. How do you translate whatever you want to say to English
     (or whatever other natural language you prefer)?    (028)

  2. How do you translate the English to Common Logic?    (029)

I use Common Logic for one very important reason:  It is vastly
simpler than OWL, RDF, or almost any other notation anyone has
proposed.  I use English (or other NL) for another important
reason:  It forces people to say what they really want to say.    (030)

KDK> If you're using contexts (quads in OWL/RDF), then sets of
> observations (graphs) may also be considered as things, with
> attributed provenance.    (031)

That brings in even more terminology.  If I use CL as the lingua
franca, I would map OWL expressions to CL expressions and talk
about them using CL terminology.    (032)

KDK> ... but I think that such a powerful framework is not really
 > needed for this particular use case.    (033)

That's what everybody says when they start a new project.  They
say that they want something simple, but when the ISO standard
is written, it's as fat as the Manhattan telephone book.    (034)

Eventually, they discover that it also happens to be incompatible
with every other special standard.  As a result, the financial
department of a company can't relate their data to the departments
for engineering, manufacturing, sales...    (035)

KDK> Since the time period of that work, the financial sector has
 > been steadily adopting the XBRL standard for financial reporting,
 > which indeed provides a mechanism for a definition of every reported
 > item to be specified through a URI.    (036)

Do you remember R. V. Guha?  He was the associate director of Cyc,
which he left in the early 1990s.  (I don't know his exact reasons,
so I won't speculate why.)    (037)

But one thing he said was that the full power of Cyc was too great,
and he wanted to define something very simple that would be adequate
for most purposes.  He thought that triples were the simplest useful
notation, and he teamed up with Tim Bray to represent triples in XML.
That was the origin of RDF.    (038)

But as time went on, those triples kept getting more complex because
XML had lots of "features" that people thought were "convenient" for
some purpose or other.  Unfortunately, they "took advantage" of those
features and RDF(S) became more and more complex.  Then OWL was built
on top of RDF, and it became more complex and morphed into multiple
versions.    (039)

If you look at the Common Logic standard, it's both *more powerful*
and *much simpler* than what RDF and OWL became.  See Section 6 of the
ISO 24707 standard, which takes just 12 pages (pp. 8 to 19) for the
abstract syntax and semantics.  The full standard takes 80 pages,
but that includes 11 more pages of explanation, 50 pages to define
three different concrete dialects, and 7 pages of bibliography.    (040)

I don't recommend raw CL as the notation for every possible use.
But what I do recommend is that other notations be defined as
CL *dialects* -- i.e., anything expressed in those languages is
formally defined by its translation to CL.    (041)

Observations:    (042)

  1. Every project that starts with a "simple subset" eventually
     grows into an unmanageable blob as people add more "features".    (043)

  2. First-order logic was developed about 120 years ago by two
     logicians who were working independently of each other:
     Gottlob Frege and Charles Sanders Peirce.    (044)

  3. Although their notations looked totally different, they were
     exactly compatible:  any statement in one notation could be
     translated to a semantically identical statement in the other.    (045)

  4. The semantics of that basic FOL, which can be completely
     defined in just a few pages, has not changed in any way
     in all that time.    (046)

  5. That FOL is sufficient to specify every digital computer that
     has ever been built and every program that has every been
     written for any digital computer.    (047)

  6. No other language that has property #5 is simpler, more general,
     or more flexible.    (048)

  7. Attempts to define so-called "simpler" languages usually
     produce documents that require anywhere from 10 to 1000 times
     more pages to specify.    (049)

John Sowa    (050)

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
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx    (051)

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