Select language: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi
Concept:
English word:
Home

¨ü¨ÆªÌ (patient)

(patient process entity) means that entity is a participant in process that may be moved, said, experienced, etc. For example, the direct objects in the sentences 'The cat swallowed the canary' and 'Billy likes the beer' would be examples of patients. Note that the patient of a Process may or may not undergo structural change as a result of the Process. The CaseRole of patient is used when one wants to specify as broadly as possible the object of a Process.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

ºØÃþ
is instance of
  ¥iÄ~©ÓÃö«Y  
is instance of
  ®æ¦ì¨¤¦â  
is instance of
  ¨ü¨ÆªÌ  

Subrelation(s)

¤u¨ã  ¸ê·½  µ²ªG 

Coordinate term(s)

¬I¨ÆªÌ  ²×ÂI  ¤è¦V  ¸gÅçªÌ  °_·½  ¸ô®| 

Type restrictions

patient(¾úµ{, ¹êÅé)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (98)

If process ¬O Âù¨ü¨Æ¾úµ{ ªº ¹ê¨Ò, then there exist obj1,obj2 so that obj1 ¬O process ªº ¨ü¨ÆªÌ and obj2 ¬O process ªº ¨ü¨ÆªÌ and obj1 µ¥©ó obj2.
(=>
      (instance ?PROCESS DualObjectProcess)
      (exists
            (?OBJ1 ?OBJ2)
            (and
                  (patient ?PROCESS ?OBJ1)
                  (patient ?PROCESS ?OBJ2)
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

(=>
      (possesses ?PERSON ?OBJ)
      (exists
            (?TYPE)
            (and
                  (holdsRight ?PERSON ?TYPE)
                  (forall
                        (?PROCESS)
                        (=>
                              (instance ?PROCESS ?TYPE)
                              (patient ?PROCESS ?OBJ))))))

If act ¬O Äá­¹ ªº ¹ê¨Ò and food ¬O act ªº ¨ü¨ÆªÌ, then food ¬O ­¹ª« ªº ¹ê¨Ò.
(=>
      (and
            (instance ?ACT Ingesting)
            (patient ?ACT ?FOOD))
      (instance ?FOOD Food))

If act ¬O ¦Y ªº ¹ê¨Ò and food ¬O act ªº ¨ü¨ÆªÌ, then ©TÅ骺 ¬O food ªº ÄÝ©Ê.
(=>
      (and
            (instance ?ACT Eating)
            (patient ?ACT ?FOOD))
      (attribute ?FOOD Solid))

If inj ¬O ¶Ë®` ªº ¹ê¨Ò, then there exists ¸Ñ­åºc³y struct so that struct ¬O inj ªº ¨ü¨ÆªÌ.
(=>
      (instance ?INJ Injuring)
      (exists
            (?STRUCT)
            (and
                  (instance ?STRUCT AnatomicalStructure)
                  (patient ?INJ ?STRUCT))))

inj ¬O ¶Ë®` ªº ¹ê¨Ò if and only if inj ¬O ·l®` ªº ¹ê¨Ò and ¥Íª«Åé ¬O inj ªº ¨ü¨ÆªÌ.
(<=>
      (instance ?INJ Injuring)
      (and
            (instance ?INJ Damaging)
            (patient ?INJ Organism)))

If poison ¬O ¤¤¬r ªº ¹ê¨Ò, then there exists thing so that thing ¬O poison ªº ¨ü¨ÆªÌ and thing ¬O ¥Íª«Åé ªº ¹ê¨Ò or thing ¬O ¸Ñ­åºc³y ªº ¹ê¨Ò.
(=>
      (instance ?POISON Poisoning)
      (exists
            (?THING)
            (and
                  (patient ?POISON ?THING)
                  (or
                        (instance ?THING Organism)
                        (instance ?THING AnatomicalStructure)))))

If join ¬O ¥[¤J²Õ´ ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and join ¬O org ªº ¬I¨ÆªÌ and person ¬O join ªº ¨ü¨ÆªÌ, then person ¬O orgªº ¦¨­û ""join ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "join ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?JOIN JoiningAnOrganization)
            (instance ?ORG Organization)
            (agent ?JOIN ?ORG)
            (patient ?JOIN ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?JOIN))
            (member ?PERSON ?ORG)))

If leave ¬O ²æÂ÷²Õ´ ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and leave ¬O org ªº ¬I¨ÆªÌ and person ¬O leave ªº ¨ü¨ÆªÌ, then person ¬O orgªº ¦¨­û ""leave ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "leave ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?LEAVE LeavingAnOrganization)
            (instance ?ORG Organization)
            (agent ?LEAVE ?ORG)
            (patient ?LEAVE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?LEAVE))
            (not
                  (member ?PERSON ?ORG))))

If grad ¬O ²¦·~ ªº ¹ê¨Ò and grad ¬O org ªº ¬I¨ÆªÌ and person ¬O grad ªº ¨ü¨ÆªÌ, then org ¬O ±Ð¨|²Õ´ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?GRAD Graduation)
            (agent ?GRAD ?ORG)
            (patient ?GRAD ?PERSON))
      (instance ?ORG EducationalOrganization))

If mat ¬O ¥¿¦¡¤J¾Ç ªº ¹ê¨Ò and mat ¬O org ªº ¬I¨ÆªÌ and person ¬O mat ªº ¨ü¨ÆªÌ, then org ¬O ±Ð¨|²Õ´ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?MAT Matriculation)
            (agent ?MAT ?ORG)
            (patient ?MAT ?PERSON))
      (instance ?ORG EducationalOrganization))

If hire ¬O ¹µ¥Î ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and hire ¬O org ªº ¬I¨ÆªÌ and person ¬O hire ªº ¨ü¨ÆªÌ, then org (¨S) ¶±¥Înot(s) person ""hire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "hire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?HIRE Hiring)
            (instance ?ORG Organization)
            (agent ?HIRE ?ORG)
            (patient ?HIRE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?HIRE))
            (employs ?ORG ?PERSON)))

If fire ¬O ¸Ñ¹µ ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and fire ¬O org ªº ¬I¨ÆªÌ and person ¬O fire ªº ¨ü¨ÆªÌ, then org not(¨S) ¶±¥Î(s) person ""fire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "fire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?FIRE TerminatingEmployment)
            (instance ?ORG Organization)
            (agent ?FIRE ?ORG)
            (patient ?FIRE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?FIRE))
            (not
                  (employs ?ORG ?PERSON))))

If proc ¬O ¬Fªv¾úµ{ ªº ¹ê¨Ò, then there exists ¬F©² gov so that proc ¬O gov ªº ¬I¨ÆªÌ or gov ¬O proc ªº ¨ü¨ÆªÌ.
(=>
      (instance ?PROC PoliticalProcess)
      (exists
            (?GOV)
            (and
                  (instance ?GOV Government)
                  (or
                        (agent ?PROC ?GOV)
                        (patient ?PROC ?GOV)))))

If increase ¬O ¼W¥[ ªº ¹ê¨Ò and obj ¬O increase ªº ¨ü¨ÆªÌ, then there exist unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 (¤£) ¤j©ó quant1.
(=>
      (and
            (instance ?INCREASE Increasing)
            (patient ?INCREASE ?OBJ))
      (exists
            (?UNIT ?QUANT1 ?QUANT2)
            (and
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?INCREASE))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?INCREASE))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT2))
                  (greaterThan ?QUANT2 ?QUANT1))))

If heat ¬O ¥[·Å ªº ¹ê¨Ò and obj ¬O heat ªº ¨ü¨ÆªÌ, then there exist ·Å«×³æ¦ì unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 (¤£) ¤j©ó quant1.
(=>
      (and
            (instance ?HEAT Heating)
            (patient ?HEAT ?OBJ))
      (exists
            (?UNIT ?QUANT1 ?QUANT2)
            (and
                  (instance ?UNIT TemperatureMeasure)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?HEAT))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?HEAT))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT2))
                  (greaterThan ?QUANT2 ?QUANT1))))

If decrease ¬O ´î¤Ö ªº ¹ê¨Ò and obj ¬O decrease ªº ¨ü¨ÆªÌ, then there exist unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 ¤p©ó quant1.
(=>
      (and
            (instance ?DECREASE Decreasing)
            (patient ?DECREASE ?OBJ))
      (exists
            (?UNIT ?QUANT1 ?QUANT2)
            (and
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?DECREASE))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?DECREASE))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT2))
                  (lessThan ?QUANT2 ?QUANT1))))

If cool ¬O ­°·Å ªº ¹ê¨Ò and obj ¬O cool ªº ¨ü¨ÆªÌ, then there exist ·Å«×³æ¦ì unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 ¤p©ó quant1.
(=>
      (and
            (instance ?COOL Cooling)
            (patient ?COOL ?OBJ))
      (exists
            (?UNIT ?QUANT1 ?QUANT2)
            (and
                  (instance ?UNIT TemperatureMeasure)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?COOL))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?COOL))
                        (equal
                              (MeasureFn ?OBJ ?UNIT)
                              ?QUANT2))
                  (lessThan ?QUANT2 ?QUANT1))))

If motion ¬O ²¾°Ê ªº ¹ê¨Ò and obj ¬O motion ªº ¨ü¨ÆªÌ and motion (¤£) °_·½s ©ó place, then obj ¦ì©ó place ""motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e.
(=>
      (and
            (instance ?MOTION Motion)
            (patient ?MOTION ?OBJ)
            (origin ?MOTION ?PLACE))
      (holdsDuring
            (ImmediatePastFn
                  (WhenFn ?MOTION))
            (located ?OBJ ?PLACE)))

If motion ¬O ²¾°Ê ªº ¹ê¨Ò and obj ¬O motion ªº ¨ü¨ÆªÌ and motion (¤£) ²×µ²not(s) place, then obj ¦ì©ó place ""motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?MOTION Motion)
            (patient ?MOTION ?OBJ)
            (destination ?MOTION ?PLACE))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?MOTION))
            (located ?OBJ ?PLACE)))

If motion ¬O ¨­Åé²¾°Ê ªº ¹ê¨Ò, then there exist ÂßÅ鳡¥ó obj,¥Íª«Åé agent so that obj ¬O motion ªº ¨ü¨ÆªÌ and motion ¬O agent ªº ¬I¨ÆªÌ.
(=>
      (instance ?MOTION BodyMotion)
      (exists
            (?OBJ ?AGENT)
            (and
                  (instance ?OBJ BodyPart)
                  (patient ?MOTION ?OBJ)
                  (instance ?AGENT Organism)
                  (agent ?MOTION ?AGENT))))

If transfer ¬O Âಾ©ÎÂà´« ªº ¹ê¨Ò and transfer ¬O agent ªº ¬I¨ÆªÌ and patient ¬O transfer ªº ¨ü¨ÆªÌ, then agent µ¥©ó patient.
(=>
      (and
            (instance ?TRANSFER Transfer)
            (agent ?TRANSFER ?AGENT)
            (patient ?TRANSFER ?PATIENT))
      (not
            (equal ?AGENT ?PATIENT)))

If remove ¬O ²¾°£ ªº ¹ê¨Ò and remove (¤£) °_·½s ©ó place and obj ¬O remove ªº ¨ü¨ÆªÌ, then obj ¦ì©ó place ""remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj ¦ì©ó place ""remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?REMOVE Removing)
            (origin ?REMOVE ?PLACE)
            (patient ?REMOVE ?OBJ))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?REMOVE))
                  (located ?OBJ ?PLACE))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?REMOVE))
                  (not
                        (located ?OBJ ?PLACE)))))

If put ¬O ©ñ¸m ªº ¹ê¨Ò and put (¤£) ²×µ²not(s) place and obj ¬O put ªº ¨ü¨ÆªÌ, then obj ¦ì©ó place ""put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj ¦ì©ó place ""put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?PUT Putting)
            (destination ?PUT ?PLACE)
            (patient ?PUT ?OBJ))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?PUT))
                  (not
                        (located ?OBJ ?PLACE)))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?PUT))
                  (located ?OBJ ?PLACE))))

If sub ¬O ´À´« ªº ¹ê¨Ò, then there exist ©ñ¸m put,²¾°£ remove,obj1,obj2,place so that put ¬O sub ªº ¦¸¾úµ{ and remove ¬O sub ªº ¦¸¾úµ{ and obj1 ¬O remove ªº ¨ü¨ÆªÌ and remove (¤£) °_·½s ©ó place and obj2 ¬O put ªº ¨ü¨ÆªÌ and put (¤£) ²×µ²not(s) place and obj1 µ¥©ó obj2.
(=>
      (instance ?SUB Substituting)
      (exists
            (?PUT ?REMOVE ?OBJ1 ?OBJ2 ?PLACE)
            (and
                  (instance ?PUT Putting)
                  (instance ?REMOVE Removing)
                  (subProcess ?PUT ?SUB)
                  (subProcess ?REMOVE ?SUB)
                  (patient ?REMOVE ?OBJ1)
                  (origin ?REMOVE ?PLACE)
                  (patient ?PUT ?OBJ2)
                  (destination ?PUT ?PLACE)
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

If touch ¬O IJ°Ê ªº ¹ê¨Ò and touch ¬O obj1 ªº ¬I¨ÆªÌ and obj2 ¬O touch ªº ¨ü¨ÆªÌ, then obj1 »P obj2 ¬Û³s ""touch ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "touch ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?TOUCH Touching)
            (agent ?TOUCH ?OBJ1)
            (patient ?TOUCH ?OBJ2))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?TOUCH))
            (connected ?OBJ1 ?OBJ2)))

If impact ¬O ¼vÅT ªº ¹ê¨Ò and obj ¬O impact ªº ¨ü¨ÆªÌ, then there exists ¬ï³z impel so that obj ¬O impel ªº ¨ü¨ÆªÌ and "impel ¦s¦b ªº ®É¶¡" (¨S) ¤ñ "impact ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?IMPACT Impacting)
            (patient ?IMPACT ?OBJ))
      (exists
            (?IMPEL)
            (and
                  (instance ?IMPEL Impelling)
                  (patient ?IMPEL ?OBJ)
                  (earlier
                        (WhenFn ?IMPEL)
                        (WhenFn ?IMPACT)))))

If steer ¬O ¤Þ¾É ªº ¹ê¨Ò, then there exists ¹B¿é¤u¨ã vehicle so that vehicle ¬O steer ªº ¨ü¨ÆªÌ.
(=>
      (instance ?STEER Steering)
      (exists
            (?VEHICLE)
            (and
                  (instance ?VEHICLE TransportationDevice)
                  (patient ?STEER ?VEHICLE))))

If education ¬O ±Ð¨|¾úµ{ ªº ¹ê¨Ò and person ¬O education ªº ¨ü¨ÆªÌ, then education ¦³ ·N¹Ï "there exists ¾Ç²ß learn so that person ¬O learn ªº ¨ü¨ÆªÌ".
(=>
      (and
            (instance ?EDUCATION EducationalProcess)
            (patient ?EDUCATION ?PERSON))
      (hasPurpose
            ?EDUCATION
            (exists
                  (?LEARN)
                  (and
                        (instance ?LEARN Learning)
                        (patient ?LEARN ?PERSON)))))

If change ¬O ¾Ö¦³ÅvªºÂಾ ªº ¹ê¨Ò and obj ¬O change ªº ¨ü¨ÆªÌ and agent1 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and agent2 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á, then agent1 µ¥©ó agent2.
(=>
      (and
            (instance ?CHANGE ChangeOfPossession)
            (patient ?CHANGE ?OBJ)
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?CHANGE))
                  (possesses ?AGENT1 ?OBJ))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?CHANGE))
                  (possesses ?AGENT2 ?OBJ)))
      (not
            (equal ?AGENT1 ?AGENT2)))

If change ¬O ¾Ö¦³ÅvªºÂಾ ªº ¹ê¨Ò and change (¤£) °_·½s ©ó agent1 and change (¤£) ²×µ²not(s) agent2 and agent2 ¬O ¬I¨ÆªÌ ªº ¹ê¨Ò and obj ¬O change ªº ¨ü¨ÆªÌ, then agent1 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and agent2 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?CHANGE ChangeOfPossession)
            (origin ?CHANGE ?AGENT1)
            (destination ?CHANGE ?AGENT2)
            (instance ?AGENT2 Agent)
            (patient ?CHANGE ?OBJ))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?CHANGE))
                  (possesses ?AGENT1 ?OBJ))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?CHANGE))
                  (possesses ?AGENT2 ?OBJ))))

If give ¬O µ¹»P ªº ¹ê¨Ò and give ¬O agent1 ªº ¬I¨ÆªÌ and give (¤£) ²×µ²not(s) agent2 and agent2 ¬O ¬I¨ÆªÌ ªº ¹ê¨Ò and obj ¬O give ªº ¨ü¨ÆªÌ, then there exists Àò¨ú get so that get ¬O agent2 ªº ¬I¨ÆªÌ and get (¤£) °_·½s ©ó agent1 and obj ¬O get ªº ¨ü¨ÆªÌ.
(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT1)
            (destination ?GIVE ?AGENT2)
            (instance ?AGENT2 Agent)
            (patient ?GIVE ?OBJ))
      (exists
            (?GET)
            (and
                  (instance ?GET Getting)
                  (agent ?GET ?AGENT2)
                  (origin ?GET ?AGENT1)
                  (patient ?GET ?OBJ))))

There exists ­É¨ú borrow so that borrow ¬O agent1 ªº ¬I¨ÆªÌ and borrow (¤£) °_·½s ©ó agent2 and object ¬O borrow ªº ¨ü¨ÆªÌ if and only if there exists ­É¤© lend so that lend ¬O agent2 ªº ¬I¨ÆªÌ and lend (¤£) ²×µ²not(s) agent1 and object ¬O lend ªº ¨ü¨ÆªÌ.
(<=>
      (exists
            (?BORROW)
            (and
                  (instance ?BORROW Borrowing)
                  (agent ?BORROW ?AGENT1)
                  (origin ?BORROW ?AGENT2)
                  (patient ?BORROW ?OBJECT)))
      (exists
            (?LEND)
            (and
                  (instance ?LEND Lending)
                  (agent ?LEND ?AGENT2)
                  (destination ?LEND ?AGENT1)
                  (patient ?LEND ?OBJECT))))

If trans ¬O ¥æ©ö ªº ¹ê¨Ò, then there exist agent1,agent2,µ¹»P give1,µ¹»P give2,obj1,obj2 so that give1 ¬O trans ªº ¦¸¾úµ{ and give2 ¬O trans ªº ¦¸¾úµ{ and give1 ¬O agent1 ªº ¬I¨ÆªÌ and give2 ¬O agent2 ªº ¬I¨ÆªÌ and obj1 ¬O give1 ªº ¨ü¨ÆªÌ and obj2 ¬O give2 ªº ¨ü¨ÆªÌ and give1 (¤£) ²×µ²not(s) agent2 and give2 (¤£) ²×µ²not(s) agent1 and agent1 µ¥©ó agent2 and obj1 µ¥©ó obj2.
(=>
      (instance ?TRANS Transaction)
      (exists
            (?AGENT1 ?AGENT2 ?GIVE1 ?GIVE2 ?OBJ1 ?OBJ2)
            (and
                  (instance ?GIVE1 Giving)
                  (instance ?GIVE2 Giving)
                  (subProcess ?GIVE1 ?TRANS)
                  (subProcess ?GIVE2 ?TRANS)
                  (agent ?GIVE1 ?AGENT1)
                  (agent ?GIVE2 ?AGENT2)
                  (patient ?GIVE1 ?OBJ1)
                  (patient ?GIVE2 ?OBJ2)
                  (destination ?GIVE1 ?AGENT2)
                  (destination ?GIVE2 ?AGENT1)
                  (not
                        (equal ?AGENT1 ?AGENT2))
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

If trans ¬O ª÷¿Ä¥æ©ö ªº ¹ê¨Ò, then there exists ¶×²v³æ¦ì obj so that obj ¬O trans ªº ¨ü¨ÆªÌ.
(=>
      (instance ?TRANS FinancialTransaction)
      (exists
            (?OBJ)
            (and
                  (patient ?TRANS ?OBJ)
                  (instance ?OBJ CurrencyMeasure))))

There exists ¶R buy so that buy ¬O agent1 ªº ¬I¨ÆªÌ and buy (¤£) °_·½s ©ó agent2 and object ¬O buy ªº ¨ü¨ÆªÌ if and only if there exists ¾P°â sell so that sell ¬O agent2 ªº ¬I¨ÆªÌ and sell (¤£) ²×µ²not(s) agent1 and object ¬O sell ªº ¨ü¨ÆªÌ.
(<=>
      (exists
            (?BUY)
            (and
                  (instance ?BUY Buying)
                  (agent ?BUY ?AGENT1)
                  (origin ?BUY ?AGENT2)
                  (patient ?BUY ?OBJECT)))
      (exists
            (?SELL)
            (and
                  (instance ?SELL Selling)
                  (agent ?SELL ?AGENT2)
                  (destination ?SELL ?AGENT1)
                  (patient ?SELL ?OBJECT))))

If there exists ¾Ç²ß learn so that learn ¬O agent ªº ¬I¨ÆªÌ and prop ¬O learn ªº ¨ü¨ÆªÌ timea(¤§¤¤) time, then agent (¤£)¬Û«H prop "time ¤£¤[ ¤§«á"a(¤§¤¤) time ¤£¤[ ¤§«á.
(=>
      (holdsDuring
            ?TIME
            (exists
                  (?LEARN)
                  (and
                        (instance ?LEARN Learning)
                        (agent ?LEARN ?AGENT)
                        (patient ?LEARN ?PROP))))
      (holdsDuring
            (ImmediateFutureFn ?TIME)
            (believes ?AGENT ?PROP)))

If meas ¬O ´ú¶q ªº ¹ê¨Ò and meas ¬O agent ªº ¬I¨ÆªÌ and obj ¬O meas ªº ¨ü¨ÆªÌ, then there exist quant,unit so that agent (¤£¡^ª¾¹Ds) %2 ""meas ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "meas ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?MEAS Measuring)
            (agent ?MEAS ?AGENT)
            (patient ?MEAS ?OBJ))
      (exists
            (?QUANT ?UNIT)
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?MEAS))
                  (knows
                        ?AGENT
                        (measure
                              ?OBJ
                              (MeasureFn ?QUANT ?UNIT))))))

If count ¬O ­p¼Æ ªº ¹ê¨Ò and count ¬O agent ªº ¬I¨ÆªÌ and entity ¬O count ªº ¨ü¨ÆªÌ, then there exists number so that agent (¤£¡^ª¾¹Ds) %2.
(=>
      (and
            (instance ?COUNT Counting)
            (agent ?COUNT ?AGENT)
            (patient ?COUNT ?ENTITY))
      (exists
            (?NUMBER)
            (knows
                  ?AGENT
                  (equal
                        (CardinalityFn ?ENTITY)
                        ?NUMBER))))

If predict ¬O ¹w´ú ªº ¹ê¨Ò and formula ¬O predict ªº ¨ü¨ÆªÌ, then there exists time so that formula (¨S) ¬°¯u timea(¤§¤¤) time and time (¨S) µo¥Í?{s} ¦b "predict ¦s¦b ªº ®É¶¡" ¤§«e or time (¨S) ¤ñ "predict ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?PREDICT Predicting)
            (patient ?PREDICT ?FORMULA))
      (exists
            (?TIME)
            (and
                  (holdsDuring ?TIME ?FORMULA)
                  (or
                        (before
                              ?TIME
                              (WhenFn ?PREDICT))
                        (earlier
                              ?TIME
                              (WhenFn ?PREDICT))))))

If remember ¬O °O¾Ð ªº ¹ê¨Ò and formula ¬O remember ªº ¨ü¨ÆªÌ, then there exists time so that formula (¨S) ¬°¯u timea(¤§¤¤) time and time (¨S) µo¥Í?{s} ¦b "remember ¦s¦b ªº ®É¶¡" ¤§«e or time (¨S) ¤ñ "remember ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?REMEMBER Remembering)
            (patient ?REMEMBER ?FORMULA))
      (exists
            (?TIME)
            (and
                  (holdsDuring ?TIME ?FORMULA)
                  (or
                        (before
                              ?TIME
                              (WhenFn ?REMEMBER))
                        (earlier
                              ?TIME
                              (WhenFn ?REMEMBER))))))

If keep ¬O «O¦³ ªº ¹ê¨Ò and keep ¬O agent ªº ¬I¨ÆªÌ and obj ¬O keep ªº ¨ü¨ÆªÌ, then there exists ©ñ¸m put so that put ¬O agent ªº ¬I¨ÆªÌ and obj ¬O put ªº ¨ü¨ÆªÌ and "put ¦s¦b ªº ®É¶¡" (¨S) ¤ñ "keep ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?KEEP Keeping)
            (agent ?KEEP ?AGENT)
            (patient ?KEEP ?OBJ))
      (exists
            (?PUT)
            (and
                  (instance ?PUT Putting)
                  (agent ?PUT ?AGENT)
                  (patient ?PUT ?OBJ)
                  (earlier
                        (WhenFn ?PUT)
                        (WhenFn ?KEEP)))))

(=>
      (and
            (instance ?KEEP Keeping)
            (patient ?KEEP ?OBJ))
      (exists
            (?PLACE)
            (forall
                  (?TIME)
                  (=>
                        (temporalPart
                              ?TIME
                              (WhenFn ?KEEP))
                        (holdsDuring
                              ?TIME
                              (located ?OBJ ?PLACE))))))

If confine ¬O ­­©w ªº ¹ê¨Ò, then there exists ¤HÃþ human so that human ¬O confine ªº ¨ü¨ÆªÌ.
(=>
      (instance ?CONFINE Confining)
      (exists
            (?HUMAN)
            (and
                  (instance ?HUMAN Human)
                  (patient ?CONFINE ?HUMAN))))

If confine ¬O ­­©w ªº ¹ê¨Ò and person ¬O confine ªº ¨ü¨ÆªÌ, then person not(¤£) ¾¬¨D(s) "person ¬O confine ªº ¨ü¨ÆªÌ".
(=>
      (and
            (instance ?CONFINE Confining)
            (patient ?CONFINE ?PERSON))
      (not
            (desires
                  ?PERSON
                  (patient ?CONFINE ?PERSON))))

If repair ¬O ­×Å@ ªº ¹ê¨Ò and obj ¬O repair ªº ¨ü¨ÆªÌ, then there exists ·l®` damage so that obj ¬O damage ªº ¨ü¨ÆªÌ and "damage ¦s¦b ªº ®É¶¡" (¨S) ¤ñ "repair ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?REPAIR Repairing)
            (patient ?REPAIR ?OBJ))
      (exists
            (?DAMAGE)
            (and
                  (instance ?DAMAGE Damaging)
                  (patient ?DAMAGE ?OBJ)
                  (earlier
                        (WhenFn ?DAMAGE)
                        (WhenFn ?REPAIR)))))

If proc ¬O ªvÀø¾úµ{ ªº ¹ê¨Ò and bio ¬O proc ªº ¨ü¨ÆªÌ, then
(=>
      (and
            (instance ?PROC TherapeuticProcess)
            (patient ?PROC ?BIO))
      (or
            (instance ?BIO Organism)
            (exists
                  (?ORG)
                  (and
                        (instance ?ORG Organism)
                        (part ?BIO ?ORG)))))

If act ¬O ¥~¬ì¤â³N ªº ¹ê¨Ò and animal ¬O act ªº ¨ü¨ÆªÌ, then there exists ¤Á³Î subact so that animal ¬O °Êª« ªº ¹ê¨Ò and cutting ¬O animal ªº ¨ü¨ÆªÌ and subact ¬O act ªº ¦¸¾úµ{.
(=>
      (and
            (instance ?ACT Surgery)
            (patient ?ACT ?ANIMAL))
      (exists
            (?SUBACT)
            (and
                  (instance ?SUBACT Cutting)
                  (instance ?ANIMAL Animal)
                  (patient ?ANIMAL ?CUTTING)
                  (subProcess ?SUBACT ?ACT))))

process ¬O ·´·À ªº ¹ê¨Ò if and only if there exists patient so that patient ¬O process ªº ¨ü¨ÆªÌ and patient (¤£) ¦s¦bs ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e" ´Á¶¡ and patient not(¤£) ¦s¦b ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á" ´Á¶¡.
(<=>
      (instance ?PROCESS Destruction)
      (exists
            (?PATIENT)
            (and
                  (patient ?PROCESS ?PATIENT)
                  (time
                        ?PATIENT
                        (ImmediatePastFn
                              (WhenFn ?PROCESS)))
                  (not
                        (time
                              ?PATIENT
                              (ImmediateFutureFn
                                    (WhenFn ?PROCESS)))))))

If kill ¬O ±þ®` ªº ¹ê¨Ò and kill ¬O agent ªº ¬I¨ÆªÌ and patient ¬O kill ªº ¨ü¨ÆªÌ, then agent ¬O ¥Íª«Åé ªº ¹ê¨Ò and patient ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?KILL Killing)
            (agent ?KILL ?AGENT)
            (patient ?KILL ?PATIENT))
      (and
            (instance ?AGENT Organism)
            (instance ?PATIENT Organism)))

If kill ¬O ±þ®` ªº ¹ê¨Ò and patient ¬O kill ªº ¨ü¨ÆªÌ, then ¬¡ªº ¬O patient ªº ÄÝ©Ê ""kill ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "kill ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ¦º ¬O patient ªº ÄÝ©Ê ""kill ¦s¦b ªº ®É¶¡" ¤§«á"a(¤§¤¤) "kill ¦s¦b ªº ®É¶¡" ¤§«á.
(=>
      (and
            (instance ?KILL Killing)
            (patient ?KILL ?PATIENT))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?KILL))
                  (attribute ?PATIENT Living))
            (holdsDuring
                  (FutureFn
                        (WhenFn ?KILL))
                  (attribute ?PATIENT Dead))))

If poke ¬O ÂW ªº ¹ê¨Ò and poke ¬O agent ªº ¬I¨ÆªÌ and obj ¬O poke ªº ¨ü¨ÆªÌ and inst ¹ï poke ¬O ¤u¨ã, then inst ³sµ² agent ©M obj "poke ¦s¦b ªº ®É¶¡"a(¤§¤¤) poke ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?POKE Poking)
            (agent ?POKE ?AGENT)
            (patient ?POKE ?OBJ)
            (instrument ?POKE ?INST))
      (holdsDuring
            (WhenFn ?POKE)
            (connects ?INST ?AGENT ?OBJ)))

If attach ¬O ¶Kªþ ªº ¹ê¨Ò and obj1 ¬O attach ªº ¨ü¨ÆªÌ and obj2 ¬O attach ªº ¨ü¨ÆªÌ, then obj1 »P obj2 ¬Û³s ""attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj1 »P obj2 ¬Û³s ""attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?ATTACH Attaching)
            (patient ?ATTACH ?OBJ1)
            (patient ?ATTACH ?OBJ2))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?ATTACH))
                  (not
                        (connected ?OBJ1 ?OBJ2)))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?ATTACH))
                  (connected ?OBJ1 ?OBJ2))))

If detach ¬O ²æÂ÷ ªº ¹ê¨Ò and obj1 ¬O detach ªº ¨ü¨ÆªÌ and obj2 ¬O detach ªº ¨ü¨ÆªÌ, then obj1 »P obj2 ¬Û³s ""detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj1 »P obj2 ¬Û³s ""detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?DETACH Detaching)
            (patient ?DETACH ?OBJ1)
            (patient ?DETACH ?OBJ2))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?DETACH))
                  (connected ?OBJ1 ?OBJ2))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?DETACH))
                  (not
                        (connected ?OBJ1 ?OBJ2)))))

If change ¬O ¤º¦b§ïÅÜ ªº ¹ê¨Ò and obj ¬O change ªº ¨ü¨ÆªÌ, then there exists property so that
(=>
      (and
            (instance ?CHANGE InternalChange)
            (patient ?CHANGE ?OBJ))
      (exists
            (?PROPERTY)
            (or
                  (and
                        (holdsDuring
                              (ImmediatePastFn
                                    (WhenFn ?CHANGE))
                              (attribute ?OBJ ?PROPERTY))
                        (holdsDuring
                              (ImmediateFutureFn
                                    (WhenFn ?CHANGE))
                              (not
                                    (attribute ?OBJ ?PROPERTY))))
                  (and
                        (holdsDuring
                              (ImmediatePastFn
                                    (WhenFn ?CHANGE))
                              (not
                                    (attribute ?OBJ ?PROPERTY)))
                        (holdsDuring
                              (ImmediateFutureFn
                                    (WhenFn ?CHANGE))
                              (attribute ?OBJ ?PROPERTY))))))

If alt ¬O ªí­±§ïÅÜ ªº ¹ê¨Ò and obj ¬O alt ªº ¨ü¨ÆªÌ, then there exist part,property so that part ¬O objªº ¥~ªí³¡¤À and property ¬O part ªº ÄÝ©Ê ""alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and property ¬O part ªº ÄÝ©Ê ""alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?ALT SurfaceChange)
            (patient ?ALT ?OBJ))
      (exists
            (?PART ?PROPERTY)
            (and
                  (superficialPart ?PART ?OBJ)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?ALT))
                        (attribute ?PART ?PROPERTY))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?ALT))
                        (not
                              (attribute ?PART ?PROPERTY))))))

If alt ¬O §Îª¬§ïÅÜ ªº ¹ê¨Ò and obj ¬O alt ªº ¨ü¨ÆªÌ, then there exists §Îª¬ÄÝ©Ê property so that
(=>
      (and
            (instance ?ALT ShapeChange)
            (patient ?ALT ?OBJ))
      (exists
            (?PROPERTY)
            (and
                  (instance ?PROPERTY ShapeAttribute)
                  (or
                        (and
                              (holdsDuring
                                    (ImmediatePastFn
                                          (WhenFn ?ALT))
                                    (attribute ?OBJ ?PROPERTY))
                              (holdsDuring
                                    (ImmediateFutureFn
                                          (WhenFn ?ALT))
                                    (not
                                          (attribute ?OBJ ?PROPERTY))))
                        (and
                              (holdsDuring
                                    (ImmediatePastFn
                                          (WhenFn ?ALT))
                                    (not
                                          (attribute ?OBJ ?PROPERTY)))
                              (holdsDuring
                                    (ImmediateFutureFn
                                          (WhenFn ?ALT))
                                    (attribute ?OBJ ?PROPERTY)))))))

If coloring ¬O µÛ¦â ªº ¹ê¨Ò and obj ¬O coloring ªº ¨ü¨ÆªÌ, then there exists ÃC¦âÄÝ©Ê property so that property ¬O obj ªº ÄÝ©Ê ""coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and property ¬O obj ªº ÄÝ©Ê ""coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?COLORING Coloring)
            (patient ?COLORING ?OBJ))
      (exists
            (?PROPERTY)
            (and
                  (instance ?PROPERTY ColorAttribute)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?COLORING))
                        (attribute ?OBJ ?PROPERTY))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?COLORING))
                        (not
                              (attribute ?OBJ ?PROPERTY))))))

If develop ¬O ¤º®eµo®i ªº ¹ê¨Ò, then there exists ¤º®e¸üÅé obj so that obj ¬O develop ªº ¨ü¨ÆªÌ.
(=>
      (instance ?DEVELOP ContentDevelopment)
      (exists
            (?OBJ)
            (and
                  (instance ?OBJ ContentBearingObject)
                  (patient ?DEVELOP ?OBJ))))

If decode ¬O ¸Ñ½X ªº ¹ê¨Ò and doc1 ¬O decode ªº ¨ü¨ÆªÌ, then there exist encode,doc2,time so that doc2 (¤£) ¥]§ts) °T®§ %2 and doc1 (¤£) ¥]§ts) °T®§ %2 and time ¬O ""decode ¦s¦b ªº ®É¶¡" ¤§«e" ªº ³¡¤À and encode ¬O ½s½X ªº ¹ê¨Ò and doc2 ¬O encode ªº ¨ü¨ÆªÌ timea(¤§¤¤) time.
(=>
      (and
            (instance ?DECODE Decoding)
            (patient ?DECODE ?DOC1))
      (exists
            (?ENCODE ?DOC2 ?TIME)
            (and
                  (containsInformation ?DOC2 ?PROP)
                  (containsInformation ?DOC1 ?PROP)
                  (temporalPart
                        ?TIME
                        (PastFn
                              (WhenFn ?DECODE)))
                  (holdsDuring
                        ?TIME
                        (and
                              (instance ?ENCODE Encoding)
                              (patient ?ENCODE ?DOC2))))))

If wet ¬O Àã¼í ªº ¹ê¨Ò and obj ¬O wet ªº ¨ü¨ÆªÌ, then À㪺 ¬O obj ªº ÄÝ©Ê or ¼éÀã ¬O obj ªº ÄÝ©Ê ""wet ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "wet ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?WET Wetting)
            (patient ?WET ?OBJ))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?WET))
            (or
                  (attribute ?OBJ Wet)
                  (attribute ?OBJ Damp))))

If wet ¬O Àã¼í ªº ¹ê¨Ò, then there exists obj so that ²GÅ骺 ¬O obj ªº ÄÝ©Ê and obj ¬O wet ªº ¨ü¨ÆªÌ.
(=>
      (instance ?WET Wetting)
      (exists
            (?OBJ)
            (and
                  (attribute ?OBJ Liquid)
                  (patient ?WET ?OBJ))))

If dry ¬O °®Àê ªº ¹ê¨Ò and obj ¬O dry ªº ¨ü¨ÆªÌ, then °®ªº ¬O obj ªº ÄÝ©Ê ""dry ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "dry ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?DRY Drying)
            (patient ?DRY ?OBJ))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?DRY))
            (attribute ?OBJ Dry)))

process ¬O ²£¥Í ªº ¹ê¨Ò if and only if there exists patient so that patient ¬O process ªº ¨ü¨ÆªÌ and patient (¤£) ¦s¦bs ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á" ´Á¶¡ and patient not(¤£) ¦s¦b ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e" ´Á¶¡.
(<=>
      (instance ?PROCESS Creation)
      (exists
            (?PATIENT)
            (and
                  (patient ?PROCESS ?PATIENT)
                  (time
                        ?PATIENT
                        (ImmediateFutureFn
                              (WhenFn ?PROCESS)))
                  (not
                        (time
                              ?PATIENT
                              (ImmediatePastFn
                                    (WhenFn ?PROCESS)))))))

If pub ¬O ¥Xª© ªº ¹ê¨Ò and text ¬O pub ªº ¨ü¨ÆªÌ, then text ¬O ¤å¥» ªº ¦¸ºØÃþ.
(=>
      (and
            (instance ?PUB Publication)
            (patient ?PUB ?TEXT))
      (subclass ?TEXT Text))

If search ¬O ±´´M ªº ¹ê¨Ò and search ¬O agent ªº ¬I¨ÆªÌ and entity ¬O search ªº ¨ü¨ÆªÌ, then agent ¦b entity ½d³ò¤¤.
(=>
      (and
            (instance ?SEARCH Searching)
            (agent ?SEARCH ?AGENT)
            (patient ?SEARCH ?ENTITY))
      (inScopeOfInterest ?AGENT ?ENTITY))

If pursue ¬O °l ªº ¹ê¨Ò and pursue ¬O agent ªº ¬I¨ÆªÌ and obj ¬O pursue ªº ¨ü¨ÆªÌ, then agent (¤£) ·Q­nnot(s) obj pursuea(¤§¤¤) pursue.
(=>
      (and
            (instance ?PURSUE Pursuing)
            (agent ?PURSUE ?AGENT)
            (patient ?PURSUE ?OBJ))
      (holdsDuring
            ?PURSUE
            (wants ?AGENT ?OBJ)))

If pursue ¬O °l ªº ¹ê¨Ò and pursue ¬O agent ªº ¬I¨ÆªÌ and obj ¬O pursue ªº ¨ü¨ÆªÌ, then agent not(¨S) ¾Ö¦³(s) obj pursuea(¤§¤¤) pursue.
(=>
      (and
            (instance ?PURSUE Pursuing)
            (agent ?PURSUE ?AGENT)
            (patient ?PURSUE ?OBJ))
      (holdsDuring
            ?PURSUE
            (not
                  (possesses ?AGENT ?OBJ))))

If investigate ¬O ½Õ¬d ªº ¹ê¨Ò and prop ¬O investigate ªº ¨ü¨ÆªÌ, then prop ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?INVESTIGATE Investigating)
            (patient ?INVESTIGATE ?PROP))
      (instance ?PROP Formula))

If investigate ¬O ½Õ¬d ªº ¹ê¨Ò and investigate ¬O agent ªº ¬I¨ÆªÌ and prop ¬O investigate ªº ¨ü¨ÆªÌ, then agent not(¤£¡^ª¾¹D "investigate ¦s¦b ªº ®É¶¡"a(¤§¤¤) investigate ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?INVESTIGATE Investigating)
            (agent ?INVESTIGATE ?AGENT)
            (patient ?INVESTIGATE ?PROP))
      (holdsDuring
            (WhenFn ?INVESTIGATE)
            (not
                  (knows ?AGENT ?PROP))))

If communicate ¬O ·¾³q ªº ¹ê¨Ò, then there exist ¤º®e¸üÅé obj,¨ã»{ª¾¤O¬I¨ÆªÌ agent1,¨ã»{ª¾¤O¬I¨ÆªÌ agent2 so that obj ¬O communicate ªº ¨ü¨ÆªÌ and communicate ¬O agent1 ªº ¬I¨ÆªÌ and communicate (¤£) ²×µ²not(s) agent2.
(=>
      (instance ?COMMUNICATE Communication)
      (exists
            (?OBJ ?AGENT1 ?AGENT2)
            (and
                  (instance ?OBJ ContentBearingObject)
                  (patient ?COMMUNICATE ?OBJ)
                  (instance ?AGENT1 CognitiveAgent)
                  (agent ?COMMUNICATE ?AGENT1)
                  (instance ?AGENT2 CognitiveAgent)
                  (destination ?COMMUNICATE ?AGENT2))))

If advert ¬O ¼s§i ªº ¹ê¨Ò, then there exists obj so that advert °Ñ·Ó obj and advert ¦³ ·N¹Ï "there exists ¾P°â sale so that obj ¬O sale ªº ¨ü¨ÆªÌ".
(=>
      (instance ?ADVERT Advertising)
      (exists
            (?OBJ)
            (and
                  (refers ?ADVERT ?OBJ)
                  (hasPurpose
                        ?ADVERT
                        (exists
                              (?SALE)
                              (and
                                    (instance ?SALE Selling)
                                    (patient ?SALE ?OBJ)))))))

If communicate ¬O »y¨¥·¾³q ªº ¹ê¨Ò, then there exists »y¨¥ªí¦¡ obj so that obj ¬O communicate ªº ¨ü¨ÆªÌ.
(=>
      (instance ?COMMUNICATE LinguisticCommunication)
      (exists
            (?OBJ)
            (and
                  (instance ?OBJ LinguisticExpression)
                  (patient ?COMMUNICATE ?OBJ))))

If state ¬O ±Ô­z ªº ¹ê¨Ò and state ¬O agent ªº ¬I¨ÆªÌ and formula ¬O state ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then agent (¤£)¬Û«H formula "state ¦s¦b ªº ®É¶¡"a(¤§¤¤) state ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?STATE Stating)
            (agent ?STATE ?AGENT)
            (patient ?STATE ?FORMULA)
            (instance ?FORMULA Formula))
      (holdsDuring
            (WhenFn ?STATE)
            (believes ?AGENT ?FORMULA)))

If order ¬O ©R¥O ªº ¹ê¨Ò and formula ¬O order ªº ¨ü¨ÆªÌ, then ³¯­z formula ¦³ ¸q°È ªº «¬ºA·N¸q.
(=>
      (and
            (instance ?ORDER Ordering)
            (patient ?ORDER ?FORMULA))
      (modalAttribute ?FORMULA Obligation))

If request ¬O ½Ð¨D ªº ¹ê¨Ò and request ¬O agent ªº ¬I¨ÆªÌ and formula ¬O request ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then agent (¤£) ¾¬¨Dnot(s) formula.
(=>
      (and
            (instance ?REQUEST Requesting)
            (agent ?REQUEST ?AGENT)
            (patient ?REQUEST ?FORMULA)
            (instance ?FORMULA Formula))
      (desires ?AGENT ?FORMULA))

If question ¬O ¸ß°Ý ªº ¹ê¨Ò and question ¬O agent ªº ¬I¨ÆªÌ and formula ¬O question ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then agent not(¤£¡^ª¾¹D "question ¦s¦b ªº ®É¶¡"a(¤§¤¤) question ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?QUESTION Questioning)
            (agent ?QUESTION ?AGENT)
            (patient ?QUESTION ?FORMULA)
            (instance ?FORMULA Formula))
      (holdsDuring
            (WhenFn ?QUESTION)
            (not
                  (knows ?AGENT ?FORMULA))))

If commit ¬O ©Ó¿Õ ªº ¹ê¨Ò and formula ¬O commit ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then ³¯­z formula ¦³ ©Ó¿Õ ªº «¬ºA·N¸q.
(=>
      (and
            (instance ?COMMIT Committing)
            (patient ?COMMIT ?FORMULA)
            (instance ?FORMULA Formula))
      (modalAttribute ?FORMULA Promise))

If percept ¬O ª¾Ä± ªº ¹ê¨Ò and percept ¬O agent ªº ¬I¨ÆªÌ and object ¬O percept ªº ¨ü¨ÆªÌ, then agent (¨S) ª`·N¨ìnot(s) object.
(=>
      (and
            (instance ?PERCEPT Perception)
            (agent ?PERCEPT ?AGENT)
            (patient ?PERCEPT ?OBJECT))
      (notices ?AGENT ?OBJECT))

If see ¬O ¬Ý ªº ¹ê¨Ò and see ¬O agent ªº ¬I¨ÆªÌ and obj ¬O see ªº ¨ü¨ÆªÌ, then
(=>
      (and
            (instance ?SEE Seeing)
            (agent ?SEE ?AGENT)
            (patient ?SEE ?OBJ))
      (and
            (attribute ?OBJ Illuminated)
            (exists
                  (?PROP)
                  (and
                        (instance ?PROP ColorAttribute)
                        (knows
                              ?AGENT
                              (attribute ?OBJ ?PROP))))))

If smell ¬O »D ªº ¹ê¨Ò and obj ¬O smell ªº ¨ü¨ÆªÌ, then there exists ¶åıÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?SMELL Smelling)
            (patient ?SMELL ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR OlfactoryAttribute)
                  (attribute ?OBJ ?ATTR))))

If taste ¬O ¨ýı ªº ¹ê¨Ò and obj ¬O taste ªº ¨ü¨ÆªÌ, then there exists ¨ýıÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?TASTE Tasting)
            (patient ?TASTE ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR TasteAttribute)
                  (attribute ?OBJ ?ATTR))))

If hear ¬O Å¥ ªº ¹ê¨Ò and obj ¬O hear ªº ¨ü¨ÆªÌ, then there exists Án­µÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?HEAR Hearing)
            (patient ?HEAR ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?OBJ ?ATTR))))

There exists ¥ú½u emit so that region ¬O emit ªº ¨ü¨ÆªÌ and region ¬O °Ï°ì ªº ¹ê¨Ò if and only if ³Q¥ú·Óªº ¬O region ªº ÄÝ©Ê.
(<=>
      (exists
            (?EMIT)
            (and
                  (instance ?EMIT RadiatingLight)
                  (patient ?EMIT ?REGION)
                  (instance ?REGION Region)))
      (attribute ?REGION Illuminated))

If process ¬O ª¬ºA§ïÅÜ ªº ¹ê¨Ò and obj ¬O process ªº ¨ü¨ÆªÌ, then there exist part,ª«²zª¬ºA state1,ª«²zª¬ºA state2 so that part ¬O obj ªº ³¡¤À) and state1 µ¥©ó state2 and state1 ¬O part ªº ÄÝ©Ê ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and state2 ¬O part ªº ÄÝ©Ê ""freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?PROCESS StateChange)
            (patient ?PROCESS ?OBJ))
      (exists
            (?PART ?STATE1 ?STATE2)
            (and
                  (part ?PART ?OBJ)
                  (instance ?STATE1 PhysicalState)
                  (instance ?STATE2 PhysicalState)
                  (not
                        (equal ?STATE1 ?STATE2))
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?PROCESS))
                        (attribute ?PART ?STATE1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?FREEZE))
                        (attribute ?PART ?STATE2)))))

If melt ¬O º²¤Æ ªº ¹ê¨Ò and obj ¬O melt ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ©TÅ骺 ¬O part ªº ÄÝ©Ê ""melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?MELT Melting)
            (patient ?MELT ?OBJ))
      (exists
            (?PART)
            (and
                  (part ?PART ?OBJ)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?MELT))
                        (attribute ?PART Solid))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?MELT))
                        (attribute ?PART Liquid)))))

If boil ¬O ªmÄË ªº ¹ê¨Ò and obj ¬O boil ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ®ðÅé ¬O part ªº ÄÝ©Ê ""boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?BOIL Boiling)
            (patient ?BOIL ?OBJ))
      (exists
            (?PART)
            (and
                  (part ?PART ?OBJ)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?BOIL))
                        (attribute ?PART Liquid))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?BOIL))
                        (attribute ?PART Gas)))))

If cond ¬O ¾®µ² ªº ¹ê¨Ò and obj ¬O cond ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ®ðÅé ¬O part ªº ÄÝ©Ê ""cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?COND Condensing)
            (patient ?COND ?OBJ))
      (exists
            (?PART)
            (and
                  (part ?PART ?OBJ)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?COND))
                        (attribute ?PART Gas))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?COND))
                        (attribute ?PART Liquid)))))

If freeze ¬O ¾®©T ªº ¹ê¨Ò and obj ¬O freeze ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ©TÅ骺 ¬O part ªº ÄÝ©Ê ""freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?FREEZE Freezing)
            (patient ?FREEZE ?OBJ))
      (exists
            (?PART)
            (and
                  (part ?PART ?OBJ)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?FREEZE))
                        (attribute ?PART Liquid))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?FREEZE))
                        (attribute ?PART Solid)))))

If drink ¬O ³Ü ªº ¹ê¨Ò and bev ¬O drink ªº ¨ü¨ÆªÌ, then bev ¬O ¶¼®Æ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?DRINK Drinking)
            (patient ?DRINK ?BEV))
      (instance ?BEV Beverage))

org ¥Xª© text if and only if there exists ¥Xª© pub so that pub ¬O org ªº ¬I¨ÆªÌ and text ¬O pub ªº ¨ü¨ÆªÌ.
(<=>
      (publishes ?ORG ?TEXT)
      (exists
            (?PUB)
            (and
                  (instance ?PUB Publication)
                  (agent ?PUB ?ORG)
                  (patient ?PUB ?TEXT))))

If "text ªº ª©¥» int1 " µ¥©ó edition1 and "text ªº ª©¥» int2 " µ¥©ó edition2 and int2 (¤£) ¤j©ó int1 and pub1 ¬O ¥Xª© ªº ¹ê¨Ò and pub2 ¬O ¥Xª© ªº ¹ê¨Ò and edition1 ¬O pub1 ªº ¨ü¨ÆªÌ and edition2 ¬O pub2 ªº ¨ü¨ÆªÌ and pub1 ªº ¤é´Á ¬O date1 and pub2 ªº ¤é´Á ¬O date2, then "date1 ªº µ²§ô" (¨S) µo¥Í?{s} ¦b "date2 ªº µ²§ô" ¤§«e.
(=>
      (and
            (equal
                  (EditionFn ?TEXT ?INT1)
                  ?EDITION1)
            (equal
                  (EditionFn ?TEXT ?INT2)
                  ?EDITION2)
            (greaterThan ?INT2 ?INT1)
            (instance ?PUB1 Publication)
            (instance ?PUB2 Publication)
            (patient ?PUB1 ?EDITION1)
            (patient ?PUB2 ?EDITION2)
            (date ?PUB1 ?DATE1)
            (date ?PUB2 ?DATE2))
      (before
            (EndFn ?DATE1)
            (EndFn ?DATE2)))

If text ¬O ´Á¥Z ªº ¦¸ºØÃþ and "¥U int1 ¦b ¨t¦C¼Æ text" µ¥©ó volume1 and "¥U int2 ¦b ¨t¦C¼Æ text" µ¥©ó volume2 and int2 (¤£) ¤j©ó int1 and pub1 ¬O ¥Xª© ªº ¹ê¨Ò and pub2 ¬O ¥Xª© ªº ¹ê¨Ò and volume1 ¬O pub1 ªº ¨ü¨ÆªÌ and volume2 ¬O pub2 ªº ¨ü¨ÆªÌ and pub1 ªº ¤é´Á ¬O date1 and pub2 ªº ¤é´Á ¬O date2, then "date1 ªº µ²§ô" (¨S) µo¥Í?{s} ¦b "date2 ªº µ²§ô" ¤§«e.
(=>
      (and
            (subclass ?TEXT Periodical)
            (equal
                  (SeriesVolumeFn ?TEXT ?INT1)
                  ?VOLUME1)
            (equal
                  (SeriesVolumeFn ?TEXT ?INT2)
                  ?VOLUME2)
            (greaterThan ?INT2 ?INT1)
            (instance ?PUB1 Publication)
            (instance ?PUB2 Publication)
            (patient ?PUB1 ?VOLUME1)
            (patient ?PUB2 ?VOLUME2)
            (date ?PUB1 ?DATE1)
            (date ?PUB2 ?DATE2))
      (before
            (EndFn ?DATE1)
            (EndFn ?DATE2)))

If weapon ¬O ªZ¾¹ ªº ¹ê¨Ò, then weapon ¦³ ·N¹Ï "there exist ·l®` dest,patient so that patient ¬O dest ªº ¨ü¨ÆªÌ and ".
(=>
      (instance ?WEAPON Weapon)
      (hasPurpose
            ?WEAPON
            (exists
                  (?DEST ?PATIENT)
                  (and
                        (instance ?DEST Damaging)
                        (patient ?DEST ?PATIENT)
                        (or
                              (instance ?PATIENT StationaryArtifact)
                              (instance ?PATIENT Animal)
                              (exists
                                    (?ANIMAL)
                                    (and
                                          (instance ?ANIMAL Animal)
                                          (inhabits ?ANIMAL ?PATIENT))))))))

If attr ¬O obj ªº ÄÝ©Ê and attr ¬O Ävª§ÄÝ©Ê ªº ¹ê¨Ò, then there exists Ävª§ contest so that contest ¬O obj ªº ¬I¨ÆªÌ or obj ¬O contest ªº ¨ü¨ÆªÌ.
(=>
      (and
            (attribute ?OBJ ?ATTR)
            (instance ?ATTR ContestAttribute))
      (exists
            (?CONTEST)
            (and
                  (instance ?CONTEST Contest)
                  (or
                        (agent ?CONTEST ?OBJ)
                        (patient ?CONTEST ?OBJ)))))

If perception ¬O ª¾Ä± ªº ¹ê¨Ò and obj ¬O perception ªº ¨ü¨ÆªÌ, then there exists ª¾Ä±ÄÝ©Ê prop so that prop ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?PERCEPTION Perception)
            (patient ?PERCEPTION ?OBJ))
      (exists
            (?PROP)
            (and
                  (instance ?PROP PerceptualAttribute)
                  (attribute ?OBJ ?PROP))))

If there exists §Îª¬§ïÅÜ change so that obj ¬O change ªº ¨ü¨ÆªÌ, then ¥iÅܧΪº ¬O obj ªº ÄÝ©Ê.
(=>
      (exists
            (?CHANGE)
            (and
                  (instance ?CHANGE ShapeChange)
                  (patient ?CHANGE ?OBJ)))
      (attribute ?OBJ Pliable))

If ¤£©ö¸Hªº ¬O obj ªº ÄÝ©Ê, then there doesn't exist ·l®` damage so that obj ¬O damage ªº ¨ü¨ÆªÌ.
(=>
      (attribute ?OBJ Unbreakable)
      (not
            (exists
                  (?DAMAGE)
                  (and
                        (instance ?DAMAGE Damaging)
                        (patient ?DAMAGE ?OBJ)))))