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)

Kategorie

inheritable relation

Fallrolle

agent

Coordinate term(s)

bestimmungsort richtung experiencer origin pfad patient

Type restrictions

agent(Prozess, 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)

Wenn lang ist ein fall von Tiersprache und proc ist der agent von agent und lang ist ein instrument für proc , dann agent ist ein fall von Tier und agent ist ein fall von Mensch nicht.

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

Wenn lang ist ein fall von Computersprache und proc ist der agent von agent und lang ist ein instrument für proc , dann agent ist ein fall von Maschine .

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

Wenn lang ist ein fall von menschliche Sprache und proc ist der agent von agent und lang ist ein instrument für proc , dann agent ist ein fall von Mensch .

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

agent ist ein fall von Agent nur wenn es gibt ein proc der proc ist der agent von agent .

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

Wenn process ist ein fall von Prozess , dann es gibt ein cause der process ist der agent von cause .

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

Wenn obj nutzt agent aus, dann es gibt ein process der process ist der agent von agent und obj ist ein hilfmittel für process .

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

Wenn agent hat die Fähigkeit, zum proc zu tun , dann agent ist fähig , in der Rolle agent proc zu tun.

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

Wenn agent hat das Recht, process durchzuführen , dann agent ist fähig , in der Rolle agent process zu tun.

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

Wenn agent wird gezwungen, die Aufgabe der Art von process durchzuführen , dann agent ist fähig , in der Rolle agent process zu tun.

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

Wenn agent verwendet obj, dann es gibt ein proc der proc ist der agent von agent und obj ist ein instrument für proc .

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

Wenn digest ist ein fall von digesting und digest ist der agent von organism , dann es gibt ein Einnehmen ingest der ingest ist der agent von organism und "die zeit des Bestehens von digest" deckt sich mit "die zeit des Bestehens von ingest" .

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

Wenn rep ist ein fall von Reproduktion und rep ist der agent von parent und child ist ein resultat von rep , dann parent ist das elterntiel von child .

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

Wenn proc ist ein fall von absichlicher Prozess und proc ist der agent von agent , dann es gibt ein purp der proc hat Zweck von purp für agent .

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

Wenn proc ist ein fall von absichlicher Prozess , dann es gibt ein kognitiver Agent agent der proc ist der agent von agent .

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

Wenn act ist ein fall von organisatorisher Prozess und act ist der agent von agent , dann

agent ist ein fall von Organisation
es gibt ein Organisation org der agent ist ein Mitglied von org

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

Wenn act ist ein fall von religiöser Prozess und act ist der agent von agent , dann

agent ist ein fall von religiöse Organisation
es gibt ein religiöse Organisation org der agent ist ein Mitglied von org

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

Wenn join ist ein fall von gehen zu einer Organisation und org ist ein fall von Organisation und join ist der agent von org und person ist ein patient von join , dann "person ist ein Mitglied von org " hält während "sofort nach "die zeit des Bestehens von join"" .

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

Wenn leave ist ein fall von verlassen eine Organisation und org ist ein fall von Organisation und leave ist der agent von org und person ist ein patient von leave , dann "person ist ein Mitglied von org nicht" hält während "sofort nach "die zeit des Bestehens von leave"" .

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

Wenn grad ist ein fall von Abschluss und grad ist der agent von org und person ist ein patient von grad , dann org ist ein fall von pädagogishe Organisation .

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

Wenn mat ist ein fall von Immatrikulation und mat ist der agent von org und person ist ein patient von mat , dann org ist ein fall von pädagogishe Organisation .

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

Wenn hire ist ein fall von Einstellen und org ist ein fall von Organisation und hire ist der agent von org und person ist ein patient von hire , dann "org beschäftigt person " hält während "sofort nach "die zeit des Bestehens von hire"" .

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

Wenn fire ist ein fall von Beenden Beschäftigung und org ist ein fall von Organisation und fire ist der agent von org und person ist ein patient von fire , dann "org beschäftigt person nicht" hält während "sofort nach "die zeit des Bestehens von fire"" .

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

Wenn proc ist ein fall von politischer Prozess , dann es gibt ein Regierung gov der proc ist der agent von gov oder gov ist ein patient von proc .

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

Wenn motion ist ein fall von Körperbewegung , dann es gibt ein Körperteil obj,Organismus agent der obj ist ein patient von motion und motion ist der agent von agent .

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

Wenn walk ist ein fall von gehen zu Fuss und walk ist der agent von agent , dann es gibt ein Landgebiet area der agent befindet sich an .

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

Wenn swim ist ein fall von Schwimmen und swim ist der agent von agent , dann es gibt ein Wassergebiet area der agent befindet sich an .

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

Wenn transfer ist ein fall von Übertragung und transfer ist der agent von agent und patient ist ein patient von transfer , dann agent ist gleich patient nicht.

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

Wenn touch ist ein fall von Berühren und touch ist der agent von obj1 und obj2 ist ein patient von touch , dann "obj1 wird an obj2 angeschlossen" hält während "sofort nach "die zeit des Bestehens von touch"" .

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

Wenn give ist ein fall von Geben und give ist der agent von agent1 und give endet an agent2 und agent2 ist ein fall von Agent und obj ist ein patient von give , dann es gibt ein Erhalten get der get ist der agent von agent2 und get beginnet an agent1 und obj ist ein patient von 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))))

Wenn give ist ein fall von Geben und give ist der agent von agent , dann give beginnet an agent .

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

Es gibt ein Borgen borrow der borrow ist der agent von agent1 und borrow beginnet an agent2 und object ist ein patient von borrow nur wenn es gibt ein Verleihen lend der lend ist der agent von agent2 und lend endet an agent1 und object ist ein patient von 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))))

Wenn get ist ein fall von Erhalten und get ist der agent von agent , dann get endet an agent .

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

Wenn trans ist ein fall von Transaktion , dann es gibt ein agent1,agent2,Geben give1,Geben give2,obj1,obj2 der give1 ist ein subProzess von trans und give2 ist ein subProzess von trans und give1 ist der agent von agent1 und give2 ist der agent von agent2 und obj1 ist ein patient von give1 und obj2 ist ein patient von give2 und give1 endet an agent2 und give2 endet an agent1 und agent1 ist gleich agent2 nicht und obj1 ist gleich obj2 nicht.

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

Wenn buy ist ein fall von Kaufen und buy ist der agent von agent , dann buy endet an agent .

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

Es gibt ein Kaufen buy der buy ist der agent von agent1 und buy beginnet an agent2 und object ist ein patient von buy nur wenn es gibt ein Verkaufen sell der sell ist der agent von agent2 und sell endet an agent1 und object ist ein patient von 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))))

Wenn sell ist ein fall von Verkaufen und sell ist der agent von agent , dann sell beginnet an agent .

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

Wenn learn ist ein fall von Lernen und learn ist der agent von agent , dann agent ist ein fall von kognitiver Agent .

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

Wenn "es gibt ein Lernen learn der learn ist der agent von agent und prop ist ein patient von learn " hält während time , dann "agent glaubt , dass prop" hält während "sofort nach time" .

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

Wenn agent ist ein fall von kognitiver Agent , dann agent ist fähig , in der Rolle agent logisches Denken zu tun.

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

Wenn meas ist ein fall von Messen und meas ist der agent von agent und obj ist ein patient von meas , dann es gibt ein quant,unit der "agent kennt "das mass von obj ist "quant unit(s)" " " hält während "sofort nach "die zeit des Bestehens von 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))))))

Wenn count ist ein fall von Zählen und count ist der agent von agent und entity ist ein patient von count , dann es gibt ein number der agent kennt ""die Zahl Fällen in entity" ist gleich number " .

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

Wenn keep ist ein fall von Halten und keep ist der agent von agent und obj ist ein patient von keep , dann es gibt ein Setzen put der put ist der agent von agent und obj ist ein patient von put und "die zeit des Bestehens von put" geschieht früh als "die zeit des Bestehens von 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)))))

Wenn kill ist ein fall von Tötung und kill ist der agent von agent und patient ist ein patient von kill , dann agent ist ein fall von Organismus und patient ist ein fall von Organismus .

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

Wenn poke ist ein fall von Stossen und poke ist der agent von agent und obj ist ein patient von poke und inst ist ein instrument für poke , dann "inst schleisst agent und obj an" hält während "die zeit des Bestehens von poke" .

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

Wenn search ist ein fall von Suchen und search ist der agent von agent und entity ist ein patient von search , dann agent ist an entity interessiert .

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

Wenn pursue ist ein fall von Verfolgen und pursue ist der agent von agent und obj ist ein patient von pursue , dann "agent wünscht obj " hält während pursue .

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

Wenn pursue ist ein fall von Verfolgen und pursue ist der agent von agent und obj ist ein patient von pursue , dann "agent besitzt obj nicht" hält während pursue .

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

Wenn investigate ist ein fall von Untersuchen und investigate ist der agent von agent und prop ist ein patient von investigate , dann "agent kennt prop nicht" hält während "die zeit des Bestehens von investigate" .

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

Wenn proc ist ein fall von Diagnoseprozess und proc ist der agent von agent , dann es gibt ein cause der proc hat Zweck von "agent kennt "cause verursacht proc " " für agent .

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

Wenn interaction ist ein fall von Sozialunterhaltung , dann es gibt ein agent1,agent2 der interaction ist der agent von agent1 und interaction ist der agent von agent2 und agent1 ist gleich agent2 nicht.

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

Wenn communicate ist ein fall von Kommunikation , dann es gibt ein Inhaltsgegenstand obj,kognitiver Agent agent1,kognitiver Agent agent2 der obj ist ein patient von communicate und communicate ist der agent von agent1 und communicate endet an 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))))

Wenn state ist ein fall von Darlegen und state ist der agent von agent und formula ist ein patient von state und formula ist ein fall von Formel , dann "agent glaubt , dass formula" hält während "die zeit des Bestehens von state" .

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

Wenn request ist ein fall von Ersuchen und request ist der agent von agent und formula ist ein patient von request und formula ist ein fall von Formel , dann agent wünscht formula .

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

Wenn question ist ein fall von Ausfragen und question ist der agent von agent und formula ist ein patient von question und formula ist ein fall von Formel , dann "agent kennt formula nicht" hält während "die zeit des Bestehens von question" .

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

Wenn express ist ein fall von Ausdrücken und express ist der agent von agent , dann es gibt ein Geisteszustand state der state ist ein attribut von agent und express drückt state aus.

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

Wenn declare ist ein fall von Erklären und declare ist der agent von agent1 , dann es gibt ein proc,agent2 der declare erlaubt agent2, die Aufgabe der Art von proc durchzuführen oder declare zwingt agent2, die Aufgabe der Art von proc durchzuführen .

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

wenn cooperate ist ein fall von Mitarbeit ,
dann es gibt ein purp der für jeden agent gilt: wenn cooperate ist der agent von agent , dann cooperate hat Zweck von purp für agent

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

Wenn meet ist ein fall von Sitzung und meet ist der agent von agent1 und meet ist der agent von agent2 , dann "agent1 ist near hinsichlich agent2 " hält während "die zeit des Bestehens von meet" .

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

Wenn meet ist ein fall von Sitzung , dann es gibt ein agent1,agent2 der meet ist der agent von agent1 und meet ist der agent von agent2 und meet hat Zweck von "es gibt ein Kommunikation comm der comm ist der agent von agent1 und comm ist der agent von 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)))))))

Wenn contest ist ein fall von Kampf , dann es gibt ein agent1,agent2,purp1,purp2 der contest ist der agent von agent1 und contest ist der agent von agent2 und contest hat Zweck von purp1 für agent1 und contest hat Zweck von purp2 für agent2 und agent1 ist gleich agent2 nicht und purp1 ist gleich purp2 nicht.

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

wenn war ist ein fall von Krieg und war ist der agent von agent ,
dann
- agent ist ein fall von Nation
- - agent ist ein fall von Organisation
  - für jeden member gilt: wenn member ist ein Mitglied von agent , dann member ist ein fall von Nation

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

Wenn percept ist ein fall von Wahrnehmung und percept ist der agent von agent , dann agent ist ein fall von Tier .

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

Wenn percept ist ein fall von Wahrnehmung und percept ist der agent von agent und object ist ein patient von percept , dann agent beachtet object .

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

Wenn see ist ein fall von Sehen und see ist der agent von agent und obj ist ein patient von see , dann

illuminated ist ein attribut von obj
es gibt ein Farbeattribut prop der agent kennt "prop ist ein attribut von 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))))))

Wenn emit ist ein fall von ausstrahlender Ton und emit ist der agent von sound , dann es gibt ein Tonsattribut attr der attr ist ein attribut von sound .

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

Wenn virus ist ein fall von Virus und proc ist ein fall von Reproduktion und proc ist der agent von virus , dann es gibt ein Zelle cell der proc befindet sich an .

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

Wenn agent ist der schreiber von text, dann es gibt ein process,text instance der process ist der agent von agent und text ist ein resultat von process .

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

org veröffentlicht text nur wenn es gibt ein Publikation pub der pub ist der agent von org und text ist ein patient von pub .

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

Wenn building ist ein fall von Gebäude , dann es gibt ein Mensch human der

human wohnt in building
es gibt ein act der act ist der agent von human und act befindet sich an

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

Wenn pol ist ein fall von politische Organisation , dann es gibt ein politischer Prozess proc der proc ist der agent von pol .

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

Wenn agent wird gezwungen, die Aufgabe der Art von process durchzuführen , dann die Aussage "es gibt ein process instance der instance ist der agent von agent " hat die modale Kraft von obligation.

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

Wenn agent hat das Recht, process durchzuführen , dann die Aussage "es gibt ein process instance der instance ist der agent von agent " hat die modale Kraft von permission.

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

Wenn attr ist ein attribut von obj und attr ist ein fall von Wettbewerbsattribut , dann es gibt ein Kampf contest der contest ist der agent von obj oder obj ist ein patient von contest .

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

Wenn organism ist ein fall von Organismus und process ist der agent von organism , dann "living ist ein attribut von organism " hält während "die zeit des Bestehens von process" .

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