;;; Knowledge Base for initial cat demo

;;; Harts are deer
(describe
(assert subclass (build lex "hart")
	superclass (build lex "deer")))

;;; Halls are buildings
(describe
(assert	subclass (build lex "hall")
	superclass (build lex "building")))

;;; Hounds are dogs
(describe
(assert subclass (build lex "hound")
	superclass (build lex "dog")))

;;; Dogs are mammals
(describe
(assert subclass (build lex "dog")
	superclass (build lex "mammal")))

;;; Dogs are quadrupeds
(describe
(assert subclass (build lex "dog")
	superclass (build lex "quadruped")))

;;; Dogs are carnivores
(describe
(assert subclass (build lex "dog")
	superclass (build lex "carnivore")))

;;; Dogs are predators
(describe
(assert subclass (build lex "dog")
	superclass (build lex "predator")))

;;; Dogs are animals
(describe
(assert subclass (build lex "dog")
	superclass (build lex "animal")))

;;; Rex is a dog
;;; (Ehrlich never had an object - proper-name case frame for Rex)

(describe
(assert member #Rex 
	class (build lex "dog")))

(describe
(assert object *Rex
	proper-name (build lex "Rex")))

;;; Rex belongs to a person

(describe
(assert object *Rex
	possessor #person1
	rel (build lex "dog")))

(describe
(assert member *person1
	class (build lex "person")))

;;; Deer are mammals
(describe
(assert subclass (build lex "deer")
	superclass (build lex "mammal")))

;;; Deer are quadrupeds
(describe
(assert subclass (build lex "deer")
	superclass (build lex "quadruped")))

;;; Deer are herbivores
(describe
(assert subclass (build lex "deer")
	superclass (build lex "herbivore")
	))

;;; Carnivores are animals
(describe
(assert subclass (build lex "carnivore")
	superclass (build lex "animal")
	))

;;; Predators are carnivores
(describe
(assert subclass (build lex "predator")
	superclass (build lex "carnivore")
	))

;;; "Herbivore" and "carnivore" are antonyms
(describe
(assert antonym (build lex "herbivore")
	antonym (build lex "carnivore")))

;;; "Predator" and "carnivore" are antonyms
(describe 
(assert antonym (build lex "predator")
	antonym (build lex "carnivore")))

;;; Mammals are animals	
(describe
(assert subclass (build lex "mammal")
	superclass (build lex "animal")
	))

;;; Mammals are vertebrates
(describe 
(assert subclass (build lex "mammal")
	superclass (build lex "animal")
	))

;;; Quadrupeds are vertebrates
(describe
(assert subclass (build lex "quadruped")
	superclass (build lex "vertebrate")
	))

;;; Animals are physical objects
(describe
(assert subclass (build lex "animal")
	superclass (build lex "phys obj")
	))

;;; The Round Table is a table
(describe
(assert member (build lex "Round Table")
	class (build lex "table")
	))

;;; King Arthur is a king
(describe
(assert object #KingArt
	proper-name (build lex "King Arthur")
	))
        
(describe
(assert object1 *KingArt
	rel "ISA"
	object2 (build lex "king")
	))

;;; The Round Table is King Arthur's table
(describe
(assert object (build lex "Round Table")
	possessor *KingArt
	rel (build lex "table")
	))

;;; Excalibur is a sword
(describe
(assert object #Excal
	proper-name (build lex "Excalibur")
	))

(describe
(assert member *Excal
	class (build lex "sword")
	))

;;; Excalibur is King Arthur's sword
(describe
(assert object *Excal
	possessor *KingArth
	rel (build lex "sword")
	))

;;; Merlin is a wizard
(describe
(assert object #Merlin
	proper-name (build lex "Merlin")
	))

(describe
(assert object1 *Merlin
	rel "ISA"
	object2 (build lex "wizard")
	))

;;; Wizards are persons
(describe
(assert subclass (build lex "wizard")
	superclass (build lex "person")
	))

;;; King Ban is a king
(describe
(assert object #KingBan
	proper-name (build lex "King Ban")
	))

(describe
(assert object1 *KingBan
	rel "ISA"
	object2 (build lex "king")
	))

;;; King Bors is a king
(describe
(assert object #KingBors
	proper-name (build lex "King Bors")
	))

(describe
(assert object1 *KingBors
	rel "ISA"
	object2 (build lex "king")
	))

;;; King Lot is a king
(describe
(assert object #KingLot
	proper-name (build lex "King Lot")
	))

(describe
(assert object1 *KingLot
	rel "ISA"
	object2 (build lex "king")
	))

;;; Sir Galahad is a knight
(describe
(assert object #SirGal
	proper-name (build lex "Sir Galahad")
	))

(describe
(assert object1 *SirGal
	rel "ISA"
	object2 (build lex "knight")
	))

;;; Sir Gawain is a knight
(describe
(assert object #SirGaw
	proper-name (build lex "Sir Gawain")
	))

(describe
(assert object1 *SirGaw
	rel "ISA"
	object2 (build lex "knight")
	))

;;; Sir Tristram is a knight
(describe
(assert object #SirTris
	proper-name (build lex "Sir Tristram")
	))

(describe
(assert object1 *SirTris
	rel "ISA"
	object2 (build lex "knight")
	))

;;; Sideboards are furniture
(describe
(assert subclass (build lex "sideboard")
	superclass (build lex "furniture")
	))

;;; Tables are furniture
(describe
(assert subclass (build lex "table")
	superclass (build lex "furniture")
	))

;;; Chairs are furniture
(describe
(assert subclass (build lex "chair")
	superclass (build lex "furniture")
	))

;;; Horses are quadrupeds
(describe
(assert subclass (build lex "horse")
	superclass (build lex "quadruped")
	))

;;; Horses are herbivores
(describe
(assert subclass (build lex "horse")
	superclass (build lex "herbivore")
	))

;;; Ungulates are herbivores
(describe
(assert subclass (build lex "ungulate")
	superclass (build lex "herbivore")
	))

;;; Horses are animals
(describe
(assert subclass (build lex "horse")
	superclass (build lex "animal")
	))

;;; Knights are persons
(describe
(assert subclass (build lex "knight")
	superclass (build lex "person")
	))

;;; "Person" is a basic-level category
(describe
(assert object1 (build lex "person")
	rel "ISA"
	object2 (build lex "basic ctgy")
	))

;;; "Dog" is a basic-level category
(describe
(assert object1 (build lex "dog")
	rel "ISA"
	object2 (build lex "basic ctgy")
	))

;;; "Horse" is a basic-level category
(describe
(assert object1 (build lex "horse")
	rel "ISA"
	object2 (build lex "basic ctgy")
	))

;;; "Deer" is a basic-level category
(describe
(assert object1 (build lex "deer")
	rel "ISA"
	object2 (build lex "basic ctgy")
	))

;;; "Chair" is a basic-level category
(describe
(assert object1 (build lex "chair")
	rel "ISA"
	object2 (build lex "basic ctgy")
	))

;;; "Table" is a basic-level category
(describe
(assert object1 (build lex "table")
	rel "ISA"
	object2 (build lex "basic ctgy")
	))

;;; White is a colour
(describe
(assert member (build lex "white")
	class (build lex "colour")
	))

;;; Black is a colour
(describe
(assert member (build lex "black")
	class (build lex "colour")
	))

;;; Small is a size
(describe
(assert member (build lex "small")
	class (build lex "size")
	))

;;; "Small" and "little" are synonyms
(describe
(assert synonym (build lex "small")
	synonym (build lex "little")
	))

;;; Large is a size
(describe
(assert member (build lex "large")
	class (build lex "size")
	))

;;; "Large" and "big" are synonyms
(describe
(assert synonym (build lex "large")
	synonym (build lex "big")
	))

;;; Good is a value
(describe
(assert member (build lex "good")
	class (build lex "value")
	))

;;; Bad is a value
(describe
(assert member (build lex "bad")
	class (build lex "value")
	))

;;; If something is a hound, then presumably its function is to hunt
(describe
(assert forall $v1
	ant (build object1 *v1 
		     object2 (build lex "hound")
	             rel "ISA")
	cq (build mode (build lex "presumably")
	          object (build agent *v1
                                act (build lex "hunt")))))

;;; If x is a horse, then presumably there is a person, y, such that the
;;;    function of x is to be ridden by y
(describe
(assert forall $v2
	ant (build member *v2
	           class (build lex "horse"))
	cq ((build mode (build lex "presumably")
	           object (build object1 *v2
                                 object2 (build agent (build a2 *v2
							    skf "rider-of")
					        act (build lex "ride")
					        object *v2)
				rel (build lex "function")))
	    (build mode (build lex "presumably")
		   object (build member (build a2 *v2
                                               skf "rider-of")
				 class (build lex "person"))))))

;;; If a rider rides an animal that belongs to some class, then that class is 
;;;    a subclass of equine

(describe
(assert forall (*v2 $v3)
	&ant ((build member *v2
	             class (build lex "animal"))
	      (build object1 *v2
	             object2 *v3
		     rel "ISA")
	      (build member (build a2 *v2
                                   skf "rider-of")
                     class (build lex "person"))
	      (build agent (build a2 *v2
                                  skf "rider-of")
                     act (build action (build lex "ride")
	             		object *v2)))
	cq (build subclass *v3
		  superclass (build lex "equine"))))
		 
;;; If an animal belonging to some class bays, then it is a hound, and the 
;;; class to which it belongs is a subclass of
;;; (Ehrlich makes an error in her dissertation when representing this)

(describe
(assert forall (*v1 $v4)
	&ant ((build agent *v1
	             act (build lex "bay"))
	      (build object1 *v1
		     object2 *v4
		     rel "ISA")
	      (build subclass *v4
                     superclass (build lex "animal")))
	cq ((build object1 *v1
	           object2 (build lex "hound")
	           rel "ISA")
	    (build subclass *v4
		   superclass (build lex "hound")))
	))

;;; If something bites, then it's an animal

(describe
(assert forall $v5
	ant (build act (build lex "bite")
	           agent *v5)
	cq (build member *v5 
		  class (build lex "animal"))))

;;; If something sleeps, then it's an animal

(describe
(assert forall *v5
	ant (build act (build lex "sleep")
	 	   agent *v5)
	cq (build member *v5
		  class (build lex "animal"))
	))

;;; If something ambles, then it's an animal

(describe
(assert forall *v5
	ant (build act (build lex "ambling")
		   agent *v5)
	cq (build member *v5
		  class (build lex "animal"))
	))

;;; If something is an animal and a member of another class, then that class
;;;    is a subclass of animal

(describe
(assert forall (*v5 $v6)
	&ant ((build member *v5
		     class (build lex "animal"))
	      (build member *v5
		     class *v6))
	cq (build subclass *v6
		  superclass (build lex "animal"))
	))

(describe
(assert forall (*v5 *v6)
	&ant ((build member *v5
		     class (build lex "animal"))
	      (build object1 *v5
		     object2 *v6
	     	     rel "ISA"))
	cq (build subclass *v6
		  superclass (build lex "animal"))))

;;; If something is presumed to be an animal and a member of another class,
;;;    then presumably that class is a subclass of animal

(describe
(assert forall (*v5 *v6)
	&ant ((build mode (build lex "presumably")
	             object (build member *v5
	                           class (build lex "animal")))
	      (build member *v5 
		     class *v6))
	cq (build mode (build lex "presumably")
		  object (build subclass *v6
			        superclass (build lex "animal")))
	))

(describe
(assert forall (*v5 *v6)
	&ant ((build mode (build lex "presumably")
		     object (build member *v5
				   class (build lex "animal")))
	      (build object1 *v5
		     object2 *v6
		     rel "ISA"))
	cq (build mode (build lex "presumably")
		  object (build subclass *v6
			        superclass (build lex "animal")))
	))

;;; If something is a mammal and a member of another (non-superordinate) class,
;;;    then that class is a subclass of mammal

(describe
(assert forall (*v5 *v6)
	&ant ((build member *v5 
		     class *v6)
	      (build object1 *v5
		     object2 (build lex "mammal")
		     rel "ISA"))
	cq ((build subclass *v6
		   superclass (build lex "animal"))
	    (build subclass *v6
		   superclass (build lex "mammal")))
	))

(describe
(assert forall (*v5 *v6)
	&ant ((build object1 *v5
		     object2 *v6
		     rel "ISA")
	      (build object1 *v5
		     object2 (build lex "mammal")
		     rel "ISA"))
	cq ((build subclass *v6
		   superclass (build lex "animal"))
	    (build subclass *v6
		   superclass (build lex "mammal")))
	))

(describe
(assert forall $v7
	ant ((build member *v7
		     class (build lex "horse"))
	      (build member *v7
		     class (build lex "dog"))
	      (build member *v7
		     class (build lex "deer")))
	cq (build member *v7
		  class (build lex "animal"))
	))


;;; If someone belongs to a subclass of person then that someone is a person
(describe 
(assert forall ($v8 $v9)
	&ant ((build subclass *v8
		     superclass (build lex "person"))
	      (build member *v9
		     class *v8))
	cq (build member *v9
		  class (build lex "person"))
))

(describe
(assert forall (*v8 *v9)
	&ant ((build subclass *v8
		     superclass (build lex "person"))
	      (build object1 *v9
	 	     object2 *v8
		     rel "ISA"))
	cq (build member *v9
		  class (build lex "person"))
	))

;;; If something belongs to a subclass of a basic category, then it's a member
;;;    of that category

(describe
(assert forall ($v10 $v11 $v12)
	&ant ((build object1 *v12
		     object2 (build lex "basic ctgy")
		     rel "ISA")
	      (build subclass *v11
		     superclass *v12)
	      (build object1 *v10
		     object2 *v11
		     rel "ISA"))
	cq (build member *v10
		  class *v12)
	))

;;; If a person can carry an object, then that object is small

(describe
(assert forall ($v13 *v9)
	&ant ((build member *v9
		     class (build lex "person"))
	      (build act (build action (build lex "carry") object *v13)
		     agent *v9))
	cq (build object *v13
		  property (build lex "small"))
	))

;;; If a person wants something, then it is valuable
;;; (Ehrlich doesn't mention that *v9 must be a person, so I modify it)

(describe
(assert forall (*v13 *v9)
	&ant ((build agent *v9
	             act (build action (build lex "want") object *v13))
	      (build member *v9
		     class (build lex "person")))
	cq (build object *v13
	          property (build lex "valuable"))
	))

;;; If someone says they want something, then they do

(describe
(assert forall (*v13 *v9)
	ant (build act (build action (build lex "say that")
			      object (build act (build action (build lex "want") object *v13)
			                    agent *v9))
	           agent *v9)
	cq (build act (build action (build lex "want") object *v13)
		  agent *v9)
	))

;;; If something has colour and belongs to some class, then that class is a 
;;;    subclass of physical object

(describe
(assert forall ($v14 $v15 $v16)
	&ant ((build member *v15
		     class (build lex "colour"))
	      (build object *v16
		     property *v15)
	      (build member *v16
		     class *v14))
	cq (build subclass *v14
	          superclass (build lex "phys obj"))
	))

(describe 
(assert forall (*v14 *v15 $v17)
	&ant ((build member *v15
	             class (build lex "colour"))
	      (build object1 *v17
		     object2 *v14
		     rel "ISA")
	      (build object *v17
		     property *v15))
	cq (build subclass *v14
	          superclass (build lex "phys obj"))
	))

;;; If something has size and belongs to some class, then that class is a 
;;;    subclass of physical object

(describe
(assert forall (*v14 *v15 *v17)
	&ant ((build member *v15
		     class (build lex "size"))
	      (build member *v17
		     class *v14)
	      (build object *v17
		     property *v15))
	cq (build subclass *v14
	          superclass (build lex "phys obj"))
	))

(describe
(assert forall (*v14 *v15 *v17)
	&ant ((build member *v15
	             class (build lex "size"))
	      (build object1 *v17
		     object2 *v14
		     rel "ISA")
	      (build object *v17
		     property *v15))
	cq (build subclass *v14
	          superclass (build lex "phys obj"))
	))

;;; If a member of some class has a property, then it is possible for other
;;;    members of that class to have that property

(describe
(assert forall (*v14 *v15 *v17 $v18)
	&ant ((build object *v17
	             property *v15)
	      (build member *v17
		     class *v14)
	      (build member *v18
		     class *v14))
	cq (build mode (build lex "possibly")
		  object (build object *v18
			        property *v15))
	))

(describe
(assert forall (*v14 *v15 *v17 *v18)
	&ant ((build object1 *v17
		     object2 *v14
		     rel "ISA")
	      (build object *v17
		     property *v15)
	      (build object1 *v18
		     object2 *v14
		     rel "ISA"))
	cq (build mode (build lex "possibly")
		  object (build object *v18
			        property *v15))
	))

;;; If an animal acts, then the act performed is an action

(describe
(assert forall ($v19 $v20)
	&ant ((build member *v20
		     class (build lex "animal"))
	      (build act *v19
		     agent *v20))
	cq (build member *v19
		  class (build lex "action"))
	))

;;; If a person acts, then the act performed is an action

(describe
(assert forall ($v21 $v22)
	&ant ((build member *v22
		     class (build lex "person"))
	      (build act *v21
		     agent *v22))
	cq (build member *v21
	          class (build lex "action"))
	))

;;; Spears are weapons

(describe
(assert subclass (build lex "spear")
	superclass (build lex "weapon")
	))

;;; If something is a weapon, then its function is to damage

(describe
(assert forall $v23
	ant (build object1 *v23
		   object2 (build lex "weapon")
		   rel "ISA")
	cq (build object1 *v23
		  object2 (build lex "damage")
		  rel (build lex "function"))
	))

;;; Kings are persons

(describe
(assert subclass (build lex "king")
	superclass (build lex "person")
	))

;;; Squires are persons

(describe
(assert subclass (build lex "squire")
	superclass (build lex "person")
	))

;;; Yeomen are persons

(describe
(assert subclass (build lex "yeoman")
	superclass (build lex "person")
	))

;;; If something is a carnivore, then it eats meat

(describe 
(assert forall *v5
	ant (build object1 *v5
		   object2 (build lex "carnivore")
		   rel "ISA")
	cq (build act (build action (build lex "eat") object (build lex "meat"))
		  agent *v5)))

;;; If something is an herbivore, then it eats plants and does not eat meat

(describe
(assert forall *v5
	ant (build object1 *v5
		   object2 (build lex "herbivore")
		   rel "ISA")
	cq ((build act (build action (build lex "eat") object (build lex "plant"))
	           agent *v5)
	    (build min 0 
		   max 0 
                   arg (build act (build action (build lex "eat") object (build lex "meat"))
			      agent *v5)))))

;;; If something is a mammal, presumably it bears
;;; **NOTE** Change to bears young

(describe
(assert forall *v5
	ant (build object *v5
		   object2 (build lex "mammal")
		   rel "ISA")
	cq (build mode (build lex "presumably")
		  object (build act (build lex "bear")
			        agent *v5))))

;;; If something bears, then it is a mammal

(describe
(assert forall ($v24  *v5)
	ant (build act (build action (build lex "bear") object *v24)
		   agent *v5)
	cq (build object1 *v5
		  object2 (build lex "mammal")
		  rel "ISA")
	))

;;; If something is a predator, then presumably it hunts

(describe
(assert forall *v5
	ant (build object1 *v5
		   object2 (build lex "predator")
		   rel "ISA")
	cq (build mode (build lex "presumably")
	          object (build act (build lex "hunt")
			        agent *v5))
	))

;;; If an agent leaps onto an object at time x, then there is a time y when 
;;;    the leaper is on the object, and y is after x

(describe
(assert forall ($v25 $v26 $v27)
	ant (build act (build lex "leap")
		   agent *v25
		   onto *v26
		   time *v27)
	cq ((build object1 *v25
	           object2 *v26
		   rel (build lex "on")
		   time (build a3 *v26
			       skf "time-at"))
	    (build after (build a3 *v26
			        skf "time-at")
		   before *v27))
	))

;;; If an agent leaps to a goal at time x, then there is a time y when the
;;;    leaper is at the goal, and y is after x

(describe
(assert forall (*v25 *v26 *v27)
	ant (build act (build lex "leap")
	           agent *v25
		   time *v27
		   to *v26)
	cq ((build object1 *v25
		   object2 *v26
		   rel (build lex "at")
		   time (build a3 *v26
			       skf "time-at"))
	    (build after (build a3 *v26
			        skf "time-at")
		   before *v27))
	))

;;; If an agent leaps from an object at time x, then there is a time y when
;;;    the leaper is on the object, and y is before x

(describe
(assert forall (*v25 *v26 $v28 $v29)
	ant (build act (build lex "leap")
		   agent *v25
		   from *v28
		   time *v29)
	cq ((build object1 *v25
		   object2 *v28
		   rel (build lex "on")
		   time (build a4 *v28
			       skf "time-at"))
	    (build after *v29
		   before (build a4 *v28
				 skf "time-at")))
	))


(describe 
(assert forall ($v30 $v31 $v32)
	ant ((build agent *v30
		    place *v31
		    time *v32)
	     (build object *v30
		    place *v31
		    time *v32))
	cq (build object1 *v30
		  object2 *v31
                  rel (build lex "at")
		  time *v32)
	))