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)

Classe

inheritable relation

RuoloSemantico

agent

Coordinate term(s)

destination direction experiencer origin path patient

Type restrictions

agent(Processo, Agente)

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)

Se lang é un' istanza di LinguaggioAnimale e proc é un agente di agent e lang é uno strumento per proc, allora agent é un' istanza di Animale e agent é not un' istanza di Umano.

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

Se lang é un' istanza di LinguaggioMacchina e proc é un agente di agent e lang é uno strumento per proc, allora agent é un' istanza di Macchinario.

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

Se lang é un' istanza di LinguaggioUmano e proc é un agente di agent e lang é uno strumento per proc, allora agent é un' istanza di Umano.

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

agent é un' istanza di Agente se e solo se esiste proc tale che proc é un agente di agent.

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

Se process é un' istanza di Processo, allora esiste cause tale che process é un agente di cause.

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

Se obj utilizzas agent, allora esiste process tale che process é un agente di agent e obj é una risorsa per process.

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

Se agent ha &n la capacitá di fare proc, allora agent é capace di fare proc nel ruolo agent.

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

Se agent ha il diritto di compiere process, allora agent é capace di fare process nel ruolo agent.

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

Se agent é obbligato a compiere il compito di tipo process, allora agent é capace di fare process nel ruolo agent.

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

Se agent usa obj, allora esiste proc tale che proc é un agente di agent e obj é uno strumento per proc.

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

Se digest é un' istanza di digesting e digest é un agente di organism, allora esiste Ingestione ingest tale che ingest é un agente di organism e "il tempo di esistenza di digest" sovrappones "il tempo di esistenza di ingest".

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

Se rep é un' istanza di Replicazione e rep é un agente di parent e child é un risultato di rep, allora parent é un parente di child.

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

Se proc é un' istanza di ProcessoIntenzionale e proc é un agente di agent, allora esiste purp tale che proc ha &n scopo purp per agent.

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

Se proc é un' istanza di ProcessoIntenzionale, allora esiste AgenteCognitivo agent tale che proc é un agente di agent.

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

Se act é un' istanza di ProcessoOrganizzativo e act é un agente di agent, allora

agent é un' istanza di Organizzazione
esiste Organizzazione org tale che agent é un membro di org

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

Se act é un' istanza di ProcessoReligioso e act é un agente di agent, allora

agent é un' istanza di OrganizzazioneReligiosa
esiste OrganizzazioneReligiosa org tale che agent é un membro di org

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

Se join é un' istanza di AdesioneAdUn'Organizzazione e org é un' istanza di Organizzazione e join é un agente di org e person é un paziente di join, allora "person é un membro di org" vales durante "immediatamente dopo "il tempo di esistenza di join"".

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

Se leave é un' istanza di AbbandonoDiUn'Organizzazione e org é un' istanza di Organizzazione e leave é un agente di org e person é un paziente di leave, allora "person é not un membro di org" vales durante "immediatamente dopo "il tempo di esistenza di leave"".

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

Se grad é un' istanza di ConseguimentoDiplomiAccademici e grad é un agente di org e person é un paziente di grad, allora org é un' istanza di OrganizzazioneEducativa.

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

Se mat é un' istanza di Iscrizione e mat é un agente di org e person é un paziente di mat, allora org é un' istanza di OrganizzazioneEducativa.

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

Se hire é un' istanza di Assunzione e org é un' istanza di Organizzazione e hire é un agente di org e person é un paziente di hire, allora "org impiegas person" vales durante "immediatamente dopo "il tempo di esistenza di hire"".

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

Se fire é un' istanza di CessazioneDiRapportoLavorativo e org é un' istanza di Organizzazione e fire é un agente di org e person é un paziente di fire, allora "org non impiega person" vales durante "immediatamente dopo "il tempo di esistenza di fire"".

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

Se proc é un' istanza di ProcessoPolitico, allora esiste Governo gov tale che proc é un agente di gov o gov é un paziente di proc.

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

Se motion é un' istanza di MovimentoCorporeo, allora esiste ParteDelCorpo obj,Organismo agent tale che obj é un paziente di motion e motion é un agente di agent.

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

Se walk é un' istanza di Camminare e walk é un agente di agent, allora esiste SuperficieTerrestre area tale che agent é localizzato in area.

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

Se swim é un' istanza di Nuotare e swim é un agente di agent, allora esiste SuperficieAcquatica area tale che agent é localizzato in area.

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

Se transfer é un' istanza di Trasferimento e transfer é un agente di agent e patient é un paziente di transfer, allora agent is not uguale a patient.

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

Se touch é un' istanza di Toccare e touch é un agente di obj1 e obj2 é un paziente di touch, allora "obj1 é connesso a obj2" vales durante "immediatamente dopo "il tempo di esistenza di touch"".

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

Se give é un' istanza di Dare e give é un agente di agent1 e give fines in agent2 e agent2 é un' istanza di Agente e obj é un paziente di give, allora esiste Ottenere get tale che get é un agente di agent2 e get si originas in agent1 e obj é un paziente di 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))))

Se give é un' istanza di Dare e give é un agente di agent, allora give si originas in agent.

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

Esiste PrendereInPrestito borrow tale che borrow é un agente di agent1 e borrow si originas in agent2 e object é un paziente di borrow se e solo se esiste DareInPrestito lend tale che lend é un agente di agent2 e lend fines in agent1 e object é un paziente di 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))))

Se get é un' istanza di Ottenere e get é un agente di agent, allora get fines in agent.

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

Se trans é un' istanza di Scambio, allora esiste agent1,agent2,Dare give1,Dare give2,obj1,obj2 tale che give1 é un sottoprocesso di trans e give2 é un sottoprocesso di trans e give1 é un agente di agent1 e give2 é un agente di agent2 e obj1 é un paziente di give1 e obj2 é un paziente di give2 e give1 fines in agent2 e give2 fines in agent1 e agent1 is not uguale a agent2 e obj1 is not uguale a 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)))))

Se buy é un' istanza di Acquistare e buy é un agente di agent, allora buy fines in agent.

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

Esiste Acquistare buy tale che buy é un agente di agent1 e buy si originas in agent2 e object é un paziente di buy se e solo se esiste Vendere sell tale che sell é un agente di agent2 e sell fines in agent1 e object é un paziente di 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))))

Se sell é un' istanza di Vendere e sell é un agente di agent, allora sell si originas in agent.

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

Se learn é un' istanza di Apprendere e learn é un agente di agent, allora agent é un' istanza di AgenteCognitivo.

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

Se "esiste Apprendere learn tale che learn é un agente di agent e prop é un paziente di learn" vales durante time, allora "agent believes prop" vales durante "immediatamente dopo time".

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

Se agent é un' istanza di AgenteCognitivo, allora agent é capace di fare Ragionare nel ruolo agent.

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

Se meas é un' istanza di Misurare e meas é un agente di agent e obj é un paziente di meas, allora esiste quant,unit tale che "agent conosces "lamisura obj é "quant unit(s""" vales durante "immediatamente dopo "il tempo di esistenza di 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))))))

Se count é un' istanza di Contare e count é un agente di agent e entity é un paziente di count, allora esiste number tale che agent conosces ""il numero di istanzia in entity" is uguale a number".

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

Se keep é un' istanza di Trattenere e keep é un agente di agent e obj é un paziente di keep, allora esiste Porre put tale che put é un agente di agent e obj é un paziente di put e "il tempo di esistenza di put" accades prima di "il tempo di esistenza di 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)))))

Se kill é un' istanza di Uccidere e kill é un agente di agent e patient é un paziente di kill, allora agent é un' istanza di Organismo e patient é un' istanza di Organismo.

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

Se poke é un' istanza di Perforare e poke é un agente di agent e obj é un paziente di poke e inst é uno strumento per poke, allora "inst connette agent e obj" vales durante "il tempo di esistenza di poke".

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

Se search é un' istanza di Ricercare e search é un agente di agent e entity é un paziente di search, allora agent é interessato a entity.

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

Se pursue é un' istanza di Cercare e pursue é un agente di agent e obj é un paziente di pursue, allora "agent vuoles obj" vales durante pursue.

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

Se pursue é un' istanza di Cercare e pursue é un agente di agent e obj é un paziente di pursue, allora "agent non possiede obj" vales durante pursue.

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

Se investigate é un' istanza di Investigare e investigate é un agente di agent e prop é un paziente di investigate, allora "agent non conosce prop" vales durante "il tempo di esistenza di investigate".

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

Se proc é un' istanza di ProcessoDiagnostico e proc é un agente di agent, allora esiste cause tale che proc ha &n scopo "agent conosces "cause causas proc"" per agent.

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

Se interaction é un' istanza di InterazioneSociale, allora esiste agent1,agent2 tale che interaction é un agente di agent1 e interaction é un agente di agent2 e agent1 is not uguale a agent2.

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

Se communicate é un' istanza di Comunicazione, allora esiste OggettoSemiotico obj,AgenteCognitivo agent1,AgenteCognitivo agent2 tale che obj é un paziente di communicate e communicate é un agente di agent1 e communicate fines in 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))))

Se state é un' istanza di Affermare e state é un agente di agent e formula é un paziente di state e formula é un' istanza di Formula, allora "agent believes formula" vales durante "il tempo di esistenza di state".

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

Se request é un' istanza di Richiedere e request é un agente di agent e formula é un paziente di request e formula é un' istanza di Formula, allora agent desideras formula.

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

Se question é un' istanza di Domandare e question é un agente di agent e formula é un paziente di question e formula é un' istanza di Formula, allora "agent non conosce formula" vales durante "il tempo di esistenza di question".

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

Se express é un' istanza di Esprimere e express é un agente di agent, allora esiste StatoMentale state tale che state is an attribute of agent e express esprime state.

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

Se declare é un' istanza di Dichiarare e declare é un agente di agent1, allora esiste proc,agent2 tale che declare permette a agent2 di compiere il compito di tipo proc o declare obbliga agent2 a compiere il compito di tipo proc.

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

se cooperate é un' istanza di Cooperazione,
allora esiste purp tale che per ogni agent vale: se cooperate é un agente di agent, allora cooperate ha &n scopo purp per agent

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

Se meet é un' istanza di Incontro e meet é un agente di agent1 e meet é un agente di agent2, allora "agent1 é near a agent2" vales durante "il tempo di esistenza di meet".

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

Se meet é un' istanza di Incontro, allora esiste agent1,agent2 tale che meet é un agente di agent1 e meet é un agente di agent2 e meet ha scopo "esiste Comunicazione comm tale che comm é un agente di agent1 e comm é un agente di 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)))))))

Se contest é un' istanza di Competizione, allora esiste agent1,agent2,purp1,purp2 tale che contest é un agente di agent1 e contest é un agente di agent2 e contest ha &n scopo purp1 per agent1 e contest ha &n scopo purp2 per agent2 e agent1 is not uguale a agent2 e purp1 is not uguale a 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)))))

se war é un' istanza di Guerra e war é un agente di agent,
allora
- agent é un' istanza di Nazione
- - agent é un' istanza di Organizzazione
  - per ogni member vale: se member é un membro di agent, allora member é un' istanza di Nazione

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

Se percept é un' istanza di Percezione e percept é un agente di agent, allora agent é un' istanza di Animale.

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

Se percept é un' istanza di Percezione e percept é un agente di agent e object é un paziente di percept, allora agent notas object.

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

Se see é un' istanza di Vista e see é un agente di agent e obj é un paziente di see, allora

illuminated is an attribute of obj
esiste AttributoDiColore prop tale che agent conosces "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))))))

Se emit é un' istanza di OndaSonora e emit é un agente di sound, allora esiste AttributoSonoro attr tale che attr is an attribute of sound.

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

Se virus é un' istanza di Virus e proc é un' istanza di Replicazione e proc é un agente di virus, allora esiste Cellula cell tale che proc é localizzato in cell.

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

Se agent é l' autore di text, allora esiste process,text instance tale che process é un agente di agent e text é un risultato di process.

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

org pubblica text se e solo se esiste Editoria pub tale che pub é un agente di org e text é un paziente di pub.

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

Se building é un' istanza di Costruzione, allora esiste Umano human tale che

human abitas in building
esiste act tale che act é un agente di human e act é localizzato in building

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

Se pol é un' istanza di OrganizzazionePolitica, allora esiste ProcessoPolitico proc tale che proc é un agente di pol.

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

Se agent é obbligato a compiere il compito di tipo process, allora l'affermazione "esiste process instance tale che instance é un agente di agent" ha il modello di forza di obligation.

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

Se agent ha il diritto di compiere process, allora l'affermazione "esiste process instance tale che instance é un agente di agent" ha il modello di forza di permission.

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

Se attr is an attribute of obj e attr é un' istanza di AttributoDiCompetizione, allora esiste Competizione contest tale che contest é un agente di obj o obj é un paziente di contest.

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

Se organism é un' istanza di Organismo e process é un agente di organism, allora "living is an attribute of organism" vales durante "il tempo di esistenza di process".

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