SUO: Re: Logic, Topic Maps, and RDF

["John F. Sowa" <sowa@bestweb.net>]

Jack,

It's important to distinguish statements about the content
(which should be expressible in plain English) from
statements about the representation (which may use technical
terms about the notation).

  > If we then try to reduce the diagram  to  short story
  > (sentence in this case), we can say something like:

  > There exists a relationship of type "marriage" between
  > a husband, played by "Joe Sixpack", and a wife, played
  > by "Sara Sixpack".

What worries me is the phrase "something like" in the
introduction and the phrases "relationship of type"
and "played by".

"Something like" does not mean "exactly like" --
it suggests an approximation that distorts or
leaves out some significant information.  What
information is that?

Then the supposed English sentence uses technical
terms about the representation.  It is not a statement
that any normal English speaker would use to convey
some information to another English speaker.
Following is my interpretation of that sentence as
a CG and an English sentence that does not use any
technical terms about CGs or topic maps:

CG:  [Husband: 'Joe Sixpack']->(IsMarriedTo)->[Wife: 'Sara Sixpack'].

English:  A husband Joe Sixpack is married to a wife Sara Sixpack.

The CG can also be translated to the following formula in
typed predicate calculus:

   (Ex:Husband)(Ey:Wife)(name(x,"Joe Sixpack") & name(y,"Sara Sixpack")
       & IsMarriedTo(x,y)).

This formula can also be translated to English without using
technical terms, but I prefer to add variables to the language
in order to simplify the mapping:

   There is a husband x and a wife y where the name of x is
   Joe Sixpack and the name of y is Sara Sixpack and
   x is married to y.

And by the way, the concept [Husband: 'Joe Sixpack'] is
actually an abbreviation for the following CG:

   [Husband]->(Name)->[Word: "Joe Sixpack"].

Note that single quotes are used to delimit names,
and double quotes are used to delimit character
strings.  The type label Word indicates that the
character string is a literal of type Word.

When I translate the CG to the formula, I usually expand
the implicit name relation, since there is no common
convention for handling names in predicate calculus.

Following are your statments and my suggestions for
representing them in CGs with an English sentence that
translates each CG:

  > topic rdf:ID "IsMarriedTo"
  > isMarriedTo instanceOf #AssociationType

CG:  [Relation: 'IsMarriedTo']

English:  There is a relation named IsMarriedTo.

  > topic rdf:ID "HusbandRole"
  > HusbandRole instanceOf #Role

CG: [Type: 'Husband']->(SubT)->[Type: 'Role']

English:  There is a type named Husband and a
type named Role.  Husband is a subtype of Role.
You could also add another statement to
indicate that Husband is also a subtype of Man:

    [Type: 'Husband']->(SubT)->[Type: 'Man'].

The single quotes indicate that Husband, Man,
and Role are names of entities of type Type.

  > topic rdf:ID "Husband"
  > topic rdf:ID "Wife"
  > topic rdf:ID "WifeRole"

You wouldn't need such statements in CG notation,
since every instance of a concept [t:r] states
that t is a type and r is a referent to something
of the type t.  If r is a string in single quotes,
such as 'nnnn', then 'nnnn' is a name used to
refer to some entity of the type t.

 > WifeRole instanceOf #Role

How does "WifeRole" differ from "Wife"?
I would just define Wife as a subtype
of Role and a subtype of Woman.

  > HusbandRole subjectIdentifier #Husband
  > WifeRole subjectIdentifier #Wife

A concept of the form [t:'n'] declares that the
character string 'r' is the used as a name of
an entity of type t.  No additional statements
are necessary.

 > topic rdf:ID "Joe"
 > Joe baseName "Joe Sixpack"
 > topic rdf:ID "Sara"
 > Sara baseName "Sara Sixpack"

When you write [Husband: 'Joe Sixpack'] or [Husband: 'Joe'],
you implicitly define "Joe Sixpack" and "Joe" as names.
If you want to say that they are both names of the same
entity, you can use the expanded form:

[Word: "Joe"]<-(Name)<-[Husband]->(Name)->[Word: "Joe Sixpack"]

In the linear notation, you could also write this in
a form that looks like a "frame":

[Husband]-
    (Name)->[Word: "Joe Sixpack"]
    (Name)->[Word: "Joe"].

You could also use a dotted line, called a coreference
link, to show that two concepts refer to the same entity:

[Husband: 'Joe']...[Husband: 'Joe Sixpack']...[Man: 'Mr. Sixpack'].

English:  The husband Joe is the same as the husband Joe Sixpack,
who is the same as the man Mr. Sixpack.

 > Next, the instance, an assertion. Note here that we
 > have options, one of which would be to define a
 > topic (class) identified as an Assertion, followed
 > by a subClass called, say, MaritalRelation, for
 > which the following could be an instance. I suspect
 > that, in the end, this all should be anchored in
 > a proper upper ontology, but that's not my point
 > for the time being.

 > topic rdf:ID "JoeSaraMarriage"

In the attached diagram, there is a yellow node with
the label "Joe_Sara_Married" is that intended to be
the same as "JoeSaraMarriage"?

I would say that there is a situation named
JoeSaraMarriage:

   [Situation: 'JoeSaraMarriage'].

Then I would insert the original CG into the
same box as a description of that situation:

[Situation: 'JoeSaraMarriage'
   [Husband: 'Joe Sixpack']->(IsMarriedTo)->[Wife: 'Sara Sixpack']].

 > JoeSaraMarriage instanceOf #Assertion
 > JoeSaraMarriage assertionType #IsMarriedTo
 > topic rdf:ID "JoeCast"
 > JoeCast rolePlayer #Joe
 > JoeCast roleType #HusbandRole
 > JoeSaraMarriage rolePlayer #JoeCast
 > topic rdf:ID "SaraCast"
 > SaraCast rolePlayer #Sara
 > SaraCast roleType #WifeRole
 > JoeSaraMarriage rolePlayer #SaraCast
 > JoeSaraMarriage role #WifeRole
 > JoeSaraMarriage role #HusbandRole

I don't know why you need all this extra stuff here.
It does not appear in the original topic map.

In summary, I would state the following declarations:

   [Type: 'Husband']->(SubT)->[Type: 'Role'].
   [Type: 'Wife']->(SubT)->[Type: 'Role'].
   [Relation: 'IsMarriedTo'].

The concept types Role and Situation are part of the
ontology I used in my KR book, and which is summarized
on my web site:

    http://www.jfsowa.com/ontology/

And then I would use the following CG as a
representation of JSixPack.jpg:

[Situation: 'JoeSaraMarriage'
   [Husband: 'Joe Sixpack']->(IsMarriedTo)->[Wife: 'Sara Sixpack']].

This is the linear form of the CG, which is drawn
in the attached diagram JoeSixCG.gif.

John