Common Logic and Controlled Natural Languages

[John F. Sowa]

Folks,

In March, I used the following slides in a talk about
Common Logic:

    http://www.jfsowa.com/talks/cl_hitps.pdf
    Common Logic for Healthcare Information Technology

I received an offline note that said the slides seemed to focus
more on CLCE than on Common Logic.  But I made the point that
the primary argument is *not* for CLCE but for controlled NLs
(see the readings at the end).  And I believe that the combination
of Common Logic + controlled NLs is the "killer app" that could
make both a success:

  1. You can't have a multiplicity of controlled NLs without a
     common formalized semantics, such as CL.

  2. A methodology based on controlled NLs as the intermediate stage
     between informal specifications or requirements documents and
     the open-ended variety of special-purpose languages is essential.

As people have noticed, RDF and OWL are not readable notations,
and people have tried to invent controlled NLs that map to them.
But RDF and OWL are both very quirky languages, primarily because
they mix logic with special-purpose data structures (triples)
and special-purpose algorithms (DL proof procedures).  It's hard
to map natural languages to and from notations that have been
designed for specialized algorithms and data structures.

Of all commercial applications of logic, the Semantic Web is
tiny in comparison to the "500-pound gorilla in the room":  SQL.
Every commercial web site incorporates an SQL database, and
SQL has been the outstanding example of the commercial success
of FOL for the past 30+ years.  The WHERE clause in SQL is FOL,
but with negation as failure (as in Prolog).

One of the major problems of the Semantic Web is that it has not
been integrated with relational databases, and it is awkward to
download all or part of an SQL DB into RDF.  But if you support
full n-tuples, as in Common Logic, it is trivial to download an
SQL DB or an RDF DB into CL and to define relations between them.
Common Logic supports Unicode and the W3C naming conventions,
and it includes an XML-based dialect called XCL.

RDF and OWL can be handled as special-purpose subsets of Common
Logic (in fact, Pat Hayes, one of the chief architects of the
CL semantics was also one of the chief architects of the LBase
semantics for RDF and OWL).  Common Logic supports Unicode and
the W3C naming conventions, and it includes an XML-based dialect
called XCL.

With Common Logic as the semantic foundation and controlled NLs
plus various kinds of diagrams as the human interface, it becomes
possible to integrate the Semantic Web, SQL databases, rule-based
systems, and many other kinds of logic-based applications.

I believe that is the direction for the future.

John


---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[Jon Awbrey]

o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o

still looks like "russell on roller skates" to me ...

when are we going to start talking about a fundamental advance?

maybe next millenium ...

jon

o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o
inquiry e-lab: http://stderr.org/pipermail/inquiry/
mwb: http://www.mywikibiz.com/Directory:Jon_Awbrey
mathweb: http://www.mathweb.org/wiki/User:Jon_Awbrey
getwiki: http://www.getwiki.net/-UserTalk:Jon_Awbrey
p2p wiki: http://www.p2pfoundation.net/User:JonAwbrey
planet math: http://planetmath.org/?op=userobjs;id=15246
zhongwen wp: http://zh.wikipedia.org/wiki/User:Jon_Awbrey
ontolog: http://ontolog.cim3.net/cgi-bin/wiki.pl?JonAwbrey
http://www.altheim.com/ceryle/wiki/Wiki.jsp?page=JonAwbrey
wp review: http://wikipediareview.com/index.php?showuser=398
o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o


---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[John F. Sowa]

Jon,

That is absolutely correct:

JA> still looks like "russell on roller skates" to me ...

Common Logic is *not* a research breakthrough, and neither are
controlled NLs, SQL databases, or the Semantic Web.

But to support practical applications, we need to put those things
on roller skates instead of crutches.  For the state of the art
in 1960, see the paper by Hao Wang:

    http://www.research.ibm.com/journal/rd/041/ibmrd0401B.pdf

Wang wrote a program for the IBM 704 (a vacuum tube machine
with 144K bytes of storage), which proved all 378 theorems in
propositional and first-order logic in the _Principia Mathematica_
in 7 minutes -- an average of 1.1 seconds per theorem.

JA> when are we going to start talking about a fundamental advance?

We've been doing a lot of talking, but the people who have been
implementing commercial systems are still in the dark ages.
There are two things to do:

  1. Update commercial applications to the state of the art circa 1970.
     That is the purpose of Common Logic and controlled NLs.

  2. Distinguish true natural language processing from controlled
     NLs, which are the so-called "natural language" things that have
     actually been implemented during the past 50 years.

#2 is the really interesting stuff, but nobody is going to pay for it
unless they can see some progress from #1.

John


---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[GS Chandy]

The 'fundamental advance' has been available for a long time, in the works of John N. Warfield (http://www.jnwarfield.com); and see also "The Warfield Collection" at the George Mason University Library (http://ead.lib.virginia.edu/vivaead/published/gmu/vifgm00008.tp).   You'll find, however, that this work probably implies that 'mechanisation' of thought and ideas is quite far in the future if that is going to be possible at all (so far as we can tell today).

 

Based on Warfield's seminal contributions, I've developed a uniquely powerful generic aid to problem solving and decision making that, in its 'management avatar', I call the 'One Page Management System' (OPMS).  The OPMS approach enables any individual or group to identify a 'Mission' and then, from currently available ideas about the Mission (elicited by way of well-designed 'trigger questions') to create models showing how those ideas ('elements' in the system under consideration) may "contribute to" or "hinder"  each other and the Mission. The 'integration' of such models enables development of an Action Plan to accomplish the Mission, linking the things we know how to do right now to the objectives and Mission we want to accomplish in the future.   Warfield's Interpretive Structural Modeling (ISM) is one modeling tool of choice to enable graphical representations of ideas that helps clarify interactions between elements of systems.  Another simple tool, also developed by Warfield, is the 'Field Representation Method', which enables classification of ideas into categories/similarity classes.

 

More information about the OPMS can be made available on request.

 

GSC

Jon Awbrey <jawbrey@...> wrote:

o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o

still looks like "russell on roller skates" to me ...

when are we going to start talking about a fundamental advance?

maybe next millenium ...

jon

o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o
inquiry e-lab: http://stderr.org/pipermail/inquiry/
mwb: http://www.mywikibiz.com/Directory:Jon_Awbrey
mathweb: http://www.mathweb.org/wiki/User:Jon_Awbrey
getwiki: http://www.getwiki.net/-UserTalk:Jon_Awbrey
p2p wiki: http://www.p2pfoundation.net/User:JonAwbrey
planet math: http://planetmath.org/?op=userobjs;id=15246
zhongwen wp: http://zh.wikipedia.org/wiki/User:Jon_Awbrey
ontolog: http://ontolog.cim3.net/cgi-bin/wiki.pl?JonAwbrey
http://www.altheim.com/ceryle/wiki/Wiki.jsp?page=JonAwbrey
wp review: http://wikipediareview.com/index.php?showuser=398
o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o


---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

+++++++ 
Intelligent Systems for U and Me (i-SUM),

Camp: Mumbai, India - c/o Sahi Oretrans Pvt Ltd.

Tel.: [phone]

+++

 

---

Be a better friend, newshound, and know-it-all with Yahoo! Mobile. Try it now.

[John F. Sowa]

Norbert,

I certainly agree with that point:

NEF> Speaking for controlled natural languages... they can be
 > a break through the front of formalists who promote languages
 > that are unreadable by most domain specialists.

But the research is in human factors.  Designing good tools to
support a methodology for knowledge acquisition is extremely
important.  And I don't believe that the goals of the Semantic
Web (and many other AI projects) can be met without solid support
for a methodology that uses some sort of controlled NLs.

I also believe that there will not be a *single* controlled NL,
and different dialects are likely to be developed for many
different purposes.  Therefore, a common semantic foundation,
such as CL, is essential to promote interoperability at the
logic level, rather than the source language(s).

John




---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[Jean-Luc Delatre-2]

Awwwww... Shit!
That kook is still there: http://math.ucr.edu/home/baez/crackpot.html

JLD

Le Sun, 20 Apr 2008 08:30:49 -0700 (PDT),
GS Chandy <gs_chandy@...> a écrit :

> The 'fundamental advance' has been available for a long time, in the works of John N. Warfield (http://www.jnwarfield.com); and see also "The Warfield Collection" at the George Mason University Library (http://ead.lib.virginia.edu/vivaead/published/gmu/vifgm00008.tp).   You'll find, however, that this work probably implies that 'mechanisation' of thought and ideas is quite far in the future if that is going to be possible at all (so far as we can tell today).
>    
>   Based on Warfield's seminal contributions, I've developed a uniquely powerful generic aid to problem solving and decision making that, in its 'management avatar', I call the 'One Page Management System' (OPMS).  The OPMS approach enables any individual or group to identify a 'Mission' and then, from currently available ideas about the Mission (elicited by way of well-designed 'trigger questions') to create models showing how those ideas ('elements' in the system under consideration) may "contribute to" or "hinder"  each other and the Mission. The 'integration' of such models enables development of an Action Plan to accomplish the Mission, linking the things we know how to do right now to the objectives and Mission we want to accomplish in the future.   Warfield's Interpretive Structural Modeling (ISM) is one modeling tool of choice to enable graphical representations of ideas that helps clarify interactions between elements of systems.  Another simple tool, also developed
>  by Warfield, is the 'Field Representation Method', which enables classification of ideas into categories/similarity classes.
>    
>   More information about the OPMS can be made available on request.
>    
>   GSC
>
> Jon Awbrey <jawbrey@...> wrote:
>   o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o
>
> still looks like "russell on roller skates" to me ...
>
> when are we going to start talking about a fundamental advance?
>
> maybe next millenium ...
>
> jon
>
> o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o
> inquiry e-lab: http://stderr.org/pipermail/inquiry/
> mwb: http://www.mywikibiz.com/Directory:Jon_Awbrey
> mathweb: http://www.mathweb.org/wiki/User:Jon_Awbrey
> getwiki: http://www.getwiki.net/-UserTalk:Jon_Awbrey
> p2p wiki: http://www.p2pfoundation.net/User:JonAwbrey
> planet math: http://planetmath.org/?op=userobjs;id=15246
> zhongwen wp: http://zh.wikipedia.org/wiki/User:Jon_Awbrey
> ontolog: http://ontolog.cim3.net/cgi-bin/wiki.pl?JonAwbrey
> http://www.altheim.com/ceryle/wiki/Wiki.jsp?page=JonAwbrey
> wp review: http://wikipediareview.com/index.php?showuser=398
> o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: cg-unsubscribe@...
> For additional commands, e-mail: cg-help@...
>
>
>
>
>   +++++++
> Intelligent Systems for U and Me (i-SUM),
>    
> Camp: Mumbai, India - c/o Sahi Oretrans Pvt Ltd.
>   Tel.: [phone]
>   +++
>
>  
>  
>
>        
> ---------------------------------
> Be a better friend, newshound, and know-it-all with Yahoo! Mobile.  Try it now.

---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[Enrico Franconi]

Hi,
I found your message amazing.

On 20 Apr 2008, at 15:38, John F. Sowa wrote:

> As people have noticed, RDF and OWL are not readable notations,
> and people have tried to invent controlled NLs that map to them.

I hope that you agree that this is irrelevant for what you are arguing.

> But RDF and OWL are both very quirky languages, primarily because
> they mix logic with special-purpose data structures (triples)
> and special-purpose algorithms (DL proof procedures).

Uh? DLs are in the guarded fragment of FOL, as modal logics are.
What has this to do with quirkiness or special-purpose algorithms is  
obscure to me.

> It's hard
> to map natural languages to and from notations that have been
> designed for specialized algorithms and data structures.

It is not hard at all, since both are decidable fragments of FOL.
Of course, this also means that the expressivity is less than FOL.
There are various papers on how the reduced expressivity of these  
fragments impacts on the grammar of the corresponding CNL.
So, the argument is whether you want to trade decidability for  
expressivity; a discussion about this is welcome.

> Of all commercial applications of logic, the Semantic Web is
> tiny in comparison to the "500-pound gorilla in the room":  SQL.
> Every commercial web site incorporates an SQL database, and
> SQL has been the outstanding example of the commercial success
> of FOL for the past 30+ years.  The WHERE clause in SQL is FOL,
> but with negation as failure (as in Prolog).

Negation in SQL is not negation as failure like in prolog.
It is classical negation, interpreted on the finite model represented  
exactly by the database.

> One of the major problems of the Semantic Web is that it has not
> been integrated with relational databases, and it is awkward to
> download all or part of an SQL DB into RDF.  But if you support
> full n-tuples, as in Common Logic, it is trivial to download an
> SQL DB or an RDF DB into CL and to define relations between them.

The encoding of a SQL DB as a FOL theory requires a careful handling  
of the domain closure, the unique names, and the relation closure  
assumptions, not to mention safeness. It is a nice theoretical  
exercise (done by Ray Reiter in the 70's), which does not lead  
anywhere interesting from the practical point of view -- i.e., you  
really don't want to do FOL theorem proving on a complex theory when  
you know that the theory itself has a unique and well known model.
Forgetting for a while about safeness, the boolean (unsafe) query
\forall x. \not Person(x)
gives you a true answer over an empty database, while its naive FOL  
translation gives a false answer.

cheers
--e.


Enrico Franconi                  - franconi@...
Free University of Bozen-Bolzano - http://www.inf.unibz.it/~franconi/
Faculty of Computer Science      - Phone: [phone]
I-39100 Bozen-Bolzano BZ, Italy  - Fax:   [phone]




---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[Arun Majumdar]

Dear Enrico,

A actually found your response "amazing".

Enrico Franconi wrote:
> Hi,
> I found your message amazing.
>
> On 20 Apr 2008, at 15:38, John F. Sowa wrote:
>
>> As people have noticed, RDF and OWL are not readable notations,
>> and people have tried to invent controlled NLs that map to them.
>
> I hope that you agree that this is irrelevant for what you are arguing.
I have always found that the words "description" and "logic" together
form an oxymoron.  In  DL, there are only sets of objects and binary
relations with whatever set of functors (constructors, such as
conjunction, disjunction etc..) that an "implementor" may choose in
determining his closed world universe of discourse for some area of
interest (for example, the medical domain, or a games domain etc...).  
While your comments appear to be targeted at a very literal view of
logic, I do not believe that was John's intention in this posting (but I
stand to be corrected). I believe I can restate the intention as: ***To
have a truly "descriptive" logic is to have a logic whose expression can
be read by a child - not an expert with years of training.***
>
>> But RDF and OWL are both very quirky languages, primarily because
>> they mix logic with special-purpose data structures (triples)
>> and special-purpose algorithms (DL proof procedures).
>
> Uh? DLs are in the guarded fragment of FOL, as modal logics are.
> What has this to do with quirkiness or special-purpose algorithms is
> obscure to me.
I offer a reference here
http://pellet.owl*dl*.org/papers/sirin06from.pdf .Anyone who engineers
real-world systems knows that you need to create your own set of
constructors, to build your own DL version,  and hence, that this
involves customized algorithms, decision procedures, choice in the
implementation of "negation", choice in implementation of a resolution
process The paper cited is all about specialized algorithms (aka
"decision procedures"). So I do not see what the point of your comment
is that this has nothing to do with special purpose algorithms.
>
>> It's hard
>> to map natural languages to and from notations that have been
>> designed for specialized algorithms and data structures.
>
> It is not hard at all, since both are decidable fragments of FOL.
Natural Languages are the *hardest* languages in the world and I
*specifically* challenge anyone, on this list or elsewhere* to refute
(with proof) that what you claim is easy.  Your statement is
unjustified, unprovable and to me, completely false.
> Of course, this also means that the expressivity is less than FOL.
What are you talking about? The expressivity of *what*???
> There are various papers on how the reduced expressivity of these
> fragments impacts on the grammar of the corresponding CNL.
What papers?  Do these references emerge to you "mirabile dictum"?
> So, the argument is whether you want to trade decidability for
> expressivity; a discussion about this is welcome.
Decidability has *nothing* whatsoever to do with expressivity. The terms
get mis-used all the time and confused. Decidability identifies  
procedure guaranteed to give a true/false answer to a query in in a
finite amount of time. That is all.  There is no "trade" here with
"expressivity".   Expressivity in any language is determined by the
choice of constructors chosen to represent problems. Problem spaces, not
expressivity, determines decidability.  Expressitive determines the
representability of  a problem space - that is all.

In the applied world (aerospace, defense, business process,
manufacturing, construction etc...) no one cares about decidability.
They care about approximation and results.  DL and OWL are ill equipped
to handle the concepts needed.  Let me make a most specific case clear
with respect to "knowledge representation" and reasoning algorithms,
methods or even theories that are in any way meaningful in solving
non-linearizable real-world dynamical problems. For example, look at the
periodic-table of the elements and then look at any of the
representations of unitary knowledge in the life sciences : none of it
occurs in "triples" and any breakdown of that knowledge into "triples"
immediately destroys the ability to work with the knowledge as perceived
by the higher order structures (where the "meaningfullness" exists).
Biochemists, for example, work with "functional groups" (for example, in
the 20 amino-acid "alphabet" of proteins - no triples here).  While I
know the debate will rage on, I am *certain* that a controlled natural
language for humans will far superceed any OWL representation, which I
have seen, and which is plain illegible and incomprehensible except to
experts (and even to the experts it is not that easy).  For a recent
example of the difference, I will request John to refer to the HITSP Owl
versus CL versions ... (John is on travel - but, I will seek to provide
a use-case for comparison).

>
>> Of all commercial applications of logic, the Semantic Web is
>> tiny in comparison to the "500-pound gorilla in the room":  SQL.
>> Every commercial web site incorporates an SQL database, and
>> SQL has been the outstanding example of the commercial success
>> of FOL for the past 30+ years.  The WHERE clause in SQL is FOL,
>> but with negation as failure (as in Prolog).
>
> Negation in SQL is not negation as failure like in prolog.
> It is classical negation, interpreted on the finite model represented
> exactly by the database.

What on earth are you talking about? Have you read the Oracle 10g
manual?  Have you even read the MySQL guides for the model of negation
(or looked in its open sources)? It is NEGATION AS FAILURE (NAF). Prolog
and SQL use "negation-a-failure" of a "search-algorithm" on a finite set
(the set of objects stored and indexed) --- if an object is not found in
the set, then NAF is default chosen by these implementors.  Classical
negation has nothing to do with a computer-implementors choice of NAF
nor SQL.  We forget that "logic" does not arrive with a "execution"
engine --- it has to be "implemented".

>
>> One of the major problems of the Semantic Web is that it has not
>> been integrated with relational databases, and it is awkward to
>> download all or part of an SQL DB into RDF.  But if you support
>> full n-tuples, as in Common Logic, it is trivial to download an
>> SQL DB or an RDF DB into CL and to define relations between them.
>
> The encoding of a SQL DB as a FOL theory requires a careful handling
> of the domain closure, the unique names, and the relation closure
> assumptions, not to mention safeness. It is a nice theoretical
> exercise (done by Ray Reiter in the 70's), which does not lead
> anywhere interesting from the practical point of view -- i.e., you
> really don't want to do FOL theorem proving on a complex theory when
> you know that the theory itself has a unique and well known model.

Well - that is the key problem: "knowing that the theory has a model"
--- that is why abductive and heuristic methods, most of which have
nothing to do with DL but can be elegantly expressed in natural
languages, and expressed to some extent in controlled natural languages
(like a CL variant called CLCE) are preferred (by me).
> Forgetting for a while about safeness, the boolean (unsafe) query
> \forall x. \not Person(x)
> gives you a true answer over an empty database, while its naive FOL
> translation gives a false answer.
Again - things seem mixed up.  What "empty database" are you talking
about? What do you mean by "naive".  The statement is meaningless to me
because your example is incomplete here.
>
> cheers
> --e.
>
Cheers,

Arun

>
> Enrico Franconi                  - franconi@...
> Free University of Bozen-Bolzano - http://www.inf.unibz.it/~franconi/
> Faculty of Computer Science      - Phone: [phone]
> I-39100 Bozen-Bolzano BZ, Italy  - Fax:   [phone]
>
>
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: cg-unsubscribe@...
> For additional commands, e-mail: cg-help@...
>
>
>

---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[Jon Awbrey]

o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o

Norbert E. Fuchs wrote:
>
> On 20 Apr 2008, at 15:56, Jon Awbrey wrote:
>
> > still looks like "russell on roller skates" to me ...
>
> Excuse my ignorance, what is meant by "Russell on roller skates"?
>
> --- nef

it was a metaphorical way of describing projects that attempt
to mechanize or lay one patch after another on a tradition in
logic that i have reason to consider fundamentally inadequate
and even a little superficial.  i wasn't really talking about
approximations to natural language, where all we can hope for
is incremental progress bit-by-bit, but the kinds of projects
in logic that grind on as they have for the last century, all
oblivious to the fundamental questions about the character of
logic that C.S. Peirce addressed when he defined it as formal
semiotic.

jon

o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o
inquiry e-lab: http://stderr.org/pipermail/inquiry/
mwb: http://www.mywikibiz.com/Directory:Jon_Awbrey
mathweb: http://www.mathweb.org/wiki/User:Jon_Awbrey
getwiki: http://www.getwiki.net/-UserTalk:Jon_Awbrey
p2p wiki: http://www.p2pfoundation.net/User:JonAwbrey
planet math: http://planetmath.org/?op=userobjs;id=15246
zhongwen wp: http://zh.wikipedia.org/wiki/User:Jon_Awbrey
ontolog: http://ontolog.cim3.net/cgi-bin/wiki.pl?JonAwbrey
http://www.altheim.com/ceryle/wiki/Wiki.jsp?page=JonAwbrey
wp review: http://wikipediareview.com/index.php?showuser=5619
o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o


---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[Rich Morin]

Given my interest in mechanized documentation, I immediately
want to know what kinds of tooling might be created to:

  *  analyze sets of relationships and generate CNL "readings"

  *  make CNL readings as comprehensible as possible (eg,
     simple, organized, idiomatic) for the human reader

Given a system that combines user-specified facts and rules
with mechanically-derived data and inferences, there could be
quite a few (:-) resulting statements.  Making these visible
and comprehensible to humans is (I claim) an interesting and
potentially useful exercise.

Using tools such as GraphViz, it is possible to generate a
diagram of (say) a CG representation of some relationships.
Using (say) tooltips, the CNL "readings" could be provided.
The question is whether all of this would be comprehensible
to relatively untrained readers.

-r
--
http://www.cfcl.com/rdm            Rich Morin
http://www.cfcl.com/rdm/resume     rdm@...
http://www.cfcl.com/rdm/weblog     [phone]

Technical editing and writing, programming, and web development

---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[David Cox]

Rich,

This describes a simple way people have used (and have liked) to communicate 'relationships' and 'readings,'  the two subjects you focused on in your email to CGers.

The method asks us to think of  relationships in systems as the connections (or the logic) users must see,  along with the chunks being connected (your readings or 'content.' The chunks can include definitions, symbolic or technical representations, etc.).

The method requires people who design instructions for system users to "chunk" content into special visual frames according to a rudimentary rule ("read top-down") which allows the connections of chunks to be visible without any form -- no language, no symbols, no mathematical formulas, no arrows, no space.

(An aside.  This "without any form" seems to me a remarkable concept  8-)   .  Niels Bohr, correspondent of Einstein, said, “It is wrong to think that the task of physics is to find out how Nature is.  Physics concerns what we can say about Nature.”  Cited by Heinz R. Pagels © 1982 p 73 in his book THE COSMIC CODE; QUANTUM PHYSICS AS THE LANGUAGE OF NATURE.  A Bantam Book  Simon & Schuster.  Dr. Bohr's statement suggests to me:  "A commendable way to represent the logic of our systems is without saying anything.")

Like other CGers, Rich, you are likely somewhat familiar with FLIPP Explainers (Explanation by Pattern).  What's new here is the realization that logic can be represented 'without space,'  i.e., simply.  This depends on each FLIPP frame having the property that it is connectible as a logic IF...THEN, or an OR, or an AND, or a NOT thru juxtaposition and the top-down-only rule. This makes the format much like games having (a.) their own game-specific boards (chess, soccer, tennis, baseball, cribbage, children's hopscotch, driving on highways, track and field, conference tables, airplane control panels, Vista screens, battle fields) and (b.) their own game-specific rules.

What FLIPP users would greatly benefit from is an extremely simple computerized way for non-programmers to modify FLIPP Explainers to reflect changes.  John Sowa  alludes to the same reply I have gotten: "The cost."  This has not stopped original applications of FLIPP because system architects must scratch-invent each frame and  frame position anyway.  Revising a twenty-million user path diagram quickly several times a day for thousands of users is the assignment, Rich.  :-) .
I'm with you on your apt thought:

"Given a system that combines user-specified facts and rules
with mechanically-derived data and inferences, there could be
quite a few (:-) resulting statements.  Making these visible
and comprehensible to humans is (I claim) an interesting and
potentially useful exercise.with mechanically-derived data and inferences, there could be
quite a few (:-) resulting statements.  Making these visible
and comprehensible to humans is (I claim) an interesting and
potentially useful exercise."

A one-page demo of FLIPP Explainers is at http://www.flipp-explainers.org/demonstration.htm

Best, Rich.
DJC 4/23/08  Cincinnati OH

Rich Morin wrote:

Given my interest in mechanized documentation, I immediately
want to know what kinds of tooling might be created to:

  *  analyze sets of relationships and generate CNL "readings"

  *  make CNL readings as comprehensible as possible (eg,
     simple, organized, idiomatic) for the human reader

Given a system that combines user-specified facts and rules
with mechanically-derived data and inferences, there could be
quite a few (:-) resulting statements.  Making these visible
and comprehensible to humans is (I claim) an interesting and
potentially useful exercise.

Using tools such as GraphViz, it is possible to generate a
diagram of (say) a CG representation of some relationships.
Using (say) tooltips, the CNL "readings" could be provided.
The question is whether all of this would be comprehensible
to relatively untrained readers.

-r
  

[John F. Sowa]

Enrico,

I was out of town for the past few days and couldn't respond.
But I was trying to make several points, which are related to
the following article:

    http://www.jfsowa.com/pubs/fflogic.pdf
    Fads and Fallacies About Logic

JFS>> As people have noticed, RDF and OWL are not readable notations,
 >> and people have tried to invent controlled NLs that map to them.

EF> I hope that you agree that this is irrelevant for what you are
 > arguing.

One of the points that I have made on various occasions is that
there is a major distinction between representing knowledge about
some subject and coding some or all of that knowledge in a computable
form for some purpose.  The people who are experts in a domain very
rarely know anything about computational complexity, algorithm design,
theorem proving, etc.  And the people who know those subjects very
rarely understand the applications.

It's essential to have two kinds of knowledge representation
languages:

  1. Notations that are readable by domain experts, but avoid all
     issues of how the knowledge is used in computation.

  2. Notations that are optimized for particular algorithms and
     proof procedure.

Ideally, the mapping from #1 to #2 should be automated, but some
human assistance or checking is necessary, at least for the current
state of the art.  Following is a good example:

    Peterson, Brian J., William A. Andersen, & Joshua Engel (1998)
    "Knowledge bus: generating application-focused databases from
    large ontologies," Proc. 5th KRDB Workshop, Seattle, WA.
    http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-10/

JFS>> But RDF and OWL are both very quirky languages, primarily because
 >> they mix logic with special-purpose data structures (triples)
 >> and special-purpose algorithms (DL proof procedures).

EF> Uh? DLs are in the guarded fragment of FOL, as modal logics are.
 > What has this to do with quirkiness or special-purpose algorithms
 > is obscure to me.

DLs are examples of languages of type #2, which have been optimized
for specific purposes.  RDF has been further optimized for algorithms
designed for "triples".  Some people have claimed that a triple store
is efficient for certain purposes, but as Knuth, said, quoting Hoare,
"Premature optimization is the root of all evil."

Furthermore, the combination of the RDF encoding with DLs leads to
representations that are unintelligible to domain experts who have
not become dedicated RDF-OWL hackers.

That is what I meant by "quirky".  No one who is familiar with the
subject matter would explain it in a way that translates directly
to the RDF-OWL form.  But a statement in English (or at least a
controlled version of English) could be translated to an ordinary
statement in full FOL in several different common notations.

JFS>> It's hard to map natural languages to and from notations that
 > have been designed for specialized algorithms and data structures.

EF> It is not hard at all, since both are decidable fragments of FOL.

Two points:  (1) Decidability and readability or writability are
unrelated issues; see the fflogic.pdf paper.  (2) Common Logic has
a highly regular structure that is easier to translate to and from
NL syntax (at least for controlled NLs).

EF> Negation in SQL is not negation as failure like in prolog.
 > It is classical negation, interpreted on the finite model
 > represented exactly by the database.

That depends on the application.  If you use the database to store
airline reservations, you have a closed-world database -- because
any reservation that is not in the database does not exist.  But
relational databases are used to store both open and closed world
information.  For open worlds, the SQL negation is the same as
the Prolog version of negation as failure.

EF> The encoding of a SQL DB as a FOL theory requires a careful
 > handling of the domain closure, the unique names, and the relation
 > closure assumptions, not to mention safeness.

I agree, as Socrates said, that the unexamined program is not worth
implementing.   But there are many thoroughly examined ways of
using the data stored in relational DBs, for both open and closed
worlds.

John


---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...

[naoya_arakawa]

On 20 Apr 2008, "John F. Sowa" <sowa@...> wrote;

> As people have noticed, RDF and OWL are not readable notations,

> But RDF and OWL are both very quirky languages, primarily because
> they mix logic with special-purpose data structures (triples)
> and special-purpose algorithms (DL proof procedures).

Aside from OWL, RDF is equivalent to the general formal graph while
CGs are graphs specialized to represent FOL.
As for the readability, the CG display form is a bit more compact  than RDF.  Namely, CGDF hides quantifiers and type relations into nodes.
(But I guess you are not talking of CGDF but of CLCE, and controlled  English would often be readable than graph forms for English  speakers.)

A problem with RDF is that it  doesn't have a standard notation to  represent FOL  (if anyone know such a standard, please let me know), and I think this would hinder the development of the Semantic Web.

Since RDF and CGs are formally quite similar, my suggestion is to create the standard such as CGRDF, which is a simple notational variant or yet another representation format of CGs.
In fact, this has been suggested by TBL himself:
http://www.w3.org/DesignIssues/CG.html

It would be nice if TBL and CGers have been collaborating.
If not, why not?

Best,
--
Naoya Arakawa

---------------------------------------------------------------------
To unsubscribe, e-mail: cg-unsubscribe@...
For additional commands, e-mail: cg-help@...