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.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

class

inheritable relation

case role

agent

Coordinate term(s)

destination direction experiencer origin path patient

Type restrictions

agent(process, agent)

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.

Axioms (74)

If lang is an instance of animal language and proc is an agent of agent and lang is an instrument for proc, then agent is an instance of animal and agent is not an instance of human.

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

If lang is an instance of computer language and proc is an agent of agent and lang is an instrument for proc, then agent is an instance of machine.

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

If lang is an instance of human language and proc is an agent of agent and lang is an instrument for proc, then agent is an instance of human.

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

agent is an instance of agent if and only if there exists proc so that proc is an agent of agent.

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

If process is an instance of process, then there exists cause so that process is an agent of cause.

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

If obj exploits agent, then there exists process so that process is an agent of agent and obj is a resource for process.

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

If agent has &n skill to do proc, then agent is capable to do proc in role agent.

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

If agent has the right to perform process, then agent is capable to do process in role agent.

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

If agent is obliged to perform tasks of type process, then agent is capable to do process in role agent.

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

If agent uses obj, then there exists proc so that proc is an agent of agent and obj is an instrument for proc.

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

If digest is an instance of digesting and digest is an agent of organism, then there exists ingesting ingest so that ingest is an agent of organism and "the time of existence of digest" overlaps "the time of existence of ingest".

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

If rep is an instance of replication and rep is an agent of parent and child is a result of rep, then parent is a parent of child.

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

If proc is an instance of intentional process and proc is an agent of agent, then there exists purp so that proc has &n purpose purp for agent.

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

If proc is an instance of intentional process, then there exists cognitive agent agent so that proc is an agent of agent.

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

If act is an instance of organizational process and act is an agent of agent, then

agent is an instance of organization
there exists organization org so that agent is a member of org

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

If act is an instance of religious process and act is an agent of agent, then

agent is an instance of religious organization
there exists religious organization org so that agent is a member of org

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

If join is an instance of joining an organization and org is an instance of organization and join is an agent of org and person is a patient of join, then person is a member of org immediately after "the time of existence of join".

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

If leave is an instance of leaving an organization and org is an instance of organization and leave is an agent of org and person is a patient of leave, then person is not a member of org immediately after "the time of existence of leave".

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

If grad is an instance of graduation and grad is an agent of org and person is a patient of grad, then org is an instance of educational organization.

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

If mat is an instance of matriculation and mat is an agent of org and person is a patient of mat, then org is an instance of educational organization.

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

If hire is an instance of hiring and org is an instance of organization and hire is an agent of org and person is a patient of hire, then org employs person immediately after "the time of existence of hire".

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

If fire is an instance of terminating employment and org is an instance of organization and fire is an agent of org and person is a patient of fire, then org doesn't employ person immediately after "the time of existence of fire".

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

If proc is an instance of political process, then there exists government gov so that proc is an agent of gov or gov is a patient of proc.

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

If motion is an instance of body motion, then there exist body part obj,organism agent so that obj is a patient of motion and motion is an agent of agent.

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

If walk is an instance of walking and walk is an agent of agent, then there exists land area area so that agent is located at area.

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

If swim is an instance of swimming and swim is an agent of agent, then there exists water area area so that agent is located at area.

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

If transfer is an instance of transfer and transfer is an agent of agent and patient is a patient of transfer, then agent is not equal to patient.

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

If touch is an instance of touching and touch is an agent of obj1 and obj2 is a patient of touch, then obj1 is connected to obj2 immediately after "the time of existence of touch".

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

If give is an instance of giving and give is an agent of agent1 and give ends at agent2 and agent2 is an instance of agent and obj is a patient of give, then there exists getting get so that get is an agent of agent2 and get origins at agent1 and obj is a patient of 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 is an instance of giving and give is an agent of agent, then give origins at agent.

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

There exists borrowing borrow so that borrow is an agent of agent1 and borrow origins at agent2 and object is a patient of borrow if and only if there exists lending lend so that lend is an agent of agent2 and lend ends at agent1 and object is a patient of 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 is an instance of getting and get is an agent of agent, then get ends at agent.

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

If trans is an instance of transaction, then there exist agent1,agent2,giving give1,giving give2,obj1,obj2 so that give1 is a subprocess of trans and give2 is a subprocess of trans and give1 is an agent of agent1 and give2 is an agent of agent2 and obj1 is a patient of give1 and obj2 is a patient of give2 and give1 ends at agent2 and give2 ends at agent1 and agent1 is not equal to agent2 and obj1 is not equal to 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 is an instance of buying and buy is an agent of agent, then buy ends at agent.

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

There exists buying buy so that buy is an agent of agent1 and buy origins at agent2 and object is a patient of buy if and only if there exists selling sell so that sell is an agent of agent2 and sell ends at agent1 and object is a patient of 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 is an instance of selling and sell is an agent of agent, then sell origins at agent.

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

If learn is an instance of learning and learn is an agent of agent, then agent is an instance of cognitive agent.

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

If there exists learning learn so that learn is an agent of agent and prop is a patient of learn during time, then agent believes prop immediately after time.

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

If agent is an instance of cognitive agent, then agent is capable to do reasoning in role agent.

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

If meas is an instance of measuring and meas is an agent of agent and obj is a patient of meas, then there exist quant,unit so that agent knows "the measure of obj is "quant unit(s)"" immediately after "the time of existence of 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))))))

If count is an instance of counting and count is an agent of agent and entity is a patient of count, then there exists number so that agent knows ""the number of instances in entity" is equal to number".

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

If keep is an instance of keeping and keep is an agent of agent and obj is a patient of keep, then there exists putting put so that put is an agent of agent and obj is a patient of put and "the time of existence of put" happens earlier than "the time of existence of 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)))))

If kill is an instance of killing and kill is an agent of agent and patient is a patient of kill, then agent is an instance of organism and patient is an instance of organism.

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

If poke is an instance of poking and poke is an agent of agent and obj is a patient of poke and inst is an instrument for poke, then inst connects agent and obj the time of existence of poke.

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

If search is an instance of searching and search is an agent of agent and entity is a patient of search, then agent is interested in entity.

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

If pursue is an instance of pursuing and pursue is an agent of agent and obj is a patient of pursue, then agent wants obj during pursue.

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

If pursue is an instance of pursuing and pursue is an agent of agent and obj is a patient of pursue, then agent doesn't posess obj during pursue.

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

If investigate is an instance of investigating and investigate is an agent of agent and prop is a patient of investigate, then agent doesn't know prop the time of existence of investigate.

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

If proc is an instance of diagnostic process and proc is an agent of agent, then there exists cause so that proc has &n 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)))

If interaction is an instance of social interaction, then there exist agent1,agent2 so that interaction is an agent of agent1 and interaction is an agent of agent2 and agent1 is not equal to agent2.

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

If communicate is an instance of communication, then there exist content bearing object obj,cognitive agent agent1,cognitive agent agent2 so that obj is a patient of communicate and communicate is an agent of agent1 and communicate ends at 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 is an instance of stating and state is an agent of agent and formula is a patient of state and formula is an instance of formula, then agent believes formula the time of existence of state.

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

If request is an instance of requesting and request is an agent of agent and formula is a patient of request and formula is an instance of formula, then agent desires formula.

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

If question is an instance of questioning and question is an agent of agent and formula is a patient of question and formula is an instance of formula, then agent doesn't know formula the time of existence of question.

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

If express is an instance of expressing and express is an agent of agent, then there exists state of mind state so that state is an attribute of agent and express expresses state.

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

If declare is an instance of declaring and declare is an agent of agent1, then there exist proc,agent2 so that declare allows agent2 to perform task of the type proc or declare obligates agent2 to perform task of the type proc.

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

if cooperate is an instance of cooperation,
then there exists purp so that for all agent holds: if cooperate is an agent of agent, then cooperate has &n purpose purp for agent

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

If meet is an instance of meeting and meet is an agent of agent1 and meet is an agent of agent2, then agent1 is near to agent2 the time of existence of meet.

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

If meet is an instance of meeting, then there exist agent1,agent2 so that meet is an agent of agent1 and meet is an agent of agent2 and meet has purpose "there exists communication comm so that comm is an agent of agent1 and comm is an agent of agent2".

(=>
      (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 is an instance of contest, then there exist agent1,agent2,purp1,purp2 so that contest is an agent of agent1 and contest is an agent of agent2 and contest has &n purpose purp1 for agent1 and contest has &n purpose purp2 for agent2 and agent1 is not equal to agent2 and purp1 is not equal to 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)))))

if war is an instance of war and war is an agent of agent,
then
- agent is an instance of nation
- - agent is an instance of organization
  - for all member holds: if member is a member of agent, then member is an instance of nation

(=>
      (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 is an instance of perception and percept is an agent of agent, then agent is an instance of animal.

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

If percept is an instance of perception and percept is an agent of agent and object is a patient of percept, then agent notices object.

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

If see is an instance of seeing and see is an agent of agent and obj is a patient of see, then

illuminated is an attribute of obj
there exists color attribute prop so that agent knows "prop is an attribute of 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))))))

If emit is an instance of radiating sound and emit is an agent of sound, then there exists sound attribute attr so that attr is an attribute of sound.

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

If virus is an instance of virus and proc is an instance of replication and proc is an agent of virus, then there exists cell cell so that proc is located at cell.

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

If agent is the author of text, then there exist process,text instance so that process is an agent of agent and text is a result of process.

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

org publishes text if and only if there exists publication pub so that pub is an agent of org and text is a patient of pub.

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

If building is an instance of building, then there exists human human so that

human lives in building
there exists act so that act is an agent of human and act is 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)))))))

If pol is an instance of political organization, then there exists political process proc so that proc is an agent of pol.

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

If agent is obliged to perform tasks of type process, then the statement "there exists process instance so that instance is an agent of agent" has the model force of obligation.

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

If agent has the right to perform process, then the statement "there exists process instance so that instance is an agent of agent" has the model force of permission.

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

If attr is an attribute of obj and attr is an instance of contest attribute, then there exists contest contest so that contest is an agent of obj or obj is a patient of contest.

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

If organism is an instance of organism and process is an agent of organism, then living is an attribute of organism the time of existence of process.

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