;;; This is the set of assertions which build the base network which    
;;; corresponds to the "celidh" passage.    




;Gathering is subclass of events.
(describe (assert subclass (build lex gathering) superclass (build lex event)))

;meal is subclass of food.
(describe (assert subclass (build lex meal) superclass (build lex food)))


;;;
;;; rules
;;;

;Ill-deressed people are people.
(describe 
 (assert forall $p
	ant (build member *p class (build mod (build lex ill-dressed) 
					  head (build lex people)))
	cq (build member *p class (build lex people))))




;Common meals are meals.
(describe 
 (assert forall $x
	ant (build member *x class (build mod (build lex common)
					  head (build lex meal)))
	cq (build member *x class (build lex meal))))




;If something is a member of class fire, then this thing is probably outdoor.
(describe 
 (assert forall $y
	ant (build member *y class (build lex fire))
	cq (build mode (build lex presumably)
		  object (build object *y location (build lex outdoor)))))




;If something is around another thing that is probably outdoor, then this thing is probably outdoor.
(describe 
 (assert forall ($z *y)
	&ant ((build object1 *z rel (build lex around) object2 *y)
	      (build mode (build lex presumably)
                     object (build object *y location (build lex outdoor))))
	cq (build mode (build lex presumably)
	          object (build object *z location (build lex outdoor)))))




;If someone sit at some place which is probably outdoor at a time, then this someone is probably outdoor at this time.
(describe
 (assert forall (*p *z $t)
	&ant ((build agent *p act (build action (build lex sit)) location *z time *t)
              (build mode (build lex presumably)
                     object (build object *z location (build lex outdoor))))
	cq (build mode (build lex presumably)
  		  object (build object *p location (build lex outdoor) time *t))))




;If something is a member of meal, someone is a member of person eats it, then the person eats it shortly after it is almost ready.
(describe
 (assert forall (*p *x $t1 $t2 $sub1 $sub2)
	&ant ((build member *x class (build lex meal))
	      (build member *p class (build lex people))
	      (build object *x property 
			(build mod (build lex almost) head (build lex ready))
		     time *t1)
	      (build subinterval *sub1 superinterval *t1)
	      (build agent *p act (build action (build lex eat) object *x)
                     time *t2)
	      (build subinterval *sub2 superinterval *t2))
	cq (build before *sub1 after *sub2 duration (build lex short))))



;If something is over at a time, then this time is its end time.
(describe 
 (assert forall ($sth $super $fsub)
	&ant ((build agent *sth act (build action (build lex finish)) 
                     time *fsub)
	      (build object *sth time *super))
	cq (build final-subinterval *fsub superinterval *super)))



;If something has an end time, then it has an initial time which is before the end time.
(describe 
 (assert forall (*sth *super *fsub)
	&ant ((build object *sth time *super)
	      (build final-subinterval *fsub superinterval *super))
	cq ((build initial-subinterval (build skf "initial-time-of" arg2 *super)
					= itime 
		   superinterval *super)
	    (build before *itime after *fsub))))



;If a time period has a subinterval, an initial-subinterval, then the iniital subinterval is before the subinterval.
(describe 
 (assert forall ($isub $sub *super)
	&ant ((build subinterval *sub superinterval *super)
	      (build initial-subinterval *isub superinterval *super))
	cq (build before *isub after *sub)))




;If a time period has a subinterval, an final-subinterval, then the final subinterval is after the subinterval.
(describe 
 (assert forall (*fsub *sub *super)
	&ant ((build subinterval *sub superinterval *super)
	      (build final-subinterval *fsub superinterval *super))
	cq (build before *sub after *fsub)))




;If something has an initial time and an end time, and the initial time is before the end time, then this thing is a member of event.
(describe 
 (assert forall (*sth *super *isub *fsub)
	&ant ((build object *sth time *super)
	      (build initial-subinterval *isub superinterval *super)
	      (build final-subinterval *fsub superinterval *super)
	      (build before *isub after *fsub))
	cq (build member *sth class (build lex event))))

 


;If something is an event and part of another unknown class, then probably the class is a subclass of event.
(describe 
 (assert forall (*sth $cls)
	&ant ((build member *sth class *cls)
	      (build object *cls property (build lex unknown))
	      (build member *sth class (build lex event)))
	cq (build mode (build lex presumably)
	  	  object (build subclass *cls superclass (build lex event)))))




;If something is probably a gathering and part of another unknown class, then probably the class is a subclass of gathering.
(describe 
 (assert forall (*sth *cls)
	&ant ((build member *sth class *cls)
	      (build object *cls property (build lex unknown))
	      (build mode (build lex presumably)
		     object (build member *sth class (build lex gathering))))
	cq (build mode (build lex presumably)
	 	  object (build subclass *cls superclass (build lex gathering)))))




;If something is an event, and it is brief, then the duration between its initial time and final time is short.
(describe 
 (assert forall (*sth *super *isub *fsub)
	&ant ((build member *sth class (build lex event))
	      (build object *sth property (build lex brief))
	      (build object *sth time *super)
	      (build initial-subinterval *isub superinterval *super)
	      (build final-subinterval *fsub superinterval *super))
	cq (build before *isub after *fsub duration (build lex short))))




;If time1 is before time2 and time2 is before time3, then time1 is before time3.
(describe 
 (assert forall ($time1 $time2 $time3)
	&ant ((build before *time1 after *time2)
	      (build before *time2 after *time3))
	cq (build before *time1 after *time3)))




;If time1 is long time before time2, and time2 is before time3, then time1 is long time before time3.
(describe 
 (assert forall (*time1 *time2 *time3)
	&ant ((build before *time1 after *time2 duration (build lex long\ time))
	      (build before *time2 after *time3))
	cq (build before *time1 after *time3 duration (build lex long\ time))))




;If time1 is long time before time3, and time2 is short before time3, then time1 is long time before time2.
(describe 
 (assert forall (*time1 *time2 *time3)
 	&ant ((build before *time1 after *time3 duration (build lex long\ time))
	      (build before *time2 after *time3 duration (build lex short)))
	cq (build before *time1 after *time2 duration (build lex long\ time))))




;If time1 is before time2, time2 is before time3, and time1 is short before time3, then time1 is short before time2 and time2 is short before time3.
(describe 
 (assert forall (*time1 *time2 *time3)
	&ant ((build before *time1 after *time3 duration (build lex short))
	      (build before *time1 after *time2)
	      (build before *time2 after *time3))
	cq ((build before *time1 after *time2 duration (build lex short))
	    (build before *time2 after *time3 duration (build lex short)))))




;If time1 is one year before time3, and time2 is short before time3, then time1 is one year before time2.
(describe 
 (assert forall (*time1 *time2 *time3)
 	&ant ((build before *time1 after *time3 duration (build lex "one year"))
	      (build before *time2 after *time3 duration (build lex short)))
	cq (build before *time1 after *time2 duration (build lex "one year"))))
 



;If there is any time interval between the initial subinterval and the final subinterval of something, then this time interval is the subinterval of this thing.
(describe 
 (assert forall (*super *isub *fsub *sub)
	&ant ((build before *isub after *sub)
	      (build before *sub after *fsub)
	      (build initial-subinterval *isub superinterval *super)
	      (build final-subinterval *fsub superinterval *super))
	cq (build subinterval *sub superinterval *super)))




;If some person tells his past year at a time, he tells story at this time.
(describe 
 (assert forall (*p *t)
	ant (build agent *p act (build action (build lex tell) 
				       object (build skf "past-year-of" arg2 *p))
		   time *t)
	cq (build agent *p act (build action (build lex tell)
				      object (build lex story)) time *t)))




;If there is subinterval of something, and during this interval people eat and tell story, then probably this thing is a gathering.
(describe 
 (assert forall (*sth $sup1 *sub $sup2 *p $food)
	&ant ((build object *sth time *sup1)
	      (build subinterval *sub superinterval *sup1)
	      (build subinterval *sub superinterval *sup2)
	      (build member *p class (build lex people))
	      (build member *food class (build lex food))
	      (build time *sup2 agent *p act (build action (build lex eat)
							object *food))
	      (build time *sup2 agent *p 
		     act (build action (build lex tell) object (build lex story))))
	cq (build mode (build lex presumably)
		  object (build member *sth class (build lex gathering)))))




;If some person tells another person of his past year at a time, then they meet at this time, and they meet at another time whose final interval is one year before this time.
(describe 
 (assert forall (*p $p2 $super2 *sub2)
	&ant ((build agent *P 
		     act (build action (build lex tell)
				object (build skf "past-year-of" arg2 *p))
		     to *p2
		     time *super2)
	      (build subinterval *sub2 superinterval *super2))
	cq ((build last (build agent *p 
		   		act (build action (build lex meet) object *p2)
		   		time (build skf "last-meet-time-of" arg2 *p) 
                                     	= lastmeettime)
	    	   next (build agent *p
	           		act (build action (build lex meet) object *p2)
		   		time (build skf "this-meet-time-of" arg2 *p) 
				       	= thismeettime))
 	    (build subinterval *sub2 superinterval *thismeettime)
	    (build final-subinterval (build skf "final-time-of" arg2 *lastmeettime)
				      = finalmeettime
		   superinterval *lastmeettime)
	    (build before *finalmeettime
		   after *sub2
		   duration (build lex "one year")))))
			



;If at one time some person found another person changed greatly, and the change happened during a period of time, then they had last meeting which finished at the time when the change began, and they had this meeting which happened at this time.
(describe 
 (assert forall (*p *p2 $super4 $sub4 $ctime $itime)
	&ant ((build agent *p2
		     act (build action (build lex find)
			        object (build agent *p
					      act (build action 
							(build mode (build lex greatly)
                                         		       head (build lex change)))
					      time *ctime))
		     time *super4)
	      (build subinterval *sub4 superinterval *super4)
	      (build initial-subinterval *itime superinterval *ctime))
	cq ((build last (build agent *p
			       act (build action (build lex meet) object *p2)
			       time (build skf "last-meet-time" arg2 *p)
					= lastmeettime)
		   next (build agent *p 
			      act (build action (build lex meet) object *p2)
			      time (build skf "this-meet-time" arg2 *p)
					= thismeettime))
	    (build subinterval *sub4 superinterval *thismeettime)
	    (build final-subinterval *itime superinterval *lastmeettime)
	    (build before *itime after *sub4 duration (build lex "long time")))))



;If some person had last meeting with another person, then had the next meet with the same person one year later, and if he had a third meeting with the same person short before the next meeting, then the third meeting and the next meeting are actually the same meeting.		
(describe
 (assert forall (*p *p2 $super1 $super2 *super4 *sub1 *sub2 *sub4)
	&ant ((build last (build agent *p
				 act (build action (build lex meet) object *p2)
				 time *super1)
                     next (build agent *p 
  				 act (build action (build lex meet) object *p2)
		                 time *super2))
	      (build agent *p
		     act (build action (build lex meet) object *p2)
		     time *super4)
	      (build final-subinterval *sub1 superinterval *super1)
 	      (build subinterval *sub2 superinterval *super2)
 	      (build subinterval *sub4 superinterval *super4)
	      (build before *sub1 after *sub2 duration (build lex "one year"))
	      (build before *sub4 after *sub2 duration (build lex short)))
	cq (build equiv (build agent *p 
			       act (build action (build lex meet) object *p2)
			       time *super2)
		  equiv (build agent *p 
			       act (build action (build lex meet) object *p2)
			       time *super4))))



;If proposition1 is the last one of proposition2, proposition3 is the last one of proposition4, and proposition2 and proposition4 are same, then proposition1 and proposition3 are same.	
(describe 
 (assert forall ($pp1 $pp2 $pp3 $pp4)
       	&ant ((build last *pp1 next *pp2)
	      (build last *pp3 next *pp4)
	      (build equiv *pp2 equiv *pp4))
	cq (build equiv *pp1 equiv *pp3)))




;If some person meets another person at one time, and he meets the same person at another time, and the two meetings are actually the same meeting, then these two time periods have the same final time interval.
(describe 
 (assert forall (*p *p2 *super1 $super3 *sub1 $sub3)
	&ant ((build equiv (build agent *p
				 act (build action (build lex meet) object *p2)
				 time *super1)
	             equiv (build agent *p
				 act (build action (build lex meet) object *p2)
				 time *super3))
	      (build final-subinterval *sub1 superinterval *super1)
 	      (build final-subinterval *sub3 superinterval *super3))
	cq (build equiv *sub1 equiv *sub3)))




;If sub1 and sub3 are same time interval, and sub1 is before sub2 for a period of time, then sub3 is before sub2 for the same period of time.
(describe
 (assert forall (*sub1 *sub2 *sub3 $d)
 	&ant ((build equiv *sub1 equiv *sub3)
 	      (build before *sub1 after *sub2 duration *d))
	cq (build before *sub3 after *sub2 duration *d)))