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

¬I¨ÆªÌ (agent)

(agent process agent) means that agent is an active determinant, either animate or inanimate, of the Process process, with or without voluntary intention. For example, water is the agent of erosion in the following proposition: the water eroded the coastline. For another example, Eve is an agent in the following proposition: Eve bit an apple.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

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

Coordinate term(s)

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

Type restrictions

agent(¾úµ{, ¬I¨ÆªÌ)

Related WordNet synsets

agency
the state of being in action or exerting power; "the agency of providence"; "she has free agency"
agency is kind of (all)...   agency is kind of...  
act, move
perform an action; "think before you act"; "We must move quickly"
act is opposite to...   kinds of act...   kinds of act (all)...   see also...  
agential
of or relating to an agent or agency
agential pertains to noun...  
See more related synsets on a separate page.

Axioms (74)

If lang ¬O °Êª«»y¨¥ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ and lang ¹ï proc ¬O ¤u¨ã, then agent ¬O °Êª« ªº ¹ê¨Ò and agent ¬O ¤HÃþ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LANG AnimalLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (and
            (instance ?AGENT Animal)
            (not
                  (instance ?AGENT Human))))

If lang ¬O ¹q¸£»y¨¥ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ and lang ¹ï proc ¬O ¤u¨ã, then agent ¬O ¾÷¾¹ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LANG ComputerLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (instance ?AGENT Machine))

If lang ¬O ¤HÃþ»y¨¥ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ and lang ¹ï proc ¬O ¤u¨ã, then agent ¬O ¤HÃþ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LANG HumanLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (instance ?AGENT Human))

agent ¬O ¬I¨ÆªÌ ªº ¹ê¨Ò if and only if there exists proc so that proc ¬O agent ªº ¬I¨ÆªÌ.
(<=>
      (instance ?AGENT Agent)
      (exists
            (?PROC)
            (agent ?PROC ?AGENT)))

If process ¬O ¾úµ{ ªº ¹ê¨Ò, then there exists cause so that process ¬O cause ªº ¬I¨ÆªÌ.
(=>
      (instance ?PROCESS Process)
      (exists
            (?CAUSE)
            (agent ?PROCESS ?CAUSE)))

If obj (¤£) §Q¥Înot(s) agent, then there exists process so that process ¬O agent ªº ¬I¨ÆªÌ and obj ¹ï process ¬O ¸ê·½.
(=>
      (exploits ?OBJ ?AGENT)
      (exists
            (?PROCESS)
            (and
                  (agent ?PROCESS ?AGENT)
                  (resource ?PROCESS ?OBJ))))

If ¦³§Þ¥©(proc,agent) holds, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ proc.
(=>
      (hasSkill ?PROC ?AGENT)
      (capability ?PROC agent ?AGENT))

If agent ¦³ Åv ¨Ï process ¬°¯u, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ process.
(=>
      (holdsRight ?PROCESS ?AGENT)
      (capability ?PROCESS agent ?AGENT))

If agent ¦³¸q°È °õ¦æ Ãþ«¬ process ¥ô°È, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ process.
(=>
      (holdsObligation ?PROCESS ?AGENT)
      (capability ?PROCESS agent ?AGENT))

If agent ¨Ï¥Î obj, then there exists proc so that proc ¬O agent ªº ¬I¨ÆªÌ and obj ¹ï proc ¬O ¤u¨ã.
(=>
      (uses ?OBJ ?AGENT)
      (exists
            (?PROC)
            (and
                  (agent ?PROC ?AGENT)
                  (instrument ?PROC ?OBJ))))

If digest ¬O ®ø¤Æ ªº ¹ê¨Ò and digest ¬O organism ªº ¬I¨ÆªÌ, then there exists Äá­¹ ingest so that ingest ¬O organism ªº ¬I¨ÆªÌ and "digest ¦s¦b ªº ®É¶¡" (¨S) »P 1 ?­«Å|s.
(=>
      (and
            (instance ?DIGEST Digesting)
            (agent ?DIGEST ?ORGANISM))
      (exists
            (?INGEST)
            (and
                  (instance ?INGEST Ingesting)
                  (agent ?INGEST ?ORGANISM)
                  (overlapsTemporally
                        (WhenFn ?INGEST)
                        (WhenFn ?DIGEST)))))

If rep ¬O ½Æ»s ªº ¹ê¨Ò and rep ¬O parent ªº ¬I¨ÆªÌ and child ¬O rep ªº µ²ªG, then parent ¬O child ªº Âù¿Ë.
(=>
      (and
            (instance ?REP Replication)
            (agent ?REP ?PARENT)
            (result ?REP ?CHILD))
      (parent ?CHILD ?PARENT))

If proc ¬O ·N¦V©Ê¾úµ{ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ, then there exists purp so that proc ¹ïagent ¦³ ·N¹Ï purp.
(=>
      (and
            (instance ?PROC IntentionalProcess)
            (agent ?PROC ?AGENT))
      (exists
            (?PURP)
            (hasPurposeForAgent ?PROC ?PURP ?AGENT)))

If proc ¬O ·N¦V©Ê¾úµ{ ªº ¹ê¨Ò, then there exists ¨ã»{ª¾¤O¬I¨ÆªÌ agent so that proc ¬O agent ªº ¬I¨ÆªÌ.
(=>
      (instance ?PROC IntentionalProcess)
      (exists
            (?AGENT)
            (and
                  (instance ?AGENT CognitiveAgent)
                  (agent ?PROC ?AGENT))))

If act ¬O ²Õ´©Êªº¾úµ{ ªº ¹ê¨Ò and act ¬O agent ªº ¬I¨ÆªÌ, then
(=>
      (and
            (instance ?ACT OrganizationalProcess)
            (agent ?ACT ?AGENT))
      (or
            (instance ?AGENT Organization)
            (exists
                  (?ORG)
                  (and
                        (instance ?ORG Organization)
                        (member ?AGENT ?ORG)))))

If act ¬O ©v±Ð¾úµ{ ªº ¹ê¨Ò and act ¬O agent ªº ¬I¨ÆªÌ, then
(=>
      (and
            (instance ?ACT ReligiousProcess)
            (agent ?ACT ?AGENT))
      (or
            (instance ?AGENT ReligiousOrganization)
            (exists
                  (?ORG)
                  (and
                        (member ?AGENT ?ORG)
                        (instance ?ORG ReligiousOrganization)))))

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 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 walk ¬O ¦æ¨« ªº ¹ê¨Ò and walk ¬O agent ªº ¬I¨ÆªÌ, then there exists ³°¦a area so that agent ¦ì©ó area.
(=>
      (and
            (instance ?WALK Walking)
            (agent ?WALK ?AGENT))
      (exists
            (?AREA)
            (and
                  (instance ?AREA LandArea)
                  (located ?AGENT ?AREA))))

If swim ¬O ¹Cªa ªº ¹ê¨Ò and swim ¬O agent ªº ¬I¨ÆªÌ, then there exists ¤ô°ì area so that agent ¦ì©ó area.
(=>
      (and
            (instance ?SWIM Swimming)
            (agent ?SWIM ?AGENT))
      (exists
            (?AREA)
            (and
                  (instance ?AREA WaterArea)
                  (located ?AGENT ?AREA))))

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 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 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))))

If give ¬O µ¹»P ªº ¹ê¨Ò and give ¬O agent ªº ¬I¨ÆªÌ, then give (¤£) °_·½s ©ó agent.
(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT))
      (origin ?GIVE ?AGENT))

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 get ¬O Àò¨ú ªº ¹ê¨Ò and get ¬O agent ªº ¬I¨ÆªÌ, then get (¤£) ²×µ²not(s) agent.
(=>
      (and
            (instance ?GET Getting)
            (agent ?GET ?AGENT))
      (destination ?GET ?AGENT))

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 buy ¬O ¶R ªº ¹ê¨Ò and buy ¬O agent ªº ¬I¨ÆªÌ, then buy (¤£) ²×µ²not(s) agent.
(=>
      (and
            (instance ?BUY Buying)
            (agent ?BUY ?AGENT))
      (destination ?BUY ?AGENT))

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 sell ¬O ¾P°â ªº ¹ê¨Ò and sell ¬O agent ªº ¬I¨ÆªÌ, then sell (¤£) °_·½s ©ó agent.
(=>
      (and
            (instance ?SELL Selling)
            (agent ?SELL ?AGENT))
      (origin ?SELL ?AGENT))

If learn ¬O ¾Ç²ß ªº ¹ê¨Ò and learn ¬O agent ªº ¬I¨ÆªÌ, then agent ¬O ¨ã»{ª¾¤O¬I¨ÆªÌ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LEARN Learning)
            (agent ?LEARN ?AGENT))
      (instance ?AGENT CognitiveAgent))

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 agent ¬O ¨ã»{ª¾¤O¬I¨ÆªÌ ªº ¹ê¨Ò, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ ±À²z.
(=>
      (instance ?AGENT CognitiveAgent)
      (capability Reasoning agent ?AGENT))

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 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)))))

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 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 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 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 proc ¬O ¶EÂ_¾úµ{ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ, then there exists cause so that proc ¹ïagent ¦³ ·N¹Ï "agent (¤£¡^ª¾¹Ds) %2".
(=>
      (and
            (instance ?PROC DiagnosticProcess)
            (agent ?PROC ?AGENT))
      (exists
            (?CAUSE)
            (hasPurposeForAgent
                  ?PROC
                  (knows
                        ?AGENT
                        (causes ?CAUSE ?PROC))
                  ?AGENT)))

If interaction ¬O ¤H»Ú¤¬°Ê ªº ¹ê¨Ò, then there exist agent1,agent2 so that interaction ¬O agent1 ªº ¬I¨ÆªÌ and interaction ¬O agent2 ªº ¬I¨ÆªÌ and agent1 µ¥©ó agent2.
(=>
      (instance ?INTERACTION SocialInteraction)
      (exists
            (?AGENT1 ?AGENT2)
            (and
                  (agent ?INTERACTION ?AGENT1)
                  (agent ?INTERACTION ?AGENT2)
                  (not
                        (equal ?AGENT1 ?AGENT2)))))

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 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 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 express ¬O ªí¹F ªº ¹ê¨Ò and express ¬O agent ªº ¬I¨ÆªÌ, then there exists ¤ß²zª¬ºA state so that state ¬O agent ªº ÄÝ©Ê and express ªí¹F state.
(=>
      (and
            (instance ?EXPRESS Expressing)
            (agent ?EXPRESS ?AGENT))
      (exists
            (?STATE)
            (and
                  (instance ?STATE StateOfMind)
                  (attribute ?AGENT ?STATE)
                  (represents ?EXPRESS ?STATE))))

If declare ¬O «Å§i ªº ¹ê¨Ò and declare ¬O agent1 ªº ¬I¨ÆªÌ, then there exist proc,agent2 so that declare ½á¤© agent2 Åv¤O °õ¦æ Ãþ«¬ proc ¥ô°È or declare ½á¤© agent2 ¸q°È °õ¦æ Ãþ«¬ proc ¥ô°È.
(=>
      (and
            (instance ?DECLARE Declaring)
            (agent ?DECLARE ?AGENT1))
      (exists
            (?PROC ?AGENT2)
            (or
                  (confersRight ?PROC ?DECLARE ?AGENT2)
                  (confersObligation ?PROC ?DECLARE ?AGENT2))))

(=>
      (instance ?COOPERATE Cooperation)
      (exists
            (?PURP)
            (forall
                  (?AGENT)
                  (=>
                        (agent ?COOPERATE ?AGENT)
                        (hasPurposeForAgent ?COOPERATE ?PURP ?AGENT)))))

If meet ¬O ·|­± ªº ¹ê¨Ò and meet ¬O agent1 ªº ¬I¨ÆªÌ and meet ¬O agent2 ªº ¬I¨ÆªÌ, then agent1 ¹ï agent2 ¬O ±µªñ "meet ¦s¦b ªº ®É¶¡"a(¤§¤¤) meet ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?MEET Meeting)
            (agent ?MEET ?AGENT1)
            (agent ?MEET ?AGENT2))
      (holdsDuring
            (WhenFn ?MEET)
            (orientation ?AGENT1 ?AGENT2 Near)))

If meet ¬O ·|­± ªº ¹ê¨Ò, then there exist agent1,agent2 so that meet ¬O agent1 ªº ¬I¨ÆªÌ and meet ¬O agent2 ªº ¬I¨ÆªÌ and meet ¦³ ·N¹Ï "there exists ·¾³q comm so that comm ¬O agent1 ªº ¬I¨ÆªÌ and comm ¬O agent2 ªº ¬I¨ÆªÌ".
(=>
      (instance ?MEET Meeting)
      (exists
            (?AGENT1 ?AGENT2)
            (and
                  (agent ?MEET ?AGENT1)
                  (agent ?MEET ?AGENT2)
                  (hasPurpose
                        ?MEET
                        (exists
                              (?COMM)
                              (and
                                    (instance ?COMM Communication)
                                    (agent ?COMM ?AGENT1)
                                    (agent ?COMM ?AGENT2)))))))

If contest ¬O Ävª§ ªº ¹ê¨Ò, then there exist agent1,agent2,purp1,purp2 so that contest ¬O agent1 ªº ¬I¨ÆªÌ and contest ¬O agent2 ªº ¬I¨ÆªÌ and contest ¹ïagent1 ¦³ ·N¹Ï purp1 and contest ¹ïagent2 ¦³ ·N¹Ï purp2 and agent1 µ¥©ó agent2 and purp1 µ¥©ó purp2.
(=>
      (instance ?CONTEST Contest)
      (exists
            (?AGENT1 ?AGENT2 ?PURP1 ?PURP2)
            (and
                  (agent ?CONTEST ?AGENT1)
                  (agent ?CONTEST ?AGENT2)
                  (hasPurposeForAgent ?CONTEST ?PURP1 ?AGENT1)
                  (hasPurposeForAgent ?CONTEST ?PURP2 ?AGENT2)
                  (not
                        (equal ?AGENT1 ?AGENT2))
                  (not
                        (equal ?PURP1 ?PURP2)))))

(=>
      (and
            (instance ?WAR War)
            (agent ?WAR ?AGENT))
      (or
            (instance ?AGENT Nation)
            (and
                  (instance ?AGENT Organization)
                  (forall
                        (?MEMBER)
                        (=>
                              (member ?MEMBER ?AGENT)
                              (instance ?MEMBER Nation))))))

If percept ¬O ª¾Ä± ªº ¹ê¨Ò and percept ¬O agent ªº ¬I¨ÆªÌ, then agent ¬O °Êª« ªº ¹ê¨Ò.
(=>
      (and
            (instance ?PERCEPT Perception)
            (agent ?PERCEPT ?AGENT))
      (instance ?AGENT Animal))

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 emit ¬O Án­µ ªº ¹ê¨Ò and emit ¬O sound ªº ¬I¨ÆªÌ, then there exists Án­µÄÝ©Ê attr so that attr ¬O sound ªº ÄÝ©Ê.
(=>
      (and
            (instance ?EMIT RadiatingSound)
            (agent ?EMIT ?SOUND))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?SOUND ?ATTR))))

If virus ¬O ¯f¬r ªº ¹ê¨Ò and proc ¬O ½Æ»s ªº ¹ê¨Ò and proc ¬O virus ªº ¬I¨ÆªÌ, then there exists ²Ó­M cell so that proc ¦ì©ó cell.
(=>
      (and
            (instance ?VIRUS Virus)
            (instance ?PROC Replication)
            (agent ?PROC ?VIRUS))
      (exists
            (?CELL)
            (and
                  (located ?PROC ?CELL)
                  (instance ?CELL Cell))))

If §@ªÌ(agent,text) holds, then there exist process,text instance so that process ¬O agent ªº ¬I¨ÆªÌ and text ¬O process ªº µ²ªG.
(=>
      (authors ?AGENT ?TEXT)
      (exists
            (?PROCESS ?INSTANCE)
            (and
                  (agent ?PROCESS ?AGENT)
                  (instance ?INSTANCE ?TEXT)
                  (result ?PROCESS ?TEXT))))

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 building ¬O «Ø¿vª« ªº ¹ê¨Ò, then there exists ¤HÃþ human so that
(=>
      (instance ?BUILDING Building)
      (exists
            (?HUMAN)
            (and
                  (instance ?HUMAN Human)
                  (or
                        (inhabits ?HUMAN ?BUILDING)
                        (exists
                              (?ACT)
                              (and
                                    (agent ?ACT ?HUMAN)
                                    (located ?ACT ?BUILDING)))))))

If pol ¬O ¬Fªv²Õ´ ªº ¹ê¨Ò, then there exists ¬Fªv¾úµ{ proc so that proc ¬O pol ªº ¬I¨ÆªÌ.
(=>
      (instance ?POL PoliticalOrganization)
      (exists
            (?PROC)
            (and
                  (instance ?PROC PoliticalProcess)
                  (agent ?PROC ?POL))))

If agent ¦³¸q°È °õ¦æ Ãþ«¬ process ¥ô°È, then ³¯­z "there exists process instance so that instance ¬O agent ªº ¬I¨ÆªÌ" ¦³ ¸q°È ªº «¬ºA·N¸q.
(=>
      (holdsObligation ?PROCESS ?AGENT)
      (modalAttribute
            (exists
                  (?INSTANCE)
                  (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT)))
            Obligation))

If agent ¦³ Åv ¨Ï process ¬°¯u, then ³¯­z "there exists process instance so that instance ¬O agent ªº ¬I¨ÆªÌ" ¦³ ³\¥i ªº «¬ºA·N¸q.
(=>
      (holdsRight ?PROCESS ?AGENT)
      (modalAttribute
            (exists
                  (?INSTANCE)
                  (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT)))
            Permission))

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 organism ¬O ¥Íª«Åé ªº ¹ê¨Ò and process ¬O organism ªº ¬I¨ÆªÌ, then ¬¡ªº ¬O organism ªº ÄÝ©Ê "process ¦s¦b ªº ®É¶¡"a(¤§¤¤) process ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?ORGANISM Organism)
            (agent ?PROCESS ?ORGANISM))
      (holdsDuring
            (WhenFn ?PROCESS)
            (attribute ?ORGANISM Living)))