agent (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.

Ontologie

SUMO / BASE-ONTOLOGY

Class(es)

třída

inheritable relation

case role

agent

Související termín(y)

destination direction experiencer origin path patient

Typy argumentů

agent(proces, původce)

Related WordNet synsets

agency: the state of being in action or exerting power; "the agency of providence"; "she has free agency"
act, move: perform an action; "think before you act"; "We must move quickly"
agential: of or relating to an agent or agency

See more related synsets on a separate page.

Axiomy (74)

Jestliže lang je instancí třídy zvířecí jazyk a agent je původcem proc a lang je nástrojem for proc, potom agent je instancí třídy zvíře a agent není instancí třídy člověk.

(=>
      (and
            (instance ?LANG AnimalLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (and
            (instance ?AGENT Animal)
            (not
                  (instance ?AGENT Human))))

Jestliže lang je instancí třídy počítačový jazyk a agent je původcem proc a lang je nástrojem for proc, potom agent je instancí třídy stroj.

(=>
      (and
            (instance ?LANG ComputerLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (instance ?AGENT Machine))

Jestliže lang je instancí třídy lidský jazyk a agent je původcem proc a lang je nástrojem for proc, potom agent je instancí třídy člověk.

(=>
      (and
            (instance ?LANG HumanLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (instance ?AGENT Human))

agent je instancí třídy původce tehdy a jen tehdy pokud existuje proc tak, že agent je původcem proc.

(<=>
      (instance ?AGENT Agent)
      (exists
            (?PROC)
            (agent ?PROC ?AGENT)))

Jestliže process je instancí třídy proces, potom existuje cause tak, že cause je původcem process.

(=>
      (instance ?PROCESS Process)
      (exists
            (?CAUSE)
            (agent ?PROCESS ?CAUSE)))

Jestliže obj exploits agent, potom existuje process tak, že agent je původcem process a obj je nástrojem pro process.

(=>
      (exploits ?OBJ ?AGENT)
      (exists
            (?PROCESS)
            (and
                  (agent ?PROCESS ?AGENT)
                  (resource ?PROCESS ?OBJ))))

Jestliže agent has skill to do proc, potom agent je capable to do proc in role agent.

(=>
      (hasSkill ?PROC ?AGENT)
      (capability ?PROC agent ?AGENT))

Jestliže agent has the right to perform process, potom agent je capable to do process in role agent.

(=>
      (holdsRight ?PROCESS ?AGENT)
      (capability ?PROCESS agent ?AGENT))

Jestliže holds obligation(process,agent) platí, potom agent je capable to do process in role agent.

(=>
      (holdsObligation ?PROCESS ?AGENT)
      (capability ?PROCESS agent ?AGENT))

Jestliže uses(obj,agent) platí, potom existuje proc tak, že agent je původcem proc a obj je nástrojem for proc.

(=>
      (uses ?OBJ ?AGENT)
      (exists
            (?PROC)
            (and
                  (agent ?PROC ?AGENT)
                  (instrument ?PROC ?OBJ))))

Jestliže digest je instancí třídy digesting a organism je původcem digest, potom existuje zažívání ingest tak, že organism je původcem ingest a "doba existence digest" overlaps "doba existence ingest".

(=>
      (and
            (instance ?DIGEST Digesting)
            (agent ?DIGEST ?ORGANISM))
      (exists
            (?INGEST)
            (and
                  (instance ?INGEST Ingesting)
                  (agent ?INGEST ?ORGANISM)
                  (overlapsTemporally
                        (WhenFn ?INGEST)
                        (WhenFn ?DIGEST)))))

Jestliže rep je instancí třídy replikace a parent je původcem rep a child je výsledkem rep, potom parent je a parent of child.

(=>
      (and
            (instance ?REP Replication)
            (agent ?REP ?PARENT)
            (result ?REP ?CHILD))
      (parent ?CHILD ?PARENT))

Jestliže proc je instancí třídy záměrný proces a agent je původcem proc, potom existuje purp tak, že proc has purpose purp for agent.

(=>
      (and
            (instance ?PROC IntentionalProcess)
            (agent ?PROC ?AGENT))
      (exists
            (?PURP)
            (hasPurposeForAgent ?PROC ?PURP ?AGENT)))

Jestliže proc je instancí třídy záměrný proces, potom existuje myslící agent agent tak, že agent je původcem proc.

(=>
      (instance ?PROC IntentionalProcess)
      (exists
            (?AGENT)
            (and
                  (instance ?AGENT CognitiveAgent)
                  (agent ?PROC ?AGENT))))

Jestliže act je instancí třídy organizační proces a agent je původcem act, potom

agent je instancí třídy organizace
existuje organizace org tak, že agent je a členem org

(=>
      (and
            (instance ?ACT OrganizationalProcess)
            (agent ?ACT ?AGENT))
      (or
            (instance ?AGENT Organization)
            (exists
                  (?ORG)
                  (and
                        (instance ?ORG Organization)
                        (member ?AGENT ?ORG)))))

Jestliže act je instancí třídy náboženský proces a agent je původcem act, potom

agent je instancí třídy náboženská organizace
existuje náboženská organizace org tak, že agent je a členem org

(=>
      (and
            (instance ?ACT ReligiousProcess)
            (agent ?ACT ?AGENT))
      (or
            (instance ?AGENT ReligiousOrganization)
            (exists
                  (?ORG)
                  (and
                        (member ?AGENT ?ORG)
                        (instance ?ORG ReligiousOrganization)))))

Jestliže join je instancí třídy nastoupení do organizace a org je instancí třídy organizace a org je původcem join a person je účastníkem join, potom person je a členem org právě po doba existence join.

(=>
      (and
            (instance ?JOIN JoiningAnOrganization)
            (instance ?ORG Organization)
            (agent ?JOIN ?ORG)
            (patient ?JOIN ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?JOIN))
            (member ?PERSON ?ORG)))

Jestliže leave je instancí třídy opuštění organizace a org je instancí třídy organizace a org je původcem leave a person je účastníkem leave, potom person není a členem org právě po doba existence leave.

(=>
      (and
            (instance ?LEAVE LeavingAnOrganization)
            (instance ?ORG Organization)
            (agent ?LEAVE ?ORG)
            (patient ?LEAVE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?LEAVE))
            (not
                  (member ?PERSON ?ORG))))

Jestliže grad je instancí třídy graduování a org je původcem grad a person je účastníkem grad, potom org je instancí třídy vzdělávací organizace.

(=>
      (and
            (instance ?GRAD Graduation)
            (agent ?GRAD ?ORG)
            (patient ?GRAD ?PERSON))
      (instance ?ORG EducationalOrganization))

Jestliže mat je instancí třídy matrikulace a org je původcem mat a person je účastníkem mat, potom org je instancí třídy vzdělávací organizace.

(=>
      (and
            (instance ?MAT Matriculation)
            (agent ?MAT ?ORG)
            (patient ?MAT ?PERSON))
      (instance ?ORG EducationalOrganization))

Jestliže hire je instancí třídy najímání a org je instancí třídy organizace a org je původcem hire a person je účastníkem hire, potom org employs person právě po doba existence hire.

(=>
      (and
            (instance ?HIRE Hiring)
            (instance ?ORG Organization)
            (agent ?HIRE ?ORG)
            (patient ?HIRE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?HIRE))
            (employs ?ORG ?PERSON)))

Jestliže fire je instancí třídy ukončení pracovního poměru a org je instancí třídy organizace a org je původcem fire a person je účastníkem fire, potom org doesn't employ person právě po doba existence fire.

(=>
      (and
            (instance ?FIRE TerminatingEmployment)
            (instance ?ORG Organization)
            (agent ?FIRE ?ORG)
            (patient ?FIRE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?FIRE))
            (not
                  (employs ?ORG ?PERSON))))

Jestliže proc je instancí třídy politický proces, potom existuje vláda gov tak, že gov je původcem proc nebo gov je účastníkem proc.

(=>
      (instance ?PROC PoliticalProcess)
      (exists
            (?GOV)
            (and
                  (instance ?GOV Government)
                  (or
                        (agent ?PROC ?GOV)
                        (patient ?PROC ?GOV)))))

Jestliže motion je instancí třídy tělesný pohyb, potom existují část těla obj,organismus agent tak, že obj je účastníkem motion a agent je původcem motion.

(=>
      (instance ?MOTION BodyMotion)
      (exists
            (?OBJ ?AGENT)
            (and
                  (instance ?OBJ BodyPart)
                  (patient ?MOTION ?OBJ)
                  (instance ?AGENT Organism)
                  (agent ?MOTION ?AGENT))))

Jestliže walk je instancí třídy chůze a agent je původcem walk, potom existuje souš area tak, že agent je located at area.

(=>
      (and
            (instance ?WALK Walking)
            (agent ?WALK ?AGENT))
      (exists
            (?AREA)
            (and
                  (instance ?AREA LandArea)
                  (located ?AGENT ?AREA))))

Jestliže swim je instancí třídy plavání a agent je původcem swim, potom existuje vodní plocha area tak, že agent je located at area.

(=>
      (and
            (instance ?SWIM Swimming)
            (agent ?SWIM ?AGENT))
      (exists
            (?AREA)
            (and
                  (instance ?AREA WaterArea)
                  (located ?AGENT ?AREA))))

Jestliže transfer je instancí třídy přeprava a agent je původcem transfer a patient je účastníkem transfer, potom agent se nerovná patient.

(=>
      (and
            (instance ?TRANSFER Transfer)
            (agent ?TRANSFER ?AGENT)
            (patient ?TRANSFER ?PATIENT))
      (not
            (equal ?AGENT ?PATIENT)))

Jestliže touch je instancí třídy dotyk a obj1 je původcem touch a obj2 je účastníkem touch, potom obj1 je spojen s obj2 právě po doba existence touch.

(=>
      (and
            (instance ?TOUCH Touching)
            (agent ?TOUCH ?OBJ1)
            (patient ?TOUCH ?OBJ2))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?TOUCH))
            (connected ?OBJ1 ?OBJ2)))

Jestliže give je instancí třídy dávání a agent1 je původcem give a give končí v agent2 a agent2 je instancí třídy původce a obj je účastníkem give, potom existuje braní get tak, že agent2 je původcem get a get začíná v agent1 a obj je účastníkem 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))))

Jestliže give je instancí třídy dávání a agent je původcem give, potom give začíná v agent.

(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT))
      (origin ?GIVE ?AGENT))

Existuje půjčování si borrow tak, že agent1 je původcem borrow a borrow začíná v agent2 a object je účastníkem borrow tehdy a jen tehdy pokud existuje půjčování lend tak, že agent2 je původcem lend a lend končí v agent1 a object je účastníkem 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))))

Jestliže get je instancí třídy braní a agent je původcem get, potom get končí v agent.

(=>
      (and
            (instance ?GET Getting)
            (agent ?GET ?AGENT))
      (destination ?GET ?AGENT))

Jestliže trans je instancí třídy transakce, potom existují agent1,agent2,dávání give1,dávání give2,obj1,obj2 tak, že give1 je a subprocess of trans a give2 je a subprocess of trans a agent1 je původcem give1 a agent2 je původcem give2 a obj1 je účastníkem give1 a obj2 je účastníkem give2 a give1 končí v agent2 a give2 končí v agent1 a agent1 se nerovná agent2 a obj1 se nerovná 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)))))

Jestliže buy je instancí třídy kupování a agent je původcem buy, potom buy končí v agent.

(=>
      (and
            (instance ?BUY Buying)
            (agent ?BUY ?AGENT))
      (destination ?BUY ?AGENT))

Existuje kupování buy tak, že agent1 je původcem buy a buy začíná v agent2 a object je účastníkem buy tehdy a jen tehdy pokud existuje prodávání sell tak, že agent2 je původcem sell a sell končí v agent1 a object je účastníkem 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))))

Jestliže sell je instancí třídy prodávání a agent je původcem sell, potom sell začíná v agent.

(=>
      (and
            (instance ?SELL Selling)
            (agent ?SELL ?AGENT))
      (origin ?SELL ?AGENT))

Jestliže learn je instancí třídy učení se a agent je původcem learn, potom agent je instancí třídy myslící agent.

(=>
      (and
            (instance ?LEARN Learning)
            (agent ?LEARN ?AGENT))
      (instance ?AGENT CognitiveAgent))

Jestliže existuje učení se learn tak, že agent je původcem learn a prop je účastníkem learn během time, potom agent believes prop právě po time.

(=>
      (holdsDuring
            ?TIME
            (exists
                  (?LEARN)
                  (and
                        (instance ?LEARN Learning)
                        (agent ?LEARN ?AGENT)
                        (patient ?LEARN ?PROP))))
      (holdsDuring
            (ImmediateFutureFn ?TIME)
            (believes ?AGENT ?PROP)))

Jestliže agent je instancí třídy myslící agent, potom agent je capable to do usuzování in role agent.

(=>
      (instance ?AGENT CognitiveAgent)
      (capability Reasoning agent ?AGENT))

Jestliže meas je instancí třídy měření a agent je původcem meas a obj je účastníkem meas, potom existují quant,unit tak, že agent knows "the measure of obj je "quant unit(s)"" právě po doba existence meas.

(=>
      (and
            (instance ?MEAS Measuring)
            (agent ?MEAS ?AGENT)
            (patient ?MEAS ?OBJ))
      (exists
            (?QUANT ?UNIT)
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?MEAS))
                  (knows
                        ?AGENT
                        (measure
                              ?OBJ
                              (MeasureFn ?QUANT ?UNIT))))))

Jestliže count je instancí třídy sčítání a agent je původcem count a entity je účastníkem count, potom existuje number tak, že agent knows ""cardinality fn(entity)" se rovná number".

(=>
      (and
            (instance ?COUNT Counting)
            (agent ?COUNT ?AGENT)
            (patient ?COUNT ?ENTITY))
      (exists
            (?NUMBER)
            (knows
                  ?AGENT
                  (equal
                        (CardinalityFn ?ENTITY)
                        ?NUMBER))))

Jestliže keep je instancí třídy držení a agent je původcem keep a obj je účastníkem keep, potom existuje uložení put tak, že agent je původcem put a obj je účastníkem put a "doba existence put" happens earlier than "doba existence keep".

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

Jestliže kill je instancí třídy zabití a agent je původcem kill a patient je účastníkem kill, potom agent je instancí třídy organismus a patient je instancí třídy organismus.

(=>
      (and
            (instance ?KILL Killing)
            (agent ?KILL ?AGENT)
            (patient ?KILL ?PATIENT))
      (and
            (instance ?AGENT Organism)
            (instance ?PATIENT Organism)))

Jestliže poke je instancí třídy propíchnutí a agent je původcem poke a obj je účastníkem poke a inst je nástrojem for poke, potom inst spojuje agent a obj doba existence poke.

(=>
      (and
            (instance ?POKE Poking)
            (agent ?POKE ?AGENT)
            (patient ?POKE ?OBJ)
            (instrument ?POKE ?INST))
      (holdsDuring
            (WhenFn ?POKE)
            (connects ?INST ?AGENT ?OBJ)))

Jestliže search je instancí třídy hledání a agent je původcem search a entity je účastníkem search, potom agent je interested in entity.

(=>
      (and
            (instance ?SEARCH Searching)
            (agent ?SEARCH ?AGENT)
            (patient ?SEARCH ?ENTITY))
      (inScopeOfInterest ?AGENT ?ENTITY))

Jestliže pursue je instancí třídy sledování a agent je původcem pursue a obj je účastníkem pursue, potom agent wants obj během pursue.

(=>
      (and
            (instance ?PURSUE Pursuing)
            (agent ?PURSUE ?AGENT)
            (patient ?PURSUE ?OBJ))
      (holdsDuring
            ?PURSUE
            (wants ?AGENT ?OBJ)))

Jestliže pursue je instancí třídy sledování a agent je původcem pursue a obj je účastníkem pursue, potom agent doesn't posess obj během pursue.

(=>
      (and
            (instance ?PURSUE Pursuing)
            (agent ?PURSUE ?AGENT)
            (patient ?PURSUE ?OBJ))
      (holdsDuring
            ?PURSUE
            (not
                  (possesses ?AGENT ?OBJ))))

Jestliže investigate je instancí třídy vyšetřování a agent je původcem investigate a prop je účastníkem investigate, potom agent doesn't know prop doba existence investigate.

(=>
      (and
            (instance ?INVESTIGATE Investigating)
            (agent ?INVESTIGATE ?AGENT)
            (patient ?INVESTIGATE ?PROP))
      (holdsDuring
            (WhenFn ?INVESTIGATE)
            (not
                  (knows ?AGENT ?PROP))))

Jestliže proc je instancí třídy diagnostický proces a agent je původcem proc, potom existuje cause tak, že proc has purpose "agent knows "cause causes proc"" for agent.

(=>
      (and
            (instance ?PROC DiagnosticProcess)
            (agent ?PROC ?AGENT))
      (exists
            (?CAUSE)
            (hasPurposeForAgent
                  ?PROC
                  (knows
                        ?AGENT
                        (causes ?CAUSE ?PROC))
                  ?AGENT)))

Jestliže interaction je instancí třídy sociální interakce, potom existují agent1,agent2 tak, že agent1 je původcem interaction a agent2 je původcem interaction a agent1 se nerovná agent2.

(=>
      (instance ?INTERACTION SocialInteraction)
      (exists
            (?AGENT1 ?AGENT2)
            (and
                  (agent ?INTERACTION ?AGENT1)
                  (agent ?INTERACTION ?AGENT2)
                  (not
                        (equal ?AGENT1 ?AGENT2)))))

Jestliže communicate je instancí třídy komunikace, potom existují objekt nesoucí informaci obj,myslící agent agent1,myslící agent agent2 tak, že obj je účastníkem communicate a agent1 je původcem communicate a communicate končí v 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))))

Jestliže state je instancí třídy tvrzení a agent je původcem state a formula je účastníkem state a formula je instancí třídy formule, potom agent believes formula doba existence state.

(=>
      (and
            (instance ?STATE Stating)
            (agent ?STATE ?AGENT)
            (patient ?STATE ?FORMULA)
            (instance ?FORMULA Formula))
      (holdsDuring
            (WhenFn ?STATE)
            (believes ?AGENT ?FORMULA)))

Jestliže request je instancí třídy požadavek a agent je původcem request a formula je účastníkem request a formula je instancí třídy formule, potom agent desires formula.

(=>
      (and
            (instance ?REQUEST Requesting)
            (agent ?REQUEST ?AGENT)
            (patient ?REQUEST ?FORMULA)
            (instance ?FORMULA Formula))
      (desires ?AGENT ?FORMULA))

Jestliže question je instancí třídy dotaz a agent je původcem question a formula je účastníkem question a formula je instancí třídy formule, potom agent doesn't know formula doba existence question.

(=>
      (and
            (instance ?QUESTION Questioning)
            (agent ?QUESTION ?AGENT)
            (patient ?QUESTION ?FORMULA)
            (instance ?FORMULA Formula))
      (holdsDuring
            (WhenFn ?QUESTION)
            (not
                  (knows ?AGENT ?FORMULA))))

Jestliže express je instancí třídy vyjádření a agent je původcem express, potom existuje stav mysli state tak, že state je atributem agent a represents(express,state) platí.

(=>
      (and
            (instance ?EXPRESS Expressing)
            (agent ?EXPRESS ?AGENT))
      (exists
            (?STATE)
            (and
                  (instance ?STATE StateOfMind)
                  (attribute ?AGENT ?STATE)
                  (represents ?EXPRESS ?STATE))))

Jestliže declare je instancí třídy deklarace a agent1 je původcem declare, potom existují proc,agent2 tak, že confers right(proc,declare,agent2) platí nebo confers obligation(proc,declare,agent2) platí.

(=>
      (and
            (instance ?DECLARE Declaring)
            (agent ?DECLARE ?AGENT1))
      (exists
            (?PROC ?AGENT2)
            (or
                  (confersRight ?PROC ?DECLARE ?AGENT2)
                  (confersObligation ?PROC ?DECLARE ?AGENT2))))

jestliže cooperate je instancí třídy spolupráce,
potom existuje purp tak, že pro všechny agent platí: jestliže agent je původcem cooperate, potom cooperate has purpose purp for agent

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

Jestliže meet je instancí třídy setkání a agent1 je původcem meet a agent2 je původcem meet, potom agent1 je near vzhledem k agent2 doba existence meet.

(=>
      (and
            (instance ?MEET Meeting)
            (agent ?MEET ?AGENT1)
            (agent ?MEET ?AGENT2))
      (holdsDuring
            (WhenFn ?MEET)
            (orientation ?AGENT1 ?AGENT2 Near)))

Jestliže meet je instancí třídy setkání, potom existují agent1,agent2 tak, že agent1 je původcem meet a agent2 je původcem meet a meet has purpose "existuje komunikace comm tak, že agent1 je původcem comm a agent2 je původcem comm".

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

Jestliže contest je instancí třídy soutěž, potom existují agent1,agent2,purp1,purp2 tak, že agent1 je původcem contest a agent2 je původcem contest a contest has purpose purp1 for agent1 a contest has purpose purp2 for agent2 a agent1 se nerovná agent2 a purp1 se nerovná 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)))))

jestliže war je instancí třídy válka a agent je původcem war,
potom
- agent je instancí třídy národ
- - agent je instancí třídy organizace
  - pro všechny member platí: jestliže member je a členem agent, potom member je instancí třídy národ

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

Jestliže percept je instancí třídy vnímání a agent je původcem percept, potom agent je instancí třídy zvíře.

(=>
      (and
            (instance ?PERCEPT Perception)
            (agent ?PERCEPT ?AGENT))
      (instance ?AGENT Animal))

Jestliže percept je instancí třídy vnímání a agent je původcem percept a object je účastníkem percept, potom agent notices object.

(=>
      (and
            (instance ?PERCEPT Perception)
            (agent ?PERCEPT ?AGENT)
            (patient ?PERCEPT ?OBJECT))
      (notices ?AGENT ?OBJECT))

Jestliže see je instancí třídy vidění a agent je původcem see a obj je účastníkem see, potom

illuminated je atributem obj
existuje atribut barvy prop tak, že agent knows "prop je atributem obj"

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

Jestliže emit je instancí třídy vyzařování zvuku a sound je původcem emit, potom existuje zvuk attr tak, že attr je atributem sound.

(=>
      (and
            (instance ?EMIT RadiatingSound)
            (agent ?EMIT ?SOUND))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?SOUND ?ATTR))))

Jestliže virus je instancí třídy virus a proc je instancí třídy replikace a virus je původcem proc, potom existuje buňka cell tak, že proc je located at cell.

(=>
      (and
            (instance ?VIRUS Virus)
            (instance ?PROC Replication)
            (agent ?PROC ?VIRUS))
      (exists
            (?CELL)
            (and
                  (located ?PROC ?CELL)
                  (instance ?CELL Cell))))

Jestliže authors(agent,text) platí, potom existují process,text instance tak, že agent je původcem process a text je výsledkem process.

(=>
      (authors ?AGENT ?TEXT)
      (exists
            (?PROCESS ?INSTANCE)
            (and
                  (agent ?PROCESS ?AGENT)
                  (instance ?INSTANCE ?TEXT)
                  (result ?PROCESS ?TEXT))))

publishes(org,text) platí tehdy a jen tehdy pokud existuje publikování pub tak, že org je původcem pub a text je účastníkem pub.

(<=>
      (publishes ?ORG ?TEXT)
      (exists
            (?PUB)
            (and
                  (instance ?PUB Publication)
                  (agent ?PUB ?ORG)
                  (patient ?PUB ?TEXT))))

Jestliže building je instancí třídy budova, potom existuje člověk human tak, že

human lives in building
existuje act tak, že human je původcem act a act je located at building

(=>
      (instance ?BUILDING Building)
      (exists
            (?HUMAN)
            (and
                  (instance ?HUMAN Human)
                  (or
                        (inhabits ?HUMAN ?BUILDING)
                        (exists
                              (?ACT)
                              (and
                                    (agent ?ACT ?HUMAN)
                                    (located ?ACT ?BUILDING)))))))

Jestliže pol je instancí třídy politická organizace, potom existuje politický proces proc tak, že pol je původcem proc.

(=>
      (instance ?POL PoliticalOrganization)
      (exists
            (?PROC)
            (and
                  (instance ?PROC PoliticalProcess)
                  (agent ?PROC ?POL))))

Jestliže holds obligation(process,agent) platí, potom modal attribute(existuje process instance tak, že agent je původcem instance,obligation) platí.

(=>
      (holdsObligation ?PROCESS ?AGENT)
      (modalAttribute
            (exists
                  (?INSTANCE)
                  (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT)))
            Obligation))

Jestliže agent has the right to perform process, potom modal attribute(existuje process instance tak, že agent je původcem instance,permission) platí.

(=>
      (holdsRight ?PROCESS ?AGENT)
      (modalAttribute
            (exists
                  (?INSTANCE)
                  (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT)))
            Permission))

Jestliže attr je atributem obj a attr je instancí třídy soutěžní atribut, potom existuje soutěž contest tak, že obj je původcem contest nebo obj je účastníkem contest.

(=>
      (and
            (attribute ?OBJ ?ATTR)
            (instance ?ATTR ContestAttribute))
      (exists
            (?CONTEST)
            (and
                  (instance ?CONTEST Contest)
                  (or
                        (agent ?CONTEST ?OBJ)
                        (patient ?CONTEST ?OBJ)))))

Jestliže organism je instancí třídy organismus a organism je původcem process, potom living je atributem organism doba existence process.

(=>
      (and
            (instance ?ORGANISM Organism)
            (agent ?PROCESS ?ORGANISM))
      (holdsDuring
            (WhenFn ?PROCESS)
            (attribute ?ORGANISM Living)))