; Lunarso Sutanto
; CVA Project

(resetnet t)
^(setq snip:*infertrace* nil)

; Define case frames

; load all pre-defined relations:
(intext "/projects/rapaport/CVA/STN2/demos/rels")

; load all pre-defined path definitions:
(intext "/projects/rapaport/CVA/mkb3.CVA/paths/paths")


(define 
	object propername
	lex 
	member class 
	subclass superclass 
	object property
	agent act event
		action direction 
	synonym
 	time
	before after
)

 ^(load "/projects/rapaport/CVA/STN2/defun_verb.cl")



;; ============================
;; ORIGINAL PASSAGE, UNMODIFIED
;; ============================

; "The dark figure streaming with fire raced towards them. The orcs yelled and
; poured over the stone gangways. Then Boromir raised his horn and blew. 
; Loud the challenge rang and bellowed, like the shout of many throats under
; the cavernous roof. For a moment the orcs *quailed* and the fiery shadow 
; halted. Then the echoes died as suddenly as a flame blown out by a dark 
; wind, and the enemy advanced again."


; The fiery shadow raced towards Boromir
; --------------------------------------
; "The dark figure streaming with fire" is changed to "fiery shadow"
; "them" is changed to simply "Boromir"

(describe (assert propername (build lex "Boromir") object #boromir))

(describe (assert member #shadow class (build lex "shadow")))


(describe (assert object *shadow property (build lex "fiery")))

(describe (assert agent *shadow 
		  act (build action (build lex "race") = race
		  direction *boromir)
		  time #time-of-event-1))


; The orcs yelled and advanced towards Boromir
; --------------------------------------------------------------
; The orcs are a particular subclass of orcs,
; particularly the orcs in the Mines of Moria that were chasing after the 
; Fellowship/ Boromir

(describe (assert subclass #orcs superclass (build lex "orcs"))) 

(describe (assert agent *orcs 
		  act (build action (build lex "yell"))
		  time *time-of-event-1))

(describe (assert agent *orcs
		  act (build action (build lex "advance") = advance
		  direction *boromir)
		  time *time-of-event-1))


; Boromir blew his horn, which challenged the orcs
; ------------------------------------------------

(describe (assert member #horn class (build lex "horn")))

(describe (assert agent *boromir 
		  act (build action (build lex "blow") 
 		  object *horn) = blowaction
		  time #time-of-event-2))

; Notice I labelled the act of blowing the horn as *blowaction, which will
; help in the SNePSUL-ization of "challenging the orcs"
; So the agent that challenged the orcs is the act of blowing the horn

(describe (assert agent *blowaction
		  act (build action (build lex "challenge")
	     	  object *orcs)
		  time *time-of-event-2))


; For a moment, the orcs quailed and the fiery shadow halted.
; ----------------------------------------------------------

(describe (assert agent *orcs
		  act (build action (build lex "quail")) = quail
		  time #time-of-event-3))
; QUAILED is the word that we are trying to define

(describe (assert agent *shadow
		  act (build action (build lex "halt")) = halt
		  time *time-of-event-3))
; This is the main connection, the fact that halted and quailed are nearly
; synonyms.


; TIME AXIOMS
; -----------

(describe (assert before *time-of-event-1 after *time-of-event-2))

(describe (assert before *time-of-event-2 after *time-of-event-3))



; ====================
; BACKGROUND KNOWLEDGE
; ====================

(describe (add synonym *advance synonym *race))

(describe (add forall ($x $y $w
		       $initial-action-1 $initial-action-2
		       $some-act
		       $final-act-1 $final-act-2
		       $t1 $t2 $t3)

	       &ant   ((build before *t1 after *t2)
		       (build before *t2 after *t3)
		       (build agent *x
			      act (build action *initial-action-1 direction *w)
			      time *t1)
		       (build agent *y
			      act (build action *initial-action-2 direction *w)
			      time *t1)
		       (build act *some-act time *t2)
		       (build agent *x 
			      act (build action *final-act-1)
			      time *t3) 
		       (build agent *y
			      act (build action *final-act-2)
			      time *t3)
		       (build synonym *initial-action-1 
			      synonym *initial-action-2))
		; advancing and racing should be the same thing

	       cq     (build synonym *final-act-1 synonym *final-act-2)))