;;; FILE:	helenkeller-20060802-2.demo
;;; FOR:	helenkeller.tex

;;; use mode 3
set-mode-3

;;; define frames

;;; Need a "lex arc" case frame
;;; Could use:  define-frame lex (nil lex)
;;; -- this is a "structured individual"

;;; But: conflates predicate with arc label
;;; -- OK in general, but not for my purposes

;;; Worse:  misleadingly suggests that the
;;;         functional term is a lexical item
;;;         -- but it's really a concept.  Better:

;;; [[thing-called(w)]] = concept associated with
;;;                       word w in lexicon
define-frame thing-called (nil lex)

;;; [[AKO(sub,sup)]] = sub is a subclass of superclass sup
define-frame AKO (nil subclass superclass)

;;; Figure 1:  humans are mammals

;;; This will be:
;;;    AKO(thing-called(humans),thing-called(mammals)).
;;;    i.e., a thing called 'humans' is a kind of
;;;          thing called 'mammals'

;;; NB:  Had we used lex(humans) and lex(mammals),
;;;      would have to say:
;;;      AKO(lex(humans),lex(mammals)

;;; But: this looks like it says:
;;;      The word 'humans' is a kind of the word 'mammals'
;;; -- there is such a relationship (hyponymy),
;;;    but that's not what we're doing

;;; So:

AKO(thing-called(humans),thing-called(mammals)).

;;; describe all relevant nodes (see Figure 1 in text)
%(describe m3)

;;;---------------------------------------------------------------------

;;; Replace lex arc with "name-object" case frame
;;; -- this is a proposition
;;; Same as "expression-expressed" or "word-object" case frames
;;; -- but uses Helen Keller's terminology

;;; [[ISA-thing-named(o,n)]] = object o is named (expressed)
;;;			       by the word n in the lexicon
define-frame ISA-thing-named (nil object name)

;;; NB:  Every relation has a converse.
;;; So, could have called this:  Name-of(o,n), where
;;; [[Name-of(o,n)]] = n is a name for o

;;; A "neutral" predicate might be:  Name-Object(o,n)
;;; -- i.e., use case-frame as predicate

;;; NB:  This is a hard-to-express proposition
;;; -- Any attempt to express it either uses "name",
;;;    which shouldn't really be used, since it's an arc
;;;    or works for some cases but not others (no gen'l sol'n)
;;; -- All it does is provide a name (i.e., a word) for o

;;; Figure 3:  humans are mammals
ISA-thing-named(b1,humans).

;;; NB:  Could have said:  ISA-thing-named(humans1,humans)
;;; But: wanted diagrams to look like those produced with
;;;      SNePSUL
;;; And: Use of node identifier that looks like English
;;;      is susceptible to McDermott's Fallacy
;;;      -- "Ah, a node labeled "humans1" must represent humans"
;;; So...

ISA-thing-named(b2,mammals).
AKO(b1,b2).

;;; describe all relevant nodes (see Figure 3 in text)
%(describe m4 m5 m6)

;;;---------------------------------------------------------------------

;;; [[Is(o,p)]] = object o has property p
define-frame Is (nil object property)

;;; Figure 4:  water is wet
ISA-thing-named(b3,water).
ISA-thing-named(b4,wet).
Is(b3,b4).

;;; describe all relevant nodes
%(describe m7 m8 m9)

;;;---------------------------------------------------------------------

;;; [[Possession(o,p,r)]] = object o is possessor p's r
;;;			    or:  p's r is o
;;;  			    or:  o stands in the r relation to p
define-frame Possession (nil object possessor rel)

;;; Figure 5:  "water" is b3's name; "wet" is b4's name
ISA-thing-named(b5,name).
Possession(water,b3,b5).
Possession(wet,b4,b5).

;;; describe all relevant nodes
%(describe m7 m8 m9 m10 m11 m12)

;;;---------------------------------------------------------------------

;;; Figure 6:  Giving a name to "name".
;;; "name" is b5's name
Possession(name,b5,b5).

;;; describe all relevant nodes
%(describe m10 m13)

;;;---------------------------------------------------------------------

;;; [[ISA(m,c)]] = m is a member of class c
define-frame ISA (nil member class)

;;; Figure 7:  Something is a red, round ball.

;;; Something is a thing named "ball".
ISA-thing-named(b6,ball).

;;; Something is a ball.
ISA(b7,b6).

;;; Something is a thing named "round"
ISA-thing-named(b8,round).

;;; The ball is round.
Is(b7,b8).

;;; Something is a thing named "red"
ISA-thing-named(b9,red).

;;; The ball (which is round) is red.
Is(b7,b9).

;;; describe all relevant nodes
%(describe m14 m15 m16 m17 m18 m19)

;;;---------------------------------------------------------------------

;;; Figure 8:   "ball" is b6's name;
;;;		"round" is b8's name;
;;;		"red" is b9's name

Possession(ball,b6,b5).
Possession(round,b8,b5).
Possession(red,b9,b5).

;;; describe all relevant nodes
%(describe m10 m20 m21 m22)

;;;---------------------------------------------------------------------

;;; If Cassie/Keller is to learn the name of naming,
;;; then she needs a rule like this:

;;; Rule (1):
;;; If x is named y, then ..?.. & y is x's name 
;;; -- where "x is named y" is the hard-to-express proposition providing
;;;    a way of uttering x, and where "..?.." is the hard-to-express
;;;    proposition providing Cassie/Keller with a name for naming

;;; So we assert this rule and do forward inference with it 
;;; (indicated by the exclamation mark punctuation):

all(x,y)(ISA-thing-named(x,y) => {ISA-thing-named(b5,name),
				  Possession(y,x,b5)})!

;;; So, she now believes wff25 and wff 24:
;;; wff24!:  Possession(humans,b1,b5)
;;; wff25!:  Possession(mammals,b2,b5)

%(describe m24 m25)

;;; And to remind you what b1, b2, b5 were:
%(describe m4 m5 m10 m24 m25)

;;; And to remind you how they are related:
%(describe m4 m5 m6 m10 m24 m25)

;;; And, to learn the name and concept of "property"
;;; she'd need a rule like this:

;;; Rule (2):
;;; If x is (i.e., has property) y, 
;;;    then ..?.. & y is a property
;;; -- This provides a concept of property and a name for it
all(x,y)(Is(x,y) => {ISA-thing-named(b10,property), ISA(y,b10)})!

;;; So, she now believes:
;;;  wff31!:  ISA(b9,b10)    
;;;  wff30!:  ISA(b8,b10)    
;;;  wff29!:  Possession(property,b10,b5)    
;;;  wff28!:  ISA(b4,b10) 

%(describe m28 m29 m30 m31)

;;;---------------------------------------------------------------------

;;; Learning the name for the concept "name":

;;; Need a rule like this:
;;; If x "is a thing named" y, then y is x's something-or-other
;;; NB:  "something-or-other" is a base node with an English-like
;;;      node identifier, which, by McDermott's Fallacy, has no
;;;      significance whatever (except some convenience to us).

;;; Here, we should pretend that this rule is applied *before*
;;; Cassie learns the name of naming.  Once the rule is applied,
;;; then we can tell her that things have names, and she can
;;; infer that her unknown "something-or-other" must be the
;;; relation of naming.  However, to be consistent with the
;;; order in which the material is presented in the text,
;;; we are doing this demo "out of order", so to speak.

;;; We assert and do forward inference with:

all(x,y)(ISA-thing-named(x,y) => Possession(y,x,something-or-other))!

;;; Now she believes:
;;; wff41!:  Possession(property,b10,something-or-other)    
;;; wff40!:  Possession(red,b9,something-or-other)    
;;; wff39!:  Possession(round,b8,something-or-other)    
;;; wff38!:  Possession(ball,b6,something-or-other)    
;;; wff37!:  Possession(name,b5,something-or-other)    
;;; wff36!:  Possession(wet,b4,something-or-other)    
;;; wff35!:  Possession(water,b3,something-or-other)    
;;; wff34!:  Possession(mammals,b2,something-or-other)    
;;; wff33!:  Possession(humans,b1,something-or-other)

%(describe m33 m34 m35 m36 m37 m38 m39 m40 m41)

;;;------------------------------------------------------------------------

;;; To figure out what a "something-or-other" is (or: what its name is?)
;;; need a "defeasible" rule like this:

;;; all(x,y,z,r)({Is(z,unknown),Possession(x,y,z),Possession(x,y,r)}
;;;              &=> Equivalent({z,r}))

;;; where
;;; [[Is(z,unknown)]] = z has the property of being unknown
;;;			(e.g., by Cassie)

;;; This is probably not the best way to represent a concept being
;;; unknown or unfamiliar, but it will suffice for present purposes

;;; We also need to define:
define-frame Equivalent (nil equiv)

;;; where:
;;; [[Equivalent({x_1,...,x_n})]] = mental entities x_1, ..., x_n
;;;				  correspond to the same actual object.

;;; And we have to assert that "something-or-other" is unknown:
Is(something-or-other,unknown).

;;; Now we can assert and do forward inference with:

all(x,y,z,r)({Is(z,unknown),Possession(x,y,z),Possession(x,y,r)}
             &=> Equivalent({z,r}))!

%(describe m10 m13 m42 m43 m44)

;;; END OF DEMO