;; A representation of:
;; "A decade ago research on lab animals revealed that stem cells taken from
;;  animal embryos are astoundingly versatile.  They grow in the lab, proliferate
;;  like rabbits and turn into specialized cells such as neurons (Begley 2001)."
;;
;; Representations are based on Marc Broklawski's original representations though
;; changes have been made to adhere to the case frames used by Ehrlich's 
;; algorithm.  Also new rules have been introduced.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Setup work.  Define external paths and relations and load verb algorithm
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Reset the network
(resetnet t)

;; Define the relations we will need.
(define agent act object lext property objects1 object1 rel object2 ant cq members class mod head source target transference vehicle forall &ant context arg1 arg2)

;;; Don't trace infer
^(setq snip:*infertrace* nil)

;;; Introduce Marc's relations
(intext "rels")

;;; Compose paths
(intext "paths")

;;; Load Noun/Verb Algorithm
^(load "code")


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Representation of:
;;  "research on lab animals"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Model the subclass of lab animals upon which research was performed.  A 
;; subclass/superclass case frmae is used.  
;; Ehrlich might not have used a subclass/superclass to represent this set.  She 
;; instead might have done the following:
;;
;; object1 #setOfLabAnimals 
;; rel "ARE"
;; object2  (build lex "lab animal")
;;
;; a variant which she admits is far from ideal but might be  
;; needed for the purposes of her algorithm.  It is not clear if I 
;; need to use this model.
(describe (assert subclass #labAnimals		 
		  superclass( build lex "lab animal")))

(describe (build act (build lex "research")
		 object *labAnimals) = researchOnLabAnimals)

;;  The verb is used in what appears to be the transitive sense.
(describe (assert object (build lex "research")
		 property (build lex "transitive")))

;; The moment of truth...
^(defn_verb 'research)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Representation of:
;;  "stem cells taken from animal embryos"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Model the animal embryos used in this experiment.  We are unfamiliar with
;; the type or quantity of of animal embryos used so we consider them to be
;; a subclass of the class animal embryo.
(describe ( assert subclass #animalEmbryosInExperiment
		  superclass (build lex "animal embryo")))


;; Specify the subset of stem cells used in this specific research.
;; Assume the class "stem cell" is a basic level category.  The reason
;; for this is twofold:
;; 1. My first impression was that it was basic level.
;; 2. Ehrlich's verb algorithm gives better results with basic level categories
;; as the Agents of actions.  
(describe( assert members #stemCellsInExperiment
		 class (build lex "stem cell")))

;; Define that "stem cell" is a basic level category.
;; This is Ehrlich's model for representing a class as basic level.
(describe ( assert object1 (lex "stem cell")
		  rel ("ISA")
		  object2 (build lex "basic ctgy")))

;; Model the action "taken".  The source arc is not part of Ehrlich's case
;; frames.  However, it is not evident that the source of an action is 
;; important to the functioning of the verb algorithm.
(describe (build action (build lex "take")
		 source *animalEmbryosInExperiment
		 object *stemCellsInExperiment) = takeAction)

;; Show that the set of stem cells is modified by the fact that it is taken
;; from animal embryos.
(describe (build mod takeAction
		 head *stemCellsInExperiment) = stemCellsFromResearch)

;; The moment of truth...
^(defn_verb 'take)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Representation of:
;;  "stem cells taken from animal embryos are astoundingly versatile"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(describe(assert object stemCellsFromResearch
		 property (build lex "astoundingly versatile") 
					= stemCellsAreAstoundinglyVersatile))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Representation of:
;;  "the research itself revealed that stem cells taken from animal embryos
;;   are astoundingly versatile"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Ehrlich's algorithm will return the Agent as being SOMETHING rather than making 
;; an attempt at guessing what the agent might be.  
;; If the user limits himself to using agents that directly or through path based 
;; inference are basic ctg, then the algorithm will return useful results.
;; (Also if the agent is a member of class Animal the algorithm will make a 
;; distinction though it is not helpful here.) 
;; A possible solution is to model researchOnLabAnimals as a basic level category.
;; But how?
(describe( assert agent researchOnLabAnimals
		  act (build lex "reveal")
		  object stemCellsAreAstoundinglyVersatile))

;; Denote reveal as being a transitive verb in this sense.
(describe (assert object (build lex "reveal")
		 property (build lex "transitive")))

;; The moment of truth...
^(defn_verb 'reveal)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Representation of:
;;  "they grow in the lab"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; The use of grow is modeled as a reflexive verb (the agent acts upon itself).
;; Consider these two sentences:
;; "They grew the watermellon."
;;   Ag   Act       Object
;; and
;; "They grow " (themselves) <- Implied(?)
;;   Ag   Act       Object
;;
;; The location relation is an Ehrlich specific relation.
(describe (assert agent stemCellsFromResearch
		  act (build lex "grow")
		  object stemCellsFromResearch
		  location (build lex "lab") = stemCellsGrownInLab))

;; Define grow as being reflexive.  If the Agent associated with grow were
;; a basic ctg or of the class Animal the output would be:
;; "A whatever can grow itself."
(describe(assert object (build lex "grow")
		property(build lex "reflexive")))

;; The moment of truth...
^(defn_verb 'grow)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  Representation of:
;;  "they proliferate like rabbits"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Show that stem cells proliferate.  Here is a major difference from Marc's 
;; original representation.  Marc had the agent representing the conglomerate:
;; "stem cells modified by having been taken from animal embryos."
;; This has two drawbacks:
;; 1.  In the similie "they proliferate like rabbits" they more likely refers
;; to stem cells in general than the specific stem cells obtained from research.
;; This is of course open to debate.
;; 2. Ehrlich's verb algorithm will have difficulty working with an agent that
;; is not a basic ctgy. 
;; Therefore I model the agent as being plain old stem cells. 
(describe(assert agent  *stemCellsInExperiment
		 act (build lex "proliferate")))

;; Define the rabbit subset proliferating.  Consider rabbits to be a basic level category
;; and that stem cells are like a set of these of these rabbits ( a set
;; excluding the Trix bunny, Easter bunny, etc.).
;; This is how Ehrlich represents a collection.
(describe (assert members #rabbits
		  class (build lex "rabbit")))

;; Make rabbits a basic level category 
(describe (assert object1 (build lex "rabbit")
		 rel ("ISA")
		 object2 (build lex "basic ctgy")))
 
;; Show that rabbits proliferate
(describe(assert agent *rabbits
		 act( build lex "proliferate")))

;; Make proliferate intransitive as it can only be inferred that the verb
;; exits and that it has a subject.
(describe (assert object(build lex "proliferate")
		  property(build lex "intransitive")))

;; The moment of truth...
^(defn_verb 'proliferate)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Define a consequence for for the action proliferate.  Ehrlich has a concept
;; of consequence that is very similar to the effect in an action/effect
;; case frame.
;; Model the action proliferate having a consequence as follows:
;; "If r is a rabbit and r proliferates,          <--- Action
;;	then r does some unknown consequence."    <--- Consequence of Action
;; "If r is a stem cell and r proliferates, then r does some unknown consequence."
;;
;; It should be noted that consequences are crucial for Ehrlich's algorithm to
;; give a complete verb definition.  Here I represent a consequence that is,
;; at this point, unknown.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(describe (build lex "unknown consequence for rabbit proliferating") 
					= unknownCqRabbitProliferating)

(describe (assert forall $r
		  &ant ( (build members *r 
				class (build lex "rabbit"))
			 (build agent *r 
				act (build lex "proliferate")))
		  cq (build agent *r 
			    act unknownCqRabbitProliferating )))


;; Proof that the rule is in working order
(describe (deduce agent $x act unknownCqRabbitProliferating ))


(describe (build lex "unknown consequence for stem cell proliferating") 
					= unknownCqStemCellProliferating)

(describe (assert forall $r
		  &ant ( (build members *r 
				class (build lex "stem cell"))
			 (build agent *r 
				act (build lex "proliferate")))
		  cq (build agent *r 
			    act unknownCqStemCellProliferating )))


;; Proof that the rule is in working order
(describe (deduce agent $x act unknownCqStemCellProliferating ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Make an attempt at defining the similie/metaphor relation.
;; Essentially, the unknown consequence for a rabbit proliferating is in a 
;; metaphor/similie action relation to the unknown consequence for a stem cell
;; proliferating on some conceptual level.  
;; Similar to Marc's representation if object1 is viewed as source, object2
;; is viewed as target and rel defines the relation as being a "similie/metaphor"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(describe (assert object1 unknownCqStemCellProliferating
		  rel (build mod ("unknown concept")
	 		     head ("similie/metaphor action"))
		  object2 unknownCqRabbitProliferating ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; object1/rel/object2 can have further meaning if we create a specific rule 
;; with which to interpret the case frame when rel points to a "similie/metaphor
;; action".  For instance:
;; "If 
;;	conseqeunce x and consequnece y are in a "simile/metaphor action" relation 
;; 	modified by context z,
;; then 
;;	similarities exist between consequence x and consequence y based on the 
;;	context z."
;; 
;; For instance if the sentence were "Juliet runs like a deer." then there are
;; two consequences for running (or less, depending on how it is modeled.)  The
;; consequences could be:
;; 1. If Juliet runs she moves from point A to point B quickly.
;; 2. If a deer runs it moves from point A to point B quickly.
;; Both of these consequences would be similar based on the concept of 
;; "gracefullness."
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(describe ( assert forall ($x $y $z)
	    	   &ant (build object1 *x 
			       rel (build mod *z
		               	      	  head ("similie/metaphor action"))	
 		   	       object2 *y  ) 
	    	   cq (build head (build agent (build lex "similarity(s)") 
		      		    	 act (build lex "exist between")
		      		  	 object *y
		        	  	 object *x)
		       	     mod *z)))

;; Proof that the rule is in working order
(describe (deduce head (build act (build lex "exist between"))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; "They turn into specialized cells such as neurons."
;; Define the neurons and specialized cells
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Make neurons basic level
(describe ( assert object1 (build lex "neuron")
		  rel ("ISA")
		  object2 (build lex "basic ctgy")))

;; Make neurons a subclass of specialized cells
(describe (assert subclass (build lex "neuron")
		  superclass (build lex "specialized cell")))

;; Model the neurons in research as a collection of the class neuron.
;; Uses an Ehrlich specific case frame.
(describe (assert members #neurons
		  class (build lex "neuron")))

;; Model the action of turning into something.
(describe (assert agent stemCellsFromResearch
		  act (build lex "turn into")
		  object *neurons))

(describe (build object(build lex "turn into")
		 property (build lex "transitive")))

;; The moment of truth...
^(defn_verb 'proliferate)