My deepest regards and _expression_ of thankfulness for the understanding (loosely caused Knowledge) and wisdom expressed. I was honored to personally meet you and also have Dinner with you at Ontology Summit 2008 (alas no camera with me to capture). It will take me long time to assimilate your examples and comparison with CL, CyC, XCL and CLIF, as well as comments regarding n-tuples.
Also my appreciation of comments from others on this thread, including Pat, Ken, Paola and Bisu Dutta.
Without getting caught up in details there are two observations:
- Imagine the knowledge hidden behind Ranganathan's logic (that brought his system at least as great example as mentioned by most readers), if we can understand that line of thinking, it will bring more discoveries e.g. like Leibnitz's, or like numbers, as well as show us the Reasoning, logic, etc. inherent in cultural concepts today that have started to surface as contributions in Software (over the past decade) and in Sciences through the past century when the West has had increasing appetite for use of products and processes of Eastern culture.
- If we could harvest those concepts in Ontology, reasoners and inference engines, we could perhaps benefit in emerging areas that can help analyse n-tuples, and simultaneous multiple relationships among "Things" that would then represent objects and relationships akin to neural connections that hopefully provide us deeper understanding about nature than single inheritance limitations.
More on this as I continue to read and comprehend your references on Ranganathan and multiple contributions made by you.
(Dr. Ravi Sharma)
313 204 1740 Mobile
I received an offline note about Ranganathan's colon classification
and the reasons why it has not been widely used. I recommended
Common Logic as a simpler system, but I also realize that many
people consider logic to be "difficult". But whenever anybody
tries to develop a "simpler" system, they usually create something
that is much harder to use than the so-called "difficult" logic.
To illustrate the principles, I'll use some examples from the slides
that I presented at the tutorial on Common Logic at the SemTech'08
conference in San Jose:
Common Logic: A Framework for a Family of Logic-Based Languages
The first slide has the title "How to say 'A cat is on a mat.'"
It shows Frege's original Begriffsschrift, Peirce's algebraic
notation, and Peano's variation of Peirce's notation, which has
become the modern predicate calculus.
Since people complained that logic was too "hard", the gang that
gave us SQL decided to "simplify" the notation. My second slide
begins with that so-called "simplification":
SELECT FIRST.ID, SECOND.ID
FROM OBJECTS FIRST, OBJECTS SECOND, SUPPORTS
WHERE FIRST.TYPE = "Cat"
AND SECOND.TYPE = "Mat"
AND SUPPORTS.SUPPORTER = SECOND.ID
AND SUPPORTS.SUPPORTEE = FIRST.ID
The SELECT line indicates that the ID columns of two tables are
being selected. The FROM line says that the first comes from
a table named OBJECTS, the second comes from the same OBJECTS
table, and the SUPPORTS table is also being used.
The four lines beginning with WHERE specify a statement in
a version of first-order logic that specifies how the two IDs
are related: The type of the first is "Cat", the type of the
second is "Mat", the supporter of the SUPPORTS table is the
second ID, and the supportee of the SUPPORTS table is the first ID.
For comparison, following is a statement in the Common Logic
Interchange Format (CLIF):
(exists ((x Cat) (y Mat)) (On x y))
This sentence says that there exists an x of type Cat and a y of
type Mat where x is on y. For comparison with the SQL statement,
the relation (On x y) could be written (Supports y x). The ID and
TYPE, which name columns of the OBJECT table in SQL, are represented
in CLIF by variables (ID) and restrictions on the variables (TYPE).
A logically equivalent notation is the Conceptual Graph
Interchange Format (CGIF):
[Cat *x] [Mat *y] (On ?x ?y)
This statement is shorter because the quantifier "there exists" is
the default. The first concept [Cat *x] says "There is a cat x",
the concept [Mat *y] says "There is a mat y", and the relation
(On ?x ?y) says "x is on y".
At the bottom of that slide is an example from an English-like
notation called Common Logic Controlled English (CLCE):
A cat is on a mat.
This looks like English, but it has a formally defined mapping
to either CLIF or CGIF notation.
Beginning with slide #15 is an example of medical English, which
was used in a conference on medical informations as an exercise for
comparing several different notations. What follows is the mapping
to CLCE, and from CLCE to both CLIF and CGIF.
The process of doing the mapping sounds complicated, and it takes
several slides to explain the details. Finally, slide #21 shows
the complete mapping to CLCE, slide #22 shows the CLIF equivalent,
and slide #23 shows the CGIF equivalent.
Notice that there are many details, even in the CLCE statement,
that require some explanation. However, the person who mapped
the same English to RDF and OWL said that he wasn't sure whether
he could even do it, but by defining a lot of intermediate forms,
he was finally able to express it in OWL. But it wouldn't fit
on one slide. He didn't attempt to explain it, but he did scroll
through page after page after page of angle brackets.
The irony is that RDF originated from an attempt by R. V. Guha
(the former associate director of the Cyc project) to develop
a simplified notation that would be easier to use than the
version of logic used in Cyc. In the late 1990s, Guha worked
with Tim Bray (one of the people who collaborated on the
development of XML) to represent simple "triples" in XML.
That became RDF.
Unfortunately, the notation Tim Bray defined, which is still used
today, was vastly more complex than it should have been. Tim
admitted and apologized for his mistake:
As Tim says, "It's the syntax, stupid!", and he adds:
Speaking only for myself, I have never actually managed to write
down a chunk of RDF/XML correctly, even when I had the triples
laid out quite clearly in my head. Furthermore -- once again
speaking for myself -- I find most existing RDF/XML entirely
unreadable. And I think I understand the theory reasonably well.
The basic idea of RDF was to represent triples of Resource, Property,
Value. Any such triple can be represented in CLIF or CGIF as
(Property Resource Value)
All three URIs as used in RDF are valid name sequences in CLIF or CGIF.
Any or all of the other information expressed in RDF can be represented
in both CLIF and CGIF, either in structured comments or in additional
relations that relate the triples to each other or to other resources.
For anyone who wants to use the XML tools, the ISO standard for Common
Logic also defines XCL as a third dialect that can be mapped directly
to or from CLIF and CGIF. Furthermore, XCL is far more compact than
RDF, and it supports a cleaner, simpler, more expressive, and more
efficient logic than the combination of RDF(S), OWL, RuleML, and SPARQL.
Finally, CLIF, CGIF, and XCL support full n-tuples. Therefore, any
SQL table can be directly downloaded to or uploaded from Common Logic
in any of those three notations. Furthermore, CL in any of those
notations can be used to write rules to specify whatever translations
are needed to relate any or all of the above notations to one another
For further references, see slide 28 of my tutorial.
Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx (01)