^(load "/projects/stn2/CVA/defun_noun.cl") 

;set trace level
^(setTraceLevel 4)


; Reset the network
(resetnet t)


^(in-package snip)


^(defun broadcast-one-report (rep)
   (let (anysent)
     (do.chset (ch *OUTGOING-CHANNELS* anysent)
	       (when (isopen.ch ch)
		 (setq anysent (or (try-to-send-report rep ch) anysent)))))
		 nil)



^(in-package sneps)

(intext "/projects/stn2/CVA/demos/rels")


;relations (some will be duplicated)
(define member class superclass subclass agent act action property object object1 object2 rel possessor lex skf skarg skarg1 skarg2 skarg3 cause effect)


;==============================================================
;Background Knowledge
;(Although this is included within this same file, it should
;ideally be "added" as part of a different file)
;==============================================================



;This rule states that if leaders possess three objects
;and two of the objects are abstract objects, then the third
;one is also an abstract object ("men of wisdom, judgment and sagacity")
(describe (assert forall ($a $b $c $d $e $f $g)
	  &ant(
	  	(build member *a class (build lex "leaders"))
	  	(build subclass *b superclass (build lex "abstract_object"))
	  	(build subclass *c superclass (build lex "abstract_object"))
	  	(build member *e class *b)
	  	(build member *f class *c)
	  	(build member *g class *d)
	  	(build object *e possessor *a)
	  	(build object *f possessor *a)
	  	(build object *g possessor *a)
	      )	
	  cq(build subclass *d superclass (build lex "abstract_object"))
	 )
)



;leaders with wisdom make good decisions when there is a problem
(describe (assert forall ($h $i $j)
	   &ant
	   (
	    (build member *h class (build lex "leaders"))
	    (build member *i class (build lex "wisdom"))
	    (build member *j class (build lex "problem"))
	    (build object *i rel (build lex "wisdom") possessor *h)
	    
	   )
	   cq(build member (build skf decision skarg1 *h skarg2 *i) class (build lex "decision"))
	   cq(build agent *h act (build action (build lex "make") object (build skf decision skarg1 *h skarg2 *i)))
	   cq(build object (build skf decision skarg1 *h skarg2 *i) property (build lex "good"))
	   )
)




;leaders with judgment make good decisions when there is a problem
(describe (assert forall (*h $k *j)
	   &ant
	   (
	    (build member *h class (build lex "leaders"))
	    (build member *k class (build lex "judgment"))
	    (build member *j class (build lex "problem"))
	    (build object *k rel (build lex "judgment") possessor *h) 
	   )
	   cq(build object (build skf decision skarg1 *h skarg2 *k) class (build lex "decision"))
	   cq(build agent *h act (build action (build lex "make") object (build skf decision skarg1 *h skarg2 *k)))
	   cq(build object (build skf decision skarg1 *h skarg2 *k) property (build lex "good"))
	   )
)



;This rule uses information about two objects in apposition 
;with a third as in the context "men of wisdom, judgment and
;sagacity."  If leaders possess three abstract objects, and if
; possessing the first object leads to making a
;good decision based on that object, and possessing the second
;object leads to making a good decision based on that object,
;then possessing the third leads to making a good decision based
;on that object.
(describe (assert forall ($l $m $n $o $p $q $r $s)
	   &ant
	   (
	    (build member *l class (build lex "leaders"))
	    (build subclass *q superclass (build lex "abstract_object"))
	    (build subclass *r superclass (build lex "abstract_object"))
	    (build subclass *s superclass (build lex "abstract_object"))
	    (build member *m class *q)
	    (build member *n class *r)
	    (build member *o class *s)
	    (build object *m possessor *l)
	    (build object *n possessor *l)
	    (build object *o possessor *l)
	    (build member *p class (build lex "problem"))
	    (build agent *l act (build action (build lex "discuss") object *p))
	    (build agent *l act (build action (build lex "make") object (build skf decision skarg1 *l skarg2 *m)))
	    (build agent *l act (build action (build lex "make") object (build skf decision skarg1 *l skarg2 *n)))
	    (build object (build skf decision skarg1 *l skarg2 *m) property (build lex "good"))
	    (build object (build skf decision skarg1 *l skarg2 *n) property (build lex "good"))
	   
	   )
	   cq(build agent *l act (build action (build lex "make") object (build skf decision skarg1 *l skarg2 *o)))
	   cq(build object (build skf decision skarg1 *l skarg2 *o) property (build lex "good"))
	   cq(build subclass *q superclass (build lex "decision_utility")) 
	   cq(build subclass *r superclass (build lex "decision_utility")) 
	   cq(build subclass *s superclass (build lex "decision_utility")) 
	  )
)

;=============================================================================
;Main Program
;=============================================================================


;skolem function node leaders is a member of the class "leaders"
(describe (add member (build skf leaders skarg (build lex "leaders"))=leaderskf class (build lex "leaders")))


;The leaders are men
(describe (add object *leaderskf property (build lex "male")))


;concept node wisdom is a subclass of abstract_object
(describe (add subclass (build lex "wisdom") superclass (build lex "abstract_object")))

;concept node judgment is a subclass of abstract_object
(describe (add subclass (build lex "judgment") superclass (build lex "abstract_object")))


;skolem function node wisdom is a member of the class "wisdom"
(describe (add member (build skf wisdom skarg *leaderskf) = wisdomskf class (build lex "wisdom")))


;skolem function node judgment is a member of the class "judgment"
(describe (add member (build skf judgment skarg *leaderskf) = judgmentskf class (build lex "judgment")))


;skolem function node sagacity is a member of the class "sagacity"
(describe (add member (build skf sagacity skarg *leaderskf) = sagacityskf class (build lex "sagacity")))


;The leaders of the tribe
(describe (add object *leaderskf rel (build lex "leaders") possessor (build skf tribe skarg (build lex "tribe"))=tribeskf))

;Men of wisdom, judgment and sagacity

;men of wisdom
(describe (add object *wisdomskf rel (build lex "wisdom") possessor *leaderskf))

;men of judgment
(describe (add object *judgmentskf rel (build lex "judgment") possessor *leaderskf))

;men of sagacity
(describe (add object *sagacityskf rel (build lex "sagacity") possessor *leaderskf))



;were now discussing the problem

(describe (add member (build skf problem skarg *leaderskf) = problemskf class (build lex "problem")))

(describe (add agent *leaderskf act (build action (build lex "discuss") object *problemskf)))


;=====================================================================
;Noun-definition algorithm
;=====================================================================
^(defineNoun "sagacity")