exists (exists)
The existential quantifier of predicate logic.
Ontology
SUMO / STRUCTURAL-ONTOLOGYClass(es)
Coordinate term(s)
<=>
=>
and
hatZurFolge
forall
not
or
Type restrictions
exists(Liste, Formel)
Related WordNet synsets
- being, beingness, existence
- the state or fact of existing: "a point of view gradually coming into being"; "laws in existence for centuries"
- reality, realness, realism
- the state of being actual or real: "the reality of his situation slowly dawned on him"
- actuality
- the state of actually existing objectively: "a hope that progressed from possibility to actuality"
- subsistence
- the state of existing in reality; having substance
- exist, be
- have an existence, be extant; "Is there a God?"
See more related synsets on a separate page.
Axioms (290)
Wenn entity ist ein direkter fall von class, dann es gibt kein class subclass der entity ist ein fall von subclass .
(=>
(immediateInstance ?ENTITY ?CLASS)
(not
(exists
(?SUBCLASS)
(and
(subclass ?SUBCLASS ?CLASS)
(instance ?ENTITY ?SUBCLASS)))))
Wenn class1 ist eine direkte teilkategorie von class2, dann es gibt kein class2 class3 der class1 ist eine teilkategorie von class3 und class2 ist gleich class3 nicht und class1 ist gleich class3 nicht.
(=>
(immediateSubclass ?CLASS1 ?CLASS2)
(not
(exists
(?CLASS3)
(and
(subclass ?CLASS3 ?CLASS2)
(subclass ?CLASS1 ?CLASS3)
(not
(equal ?CLASS2 ?CLASS3))
(not
(equal ?CLASS1 ?CLASS3))))))
- wenn exhaustive attribute(class,) gilt,
- dann für jeden obj gilt: wenn attr1 ist ein fall von class , dann es gibt ein attr2 der attr2 ist ein Mitglied von "()" und attr1 ist gleich attr2
.
(=>
(exhaustiveAttribute ?CLASS @ROW)
(forall
(?OBJ)
(=>
(instance ?ATTR1 ?CLASS)
(exists
(?ATTR2)
(and
(inList
?ATTR2
(ListFn @ROW))
(equal ?ATTR1 ?ATTR2))))))
Wenn attr1 ist ein direkter nachfolgerattribut von attr2 und "entity hat ein attribut attr2 " hält während time1 , dann es gibt ein time2 der time2 ist ein teil von "vor time1" und "entity hat ein attribut attr1 " hält während time2 .
(=>
(and
(successorAttribute ?ATTR1 ?ATTR2)
(holdsDuring
?TIME1
(property ?ENTITY ?ATTR2)))
(exists
(?TIME2)
(and
(temporalPart
?TIME2
(PastFn ?TIME1))
(holdsDuring
?TIME2
(property ?ENTITY ?ATTR1)))))
Es gibt ein thing der thing ist ein fall von Wesen .
(exists
(?THING)
(instance ?THING Entity))
phys ist ein fall von körperlicher Gegenstand nur wenn es gibt ein loc,time der phys befindet sich an und phys besteht während time .
(<=>
(instance ?PHYS Physical)
(exists
(?LOC ?TIME)
(and
(located ?PHYS ?LOC)
(time ?PHYS ?TIME))))
Wenn atom ist ein fall von Atom , dann es gibt ein Proton proton,Elektron electron der proton ist ein bestandteil von atom und electron ist ein bestandteil von atom .
(=>
(instance ?ATOM Atom)
(exists
(?PROTON ?ELECTRON)
(and
(component ?PROTON ?ATOM)
(component ?ELECTRON ?ATOM)
(instance ?PROTON Proton)
(instance ?ELECTRON Electron))))
Wenn particle ist ein fall von subatomarer Partikel , dann es gibt ein Atom atom der particle ist ein teil von atom .
(=>
(instance ?PARTICLE SubatomicParticle)
(exists
(?ATOM)
(and
(instance ?ATOM Atom)
(part ?PARTICLE ?ATOM))))
Wenn nucleus ist ein fall von Atomkern , dann es gibt ein Neutron neutron,Proton proton der neutron ist ein bestandteil von nucleus und proton ist ein bestandteil von nucleus .
(=>
(instance ?NUCLEUS AtomicNucleus)
(exists
(?NEUTRON ?PROTON)
(and
(component ?NEUTRON ?NUCLEUS)
(component ?PROTON ?NUCLEUS)
(instance ?NEUTRON Neutron)
(instance ?PROTON Proton))))
Wenn mixture ist ein fall von Mischung , dann es gibt ein reine Substanz pure1,reine Substanz pure2 der pure1 ist gleich pure2 nicht und pure1 ist ein stück von mixture und pure2 ist ein stück von mixture .
(=>
(instance ?MIXTURE Mixture)
(exists
(?PURE1 ?PURE2)
(and
(subclass ?PURE1 PureSubstance)
(subclass ?PURE2 PureSubstance)
(not
(equal ?PURE1 ?PURE2))
(piece ?PURE1 ?MIXTURE)
(piece ?PURE2 ?MIXTURE))))
Wenn obj ist ein fall von korpuskularer Gegenstand , dann es gibt ein Substanz substance1,Substanz substance2 der substance1 ist von obj gebildet und substance2 ist von obj gebildet und substance1 ist gleich substance2 nicht.
(=>
(instance ?OBJ CorpuscularObject)
(exists
(?SUBSTANCE1 ?SUBSTANCE2)
(and
(subclass ?SUBSTANCE1 Substance)
(subclass ?SUBSTANCE2 Substance)
(material ?SUBSTANCE1 ?OBJ)
(material ?SUBSTANCE2 ?OBJ)
(not
(equal ?SUBSTANCE1 ?SUBSTANCE2)))))
Wenn region ist ein fall von Gebiet , dann es gibt ein phys der phys befindet sich an .
(=>
(instance ?REGION Region)
(exists
(?PHYS)
(located ?PHYS ?REGION)))
Wenn coll ist ein fall von Ansammlung , dann es gibt ein obj der obj ist ein Mitglied von coll .
(=>
(instance ?COLL Collection)
(exists
(?OBJ)
(member ?OBJ ?COLL)))
Wenn string ist ein fall von Zeichenfolge , dann es gibt ein Zeichen part der part ist ein teil von string .
(=>
(instance ?STRING SymbolicString)
(exists
(?PART)
(and
(part ?PART ?STRING)
(instance ?PART Character))))
Wenn lang ist ein fall von gebaute Sprache , dann es gibt ein Planen plan der lang ist ein resultat von plan .
(=>
(instance ?LANG ConstructedLanguage)
(exists
(?PLAN)
(and
(instance ?PLAN Planning)
(result ?PLAN ?LANG))))
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 Doppelgegenstandprozess , dann es gibt ein obj1,obj2 der obj1 ist ein patient von process und obj2 ist ein patient von process und obj1 ist gleich obj2 nicht.
(=>
(instance ?PROCESS DualObjectProcess)
(exists
(?OBJ1 ?OBJ2)
(and
(patient ?PROCESS ?OBJ1)
(patient ?PROCESS ?OBJ2)
(not
(equal ?OBJ1 ?OBJ2)))))
abs ist ein fall von abstrakter Gegenstand nur wenn es gibt kein point der abs befindet sich an oder abs besteht während point .
(<=>
(instance ?ABS Abstract)
(not
(exists
(?POINT)
(or
(located ?ABS ?POINT)
(time ?ABS ?POINT)))))
Wenn number ist ein fall von imaginäre Zahl , dann es gibt ein reelle Zahl real der number ist gleich "real*"die quadratwurzel von "" .
(=>
(instance ?NUMBER ImaginaryNumber)
(exists
(?REAL)
(and
(instance ?REAL RealNumber)
(equal
?NUMBER
(MultiplicationFn
?REAL
(SquareRootFn -1))))))
Wenn number ist ein fall von Komplexzahl , dann es gibt ein reelle Zahl real1,reelle Zahl real2 der number ist gleich "(real1+"real2*"die quadratwurzel von "")" .
(=>
(instance ?NUMBER ComplexNumber)
(exists
(?REAL1 ?REAL2)
(and
(instance ?REAL1 RealNumber)
(instance ?REAL2 RealNumber)
(equal
?NUMBER
(AdditionFn
?REAL1
(MultiplicationFn
?REAL2
(SquareRootFn -1)))))))
rel ist ein fall von totalwertige Relation nur wenn es gibt ein valence der rel ist ein fall von Relation und rel hat valence argument(e) und - wenn für jeden number,element,class gilt: wenn number ist kleinerAls valence und die Zahl number Argument von rel ist ein fall von class und element ist gleich "numberte mitglied von "()"" , dann element ist ein fall von class ,
- dann es gibt ein item der rel(,item) gilt
.
(<=>
(instance ?REL TotalValuedRelation)
(exists
(?VALENCE)
(and
(instance ?REL Relation)
(valence ?REL ?VALENCE)
(=>
(forall
(?NUMBER ?ELEMENT ?CLASS)
(=>
(and
(lessThan ?NUMBER ?VALENCE)
(domain ?REL ?NUMBER ?CLASS)
(equal
?ELEMENT
(ListOrderFn
(ListFn @ROW)
?NUMBER)))
(instance ?ELEMENT ?CLASS)))
(exists
(?ITEM)
(holds ?REL @ROW ?ITEM))))))
Wenn rel ist ein fall von zweiwertige Relation , dann es gibt kein item1,item2,item3, der rel(item1,item2,item3,) gilt .
(=>
(instance ?REL BinaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 @ROW))))
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 agent wünscht obj , dann es gibt ein purp der obj hat Zweck von purp für agent .
(=>
(wants ?AGENT ?OBJ)
(exists
(?PURP)
(hasPurposeForAgent ?OBJ ?PURP ?AGENT)))
Wenn agent glaubt , dass formula, dann es gibt ein time der "agent betrachtet formula " hält während time .
(=>
(believes ?AGENT ?FORMULA)
(exists
(?TIME)
(holdsDuring
?TIME
(considers ?AGENT ?FORMULA))))
Wenn rel ist ein fall von dreiwertige Relation , dann es gibt kein item1,item2,item3,item4, der rel(item1,item2,item3,item4,) gilt .
(=>
(instance ?REL TernaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))
Wenn rel ist ein fall von viewwertige Relation , dann es gibt kein item1,item2,item3,item4,item5, der rel(item1,item2,item3,item4,item5,) gilt .
(=>
(instance ?REL QuaternaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW))))
Wenn rel ist ein fall von fünfwertige Relation , dann es gibt kein item1,item2,item3,item4,item5,item6, der rel(item1,item2,item3,item4,item5,item6,) gilt .
(=>
(instance ?REL QuintaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW))))
- wenn list ist ein fall von Liste ,
- dann es gibt ein number1 der es gibt ein item1 der "number1te mitglied von list" ist gleich item1 nicht und für jeden number2 gilt: wenn number2 ist ein fall von positive Ganzzahl und number2 ist kleinerAls number1 , dann es gibt ein item2 der "number2te mitglied von list" ist gleich item2
.
(=>
(instance ?LIST List)
(exists
(?NUMBER1)
(exists
(?ITEM1)
(and
(not
(equal
(ListOrderFn ?LIST ?NUMBER1)
?ITEM1))
(forall
(?NUMBER2)
(=>
(and
(instance ?NUMBER2 PositiveInteger)
(lessThan ?NUMBER2 ?NUMBER1))
(exists
(?ITEM2)
(equal
(ListOrderFn ?LIST ?NUMBER2)
?ITEM2))))))))
list ist gleich null list nur wenn es gibt kein item der item ist ein Mitglied von list.
(<=>
(equal ?LIST NullList)
(not
(exists
(?ITEM)
(inList ?ITEM ?LIST))))
- wenn class wird mit behandelt,
- dann für jeden obj gilt: wenn obj ist ein fall von class , dann es gibt ein item der item ist ein Mitglied von "()" und obj ist ein fall von item
.
(=>
(exhaustiveDecomposition ?CLASS @ROW)
(forall
(?OBJ)
(=>
(instance ?OBJ ?CLASS)
(exists
(?ITEM)
(and
(inList
?ITEM
(ListFn @ROW))
(instance ?OBJ ?ITEM))))))
Wenn "Länge von list" ist gleich number1 , dann für jeden number2 gilt: es gibt ein item der "number2te mitglied von list" ist gleich item nur wenn number2 ist kleinerAlsOderGleich number1 .
(=>
(equal
(ListLengthFn ?LIST)
?NUMBER1)
(forall
(?NUMBER2)
(<=>
(exists
(?ITEM)
(equal
(ListOrderFn ?LIST ?NUMBER2)
?ITEM))
(lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))
Wenn "Länge von list1" ist gleich number , dann es gibt ein list2 der list1 beginnt list2 und "(number+1)" ist gleich "Länge von list2" und ""(number+1)"te mitglied von list2" ist gleich item .
(=>
(equal
(ListLengthFn ?LIST1)
?NUMBER)
(exists
(?LIST2)
(and
(initialList ?LIST1 ?LIST2)
(equal
(SuccessorFn ?NUMBER)
(ListLengthFn ?LIST2))
(equal
(ListOrderFn
?LIST2
(SuccessorFn ?NUMBER))
?ITEM))))
item ist ein Mitglied von list nur wenn es gibt ein number der "numberte mitglied von list" ist gleich item .
(<=>
(inList ?ITEM ?LIST)
(exists
(?NUMBER)
(equal
(ListOrderFn ?LIST ?NUMBER)
?ITEM)))
- wenn list1 ist eine teilliste von list2 ,
- dann es gibt ein number3 der für jeden item gilt: wenn item ist ein Mitglied von list1, dann es gibt ein number1,number2 der "number1te mitglied von list1" ist gleich item und "number2te mitglied von list2" ist gleich item und number2 ist gleich "(number1+number3)"
.
(=>
(subList ?LIST1 ?LIST2)
(exists
(?NUMBER3)
(forall
(?ITEM)
(=>
(inList ?ITEM ?LIST1)
(exists
(?NUMBER1 ?NUMBER2)
(and
(equal
(ListOrderFn ?LIST1 ?NUMBER1)
?ITEM)
(equal
(ListOrderFn ?LIST2 ?NUMBER2)
?ITEM)
(equal
?NUMBER2
(AdditionFn ?NUMBER1 ?NUMBER3))))))))
Wenn rel ist ein fall von Relation mit veränderlicher Anzahl Argumente , dann es gibt kein int der rel hat int argument(e).
(=>
(instance ?REL VariableArityRelation)
(not
(exists
(?INT)
(valence ?REL ?INT))))
Wenn proc1 ist ein fall von Prozess , dann es gibt ein proc2 der proc2 verursacht proc1 .
(=>
(instance ?PROC1 Process)
(exists
(?PROC2)
(causes ?PROC2 ?PROC1)))
- wenn causes subclass(proc1,proc2) gilt,
- dann für jeden inst2 gilt: wenn inst2 ist ein fall von proc2 , dann es gibt ein proc1 inst1 der inst1 verursacht inst2
.
(=>
(causesSubclass ?PROC1 ?PROC2)
(forall
(?INST2)
(=>
(instance ?INST2 ?PROC2)
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(causes ?INST1 ?INST2))))))
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 thing hat Zweck von purpose , dann es gibt ein agent der thing hat Zweck von purpose für agent .
(=>
(hasPurpose ?THING ?PURPOSE)
(exists
(?AGENT)
(hasPurposeForAgent ?THING ?PURPOSE ?AGENT)))
Wenn obj befindet sich teils an , dann es gibt ein subobj der subobj ist ein teil von obj und subobj liegtGenau in region .
(=>
(partlyLocated ?OBJ ?REGION)
(exists
(?SUBOBJ)
(and
(part ?SUBOBJ ?OBJ)
(exactlyLocated ?SUBOBJ ?REGION))))
Wenn obj liegtGenau in region , dann es gibt kein otherobj der otherobj liegtGenau in region und otherobj ist gleich obj nicht.
(=>
(exactlyLocated ?OBJ ?REGION)
(not
(exists
(?OTHEROBJ)
(and
(exactlyLocated ?OTHEROBJ ?REGION)
(not
(equal ?OTHEROBJ ?OBJ))))))
- wenn person besitzt obj ,
- dann es gibt ein type der type hat das Recht, person durchzuführen und für jeden process gilt: wenn process ist ein fall von type , dann obj ist ein patient von process
.
(=>
(possesses ?PERSON ?OBJ)
(exists
(?TYPE)
(and
(holdsRight ?PERSON ?TYPE)
(forall
(?PROCESS)
(=>
(instance ?PROCESS ?TYPE)
(patient ?PROCESS ?OBJ))))))
- wenn proc1 ist eine vorbedingung von proc2,
- dann wenn es gibt ein inst2 der inst2 ist ein fall von proc2 , dann es gibt ein inst1 der inst1 ist ein fall von proc1
.
(=>
(precondition ?PROC1 ?PROC2)
(=>
(exists
(?INST2)
(instance ?INST2 ?PROC2))
(exists
(?INST1)
(instance ?INST1 ?PROC1))))
Wenn proc1 hemmt proc2, dann für jeden time,place gilt: ""es gibt ein proc1 inst1 der inst1 befindet sich an " hält während time " verringert die Wahrscheinlichkeit von ""es gibt ein proc2 inst2 der inst2 befindet sich an " hält während time " .
(=>
(inhibits ?PROC1 ?PROC2)
(forall
(?TIME ?PLACE)
(decreasesLikelihood
(holdsDuring
?TIME
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(located ?INST1 ?PLACE))))
(holdsDuring
?TIME
(exists
(?INST2)
(and
(instance ?INST2 ?PROC2)
(located ?INST2 ?PLACE)))))))
- wenn proc1 verhindert das Auftreten von proc2,
- dann für jeden time,place gilt: wenn "es gibt ein proc1 inst1 der inst1 befindet sich an " hält während time , dann "es gibt ein proc2 inst2 der inst2 befindet sich an " hält während time nicht
.
(=>
(prevents ?PROC1 ?PROC2)
(forall
(?TIME ?PLACE)
(=>
(holdsDuring
?TIME
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(located ?INST1 ?PLACE))))
(not
(holdsDuring
?TIME
(exists
(?INST2)
(and
(instance ?INST2 ?PROC2)
(located ?INST2 ?PLACE))))))))
Wenn rep ist in Sprache entity ausgedrückt, dann es gibt ein agent der agent verwendet rep, um für entity zu stehen.
(=>
(representsInLanguage ?REP ?ENTITY ?LANGUAGE)
(exists
(?AGENT)
(representsForAgent ?REP ?ENTITY ?AGENT)))
class1 fasst das Inhalt von class2 zusammen nur wenn für jeden obj2,info gilt: wenn obj2 ist ein fall von class2 und obj2 enthält Informationen über info, dann es gibt ein class1 obj1 der obj1 enthält Informationen über info.
(<=>
(subsumesContentClass ?CLASS1 ?CLASS2)
(forall
(?OBJ2 ?INFO)
(=>
(and
(instance ?OBJ2 ?CLASS2)
(containsInformation ?OBJ2 ?INFO))
(exists
(?OBJ1)
(and
(instance ?OBJ1 ?CLASS1)
(containsInformation ?OBJ1 ?INFO))))))
Wenn process drükt den Inhalt von prop aus, dann es gibt ein Inhaltsgegenstand obj der obj enthält Informationen über prop.
(=>
(realization ?PROCESS ?PROP)
(exists
(?OBJ)
(and
(instance ?OBJ ContentBearingObject)
(containsInformation ?OBJ ?PROP))))
express ist in Sprache language ausgedrückt nur wenn es gibt ein prop der express ist in Sprache prop ausgedrückt.
(<=>
(expressedInLanguage ?EXPRESS ?LANGUAGE)
(exists
(?PROP)
(representsInLanguage ?EXPRESS ?PROP ?LANGUAGE)))
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 number ist ein fall von rationale Zahl , dann es gibt ein Ganzzahl int1,Ganzzahl int2 der number ist gleich "int1/int2" .
(=>
(instance ?NUMBER RationalNumber)
(exists
(?INT1 ?INT2)
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer)
(equal
?NUMBER
(DivisionFn ?INT1 ?INT2)))))
Wenn "die oberstegrenze von number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist grösserAlsOderGleich number und otherint ist kleinerAls int .
(=>
(equal
(CeilingFn ?NUMBER)
?INT)
(not
(exists
(?OTHERINT)
(and
(instance ?OTHERINT Integer)
(greaterThanOrEqualTo ?OTHERINT ?NUMBER)
(lessThan ?OTHERINT ?INT)))))
Wenn "die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist kleinerAlsOderGleich number und otherint ist grösserAls int .
(=>
(equal
(FloorFn ?NUMBER)
?INT)
(not
(exists
(?OTHERINT)
(and
(instance ?OTHERINT Integer)
(lessThanOrEqualTo ?OTHERINT ?NUMBER)
(greaterThan ?OTHERINT ?INT)))))
- wenn "die größte gemeinsamer teiler von " ist gleich number ,
- dann es gibt kein greater der greater ist grösserAls number und für jeden element gilt: wenn element ist ein Mitglied von "()", dann "element betrag greater" ist gleich
.
(=>
(equal
(GreatestCommonDivisorFn @ROW)
?NUMBER)
(not
(exists
(?GREATER)
(and
(greaterThan ?GREATER ?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?ELEMENT ?GREATER)
0)))))))
Wenn number ist ein fall von Komplexzahl , dann es gibt ein part1,part2 der part1 ist gleich "das reelle teil von number" und part2 ist gleich "das imaginäre teil von number" .
(=>
(instance ?NUMBER ComplexNumber)
(exists
(?PART1 ?PART2)
(and
(equal
?PART1
(RealNumberFn ?NUMBER))
(equal
?PART2
(ImaginaryPartFn ?NUMBER)))))
- wenn "das kleinste gemeinsames vielfach von " ist gleich number ,
- dann es gibt kein less der less ist kleinerAls number und für jeden element gilt: wenn element ist ein Mitglied von "()", dann "less betrag element" ist gleich
.
(=>
(equal
(LeastCommonMultipleFn @ROW)
?NUMBER)
(not
(exists
(?LESS)
(and
(lessThan ?LESS ?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?LESS ?ELEMENT)
0)))))))
Es gibt kein element der element ist ein element von null set .
(not
(exists
(?ELEMENT)
(element ?ELEMENT NullSet)))
Wenn set ist ein fall von begrenzte Menge , dann es gibt ein nichtnegative Ganzzahl number der number ist gleich "die Zahl Fällen in set" .
(=>
(instance ?SET FiniteSet)
(exists
(?NUMBER)
(and
(instance ?NUMBER NonnegativeInteger)
(equal
?NUMBER
(CardinalityFn ?SET)))))
(=>
(instance ?CLASS MutuallyDisjointClass)
(forall
(?INST1 ?INST2)
(=>
(and
(instance ?INST1 ?CLASS)
(instance ?INST2 ?INST1))
(exists
(?INST3)
(and
(instance ?INST3 ?CLASS)
(not
(instance ?INST2 ?INST3)))))))
Wenn graph ist ein fall von Graph und node1 ist ein fall von Graphknoten und node2 ist ein fall von Graphknoten und node1 ist ein teil von graph und node2 ist ein teil von graph und node1 ist gleich node2 nicht, dann es gibt ein arc,path der - arc verbindet node1 und node2
oder - path ist ein teilgraph von graph
und - path ist ein fall von Graphweg
und - "der anfang von path" ist gleich node1 und "das ende von path" ist gleich node2
oder - "der anfang von path" ist gleich node2 und "das ende von path" ist gleich node1
(=>
(and
(instance ?GRAPH Graph)
(instance ?NODE1 GraphNode)
(instance ?NODE2 GraphNode)
(graphPart ?NODE1 ?GRAPH)
(graphPart ?NODE2 ?GRAPH)
(not
(equal ?NODE1 ?NODE2)))
(exists
(?ARC ?PATH)
(or
(links ?NODE1 ?NODE2 ?ARC)
(and
(subGraph ?PATH ?GRAPH)
(instance ?PATH GraphPath)
(or
(and
(equal
(BeginNodeFn ?PATH)
?NODE1)
(equal
(EndNodeFn ?PATH)
?NODE2))
(and
(equal
(BeginNodeFn ?PATH)
?NODE2)
(equal
(EndNodeFn ?PATH)
?NODE1)))))))
Wenn graph ist ein fall von Graph , dann es gibt ein node1,node2,node3,arc1,arc2 der node1 ist ein teil von graph und node2 ist ein teil von graph und node3 ist ein teil von graph und arc1 ist ein teil von graph und arc2 ist ein teil von graph und node2 verbindet arc1 und node1 und node3 verbindet arc2 und node2 und node1 ist gleich node2 nicht und node2 ist gleich node3 nicht und node1 ist gleich node3 nicht und arc1 ist gleich arc2 nicht.
(=>
(instance ?GRAPH Graph)
(exists
(?NODE1 ?NODE2 ?NODE3 ?ARC1 ?ARC2)
(and
(graphPart ?NODE1 ?GRAPH)
(graphPart ?NODE2 ?GRAPH)
(graphPart ?NODE3 ?GRAPH)
(graphPart ?ARC1 ?GRAPH)
(graphPart ?ARC2 ?GRAPH)
(links ?ARC1 ?NODE1 ?NODE2)
(links ?ARC2 ?NODE2 ?NODE3)
(not
(equal ?NODE1 ?NODE2))
(not
(equal ?NODE2 ?NODE3))
(not
(equal ?NODE1 ?NODE3))
(not
(equal ?ARC1 ?ARC2)))))
Wenn graph ist ein fall von gerichtetes Graph und arc ist ein fall von Graphbogen und arc ist ein teil von graph , dann es gibt ein node1,node2 der "das ausgangsnullpunkt von arc" ist gleich node1 und "das terminalnullpunkt von arc" ist gleich node2 .
(=>
(and
(instance ?GRAPH DirectedGraph)
(instance ?ARC GraphArc)
(graphPart ?ARC ?GRAPH))
(exists
(?NODE1 ?NODE2)
(and
(equal
(InitialNodeFn ?ARC)
?NODE1)
(equal
(TerminalNodeFn ?ARC)
?NODE2))))
Wenn graph ist ein fall von Baumstruktur , dann es gibt kein Graphschleife loop der loop ist ein teil von graph .
(=>
(instance ?GRAPH Tree)
(not
(exists
(?LOOP)
(and
(instance ?LOOP GraphLoop)
(graphPart ?LOOP ?GRAPH)))))
(=>
(and
(instance ?GRAPH GraphPath)
(instance ?ARC GraphArc)
(graphPart ?ARC ?GRAPH))
(=>
(equal
(InitialNodeFn ?ARC)
?NODE)
(not
(exists
(?OTHER)
(and
(equal
(InitialNodeFn ?OTHER)
?NODE)
(not
(equal ?OTHER ?ARC)))))))
(=>
(and
(instance ?GRAPH GraphPath)
(instance ?ARC GraphArc)
(graphPart ?ARC ?GRAPH))
(=>
(equal
(TerminalNodeFn ?ARC)
?NODE)
(not
(exists
(?OTHER)
(and
(equal
(TerminalNodeFn ?OTHER)
?NODE)
(not
(equal ?OTHER ?ARC)))))))
graph ist ein fall von Graphschaltkreis nur wenn es gibt ein node der "der anfang von graph" ist gleich node und "das ende von graph" ist gleich node .
(<=>
(instance ?GRAPH GraphCircuit)
(exists
(?NODE)
(and
(equal
(BeginNodeFn ?GRAPH)
?NODE)
(equal
(EndNodeFn ?GRAPH)
?NODE))))
graph ist ein fall von Multigraph nur wenn es gibt ein arc1,arc2,node1,node2 der arc1 ist ein teil von graph und arc2 ist ein teil von graph und node1 ist ein teil von graph und node2 ist ein teil von graph und arc1 verbindet node1 und node2 und arc2 verbindet node1 und node2 und arc1 ist gleich arc2 nicht.
(<=>
(instance ?GRAPH MultiGraph)
(exists
(?ARC1 ?ARC2 ?NODE1 ?NODE2)
(and
(graphPart ?ARC1 ?GRAPH)
(graphPart ?ARC2 ?GRAPH)
(graphPart ?NODE1 ?GRAPH)
(graphPart ?NODE2 ?GRAPH)
(links ?NODE1 ?NODE2 ?ARC1)
(links ?NODE1 ?NODE2 ?ARC2)
(not
(equal ?ARC1 ?ARC2)))))
graph ist ein fall von Pseudograph nur wenn es gibt ein Graphschleife loop der loop ist ein teil von graph .
(<=>
(instance ?GRAPH PseudoGraph)
(exists
(?LOOP)
(and
(instance ?LOOP GraphLoop)
(graphPart ?LOOP ?GRAPH))))
Wenn part ist ein fall von Graphelement , dann es gibt ein Graph graph der part ist ein teil von graph .
(=>
(instance ?PART GraphElement)
(exists
(?GRAPH)
(and
(instance ?GRAPH Graph)
(graphPart ?PART ?GRAPH))))
Wenn node ist ein fall von Graphknoten , dann es gibt ein other,arc der arc verbindet node und other .
(=>
(instance ?NODE GraphNode)
(exists
(?OTHER ?ARC)
(links ?NODE ?OTHER ?ARC)))
Wenn arc ist ein fall von Graphbogen , dann es gibt ein node1,node2 der arc verbindet node1 und node2 .
(=>
(instance ?ARC GraphArc)
(exists
(?NODE1 ?NODE2)
(links ?NODE1 ?NODE2 ?ARC)))
loop ist ein fall von Graphschleife nur wenn es gibt ein node der loop verbindet node und node .
(<=>
(instance ?LOOP GraphLoop)
(exists
(?NODE)
(links ?NODE ?NODE ?LOOP)))
- wenn "die menge von minimalen Pfaden die graph in zwei verschiedene Graphen schnitten" ist gleich pathclass ,
- dann es gibt ein number der für jeden path gilt: wenn path ist ein fall von pathclass , dann die länge von path ist number
.
(=>
(equal
(MinimalCutSetFn ?GRAPH)
?PATHCLASS)
(exists
(?NUMBER)
(forall
(?PATH)
(=>
(instance ?PATH ?PATHCLASS)
(pathLength ?PATH ?NUMBER)))))
Es gibt kein die menge von Pfaden die graph in zwei verschiedene Graphen schnitten path1,die menge von minimalen Pfaden die graph in zwei verschiedene Graphen schnitten path2 der die länge von path1 ist number1 und die länge von path2 ist number2 und number1 ist kleinerAls number2 .
(not
(exists
(?PATH1 ?PATH2)
(and
(instance
?PATH1
(CutSetFn ?GRAPH))
(instance
?PATH2
(MinimalCutSetFn ?GRAPH))
(pathLength ?PATH1 ?NUMBER1)
(pathLength ?PATH2 ?NUMBER2)
(lessThan ?NUMBER1 ?NUMBER2))))
Wenn das altitude von obj1 ist obj2 , dann es gibt ein top der die oberseite von obj1 ist top und der abstand zwischen top und obj2 ist height.
(=>
(altitude ?OBJ1 ?OBJ2 ?HEIGHT)
(exists
(?TOP)
(and
(top ?TOP ?OBJ1)
(distance ?TOP ?OBJ2 ?HEIGHT))))
Wenn depth(obj1,obj2,depth) gilt, dann es gibt ein bottom der die unterseite von obj1 ist bottom und der abstand zwischen bottom und obj2 ist depth.
(=>
(depth ?OBJ1 ?OBJ2 ?DEPTH)
(exists
(?BOTTOM)
(and
(bottom ?BOTTOM ?OBJ1)
(distance ?BOTTOM ?OBJ2 ?DEPTH))))
Wenn point ist ein fall von Zeitpunkt und point ist gleich positive infinity nicht, dann es gibt ein otherpoint der otherpoint ist zwischen point und positive infinity.
(=>
(and
(instance ?POINT TimePoint)
(not
(equal ?POINT PositiveInfinity)))
(exists
(?OTHERPOINT)
(temporallyBetween ?POINT ?OTHERPOINT PositiveInfinity)))
Wenn point ist ein fall von Zeitpunkt und point ist gleich negative infinity nicht, dann es gibt ein otherpoint der otherpoint ist zwischen negative infinity und point.
(=>
(and
(instance ?POINT TimePoint)
(not
(equal ?POINT NegativeInfinity)))
(exists
(?OTHERPOINT)
(temporallyBetween NegativeInfinity ?OTHERPOINT ?POINT)))
- wenn proc gescheit alle time1,
- dann für jeden time2 gilt: wenn dauer von time2 ist time1 , dann es gibt ein position der position ist ein teil von time2 und "es gibt ein inst der inst ist ein fall von proc " hält während position
.
(=>
(frequency ?PROC ?TIME1)
(forall
(?TIME2)
(=>
(duration ?TIME2 ?TIME1)
(exists
(?POSITION)
(and
(temporalPart ?POSITION ?TIME2)
(holdsDuring
?POSITION
(exists
(?INST)
(instance ?INST ?PROC))))))))
Wenn point ist ein fall von Zeitpunkt , dann es gibt ein Zeitabstand interval der point ist ein teil von interval .
(=>
(instance ?POINT TimePoint)
(exists
(?INTERVAL)
(and
(instance ?INTERVAL TimeInterval)
(temporalPart ?POINT ?INTERVAL))))
Wenn interval ist ein fall von Zeitabstand , dann es gibt ein Zeitpunkt point der point ist ein teil von interval .
(=>
(instance ?INTERVAL TimeInterval)
(exists
(?POINT)
(and
(instance ?POINT TimePoint)
(temporalPart ?POINT ?INTERVAL))))
- wenn obj ist ein fall von Gegenstand ,
- dann es gibt ein Zeitpunkt time1,Zeitpunkt time2 der time1 geschieht vor time2 und für jeden time gilt: wenn time1 geschieht vor oder gleichzeitig mit time und time geschieht vor oder gleichzeitig mit time2 , dann obj besteht während time
.
(=>
(instance ?OBJ Object)
(exists
(?TIME1 ?TIME2)
(and
(instance ?TIME1 TimePoint)
(instance ?TIME2 TimePoint)
(before ?TIME1 ?TIME2)
(forall
(?TIME)
(=>
(and
(beforeOrEqual ?TIME1 ?TIME)
(beforeOrEqual ?TIME ?TIME2))
(time ?OBJ ?TIME))))))
interval2 deckt sich mit interval1 nur wenn es gibt ein Zeitabstand interval3 der interval3 ist ein teil von interval1 und interval3 ist ein teil von interval2 .
(<=>
(overlapsTemporally ?INTERVAL1 ?INTERVAL2)
(exists
(?INTERVAL3)
(and
(instance ?INTERVAL3 TimeInterval)
(temporalPart ?INTERVAL3 ?INTERVAL1)
(temporalPart ?INTERVAL3 ?INTERVAL2))))
Wenn interval ist ein fall von "der rückläufige zeitabstand von timeclass1 nach timeclass2" , dann es gibt ein timeclass1 time1,timeclass2 time2 der time1 beginnt interval und time2 beendet interval .
(=>
(instance
?INTERVAL
(RecurrentTimeIntervalFn ?TIMECLASS1 ?TIMECLASS2))
(exists
(?TIME1 ?TIME2)
(and
(instance ?TIME1 ?TIMECLASS1)
(instance ?TIME2 ?TIMECLASS2)
(starts ?TIME1 ?INTERVAL)
(finishes ?TIME2 ?INTERVAL))))
- wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
- dann für jeden time1,time2 gilt: wenn time1 ist ein fall von interval-type und time2 ist ein fall von class , dann es gibt ein duration der dauer von time1 ist duration und dauer von time2 ist duration
.
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(forall
(?TIME1 ?TIME2)
(=>
(and
(instance ?TIME1 ?INTERVAL-TYPE)
(instance ?TIME2 ?CLASS))
(exists
(?DURATION)
(and
(duration ?TIME1 ?DURATION)
(duration ?TIME2 ?DURATION))))))
Wenn "Aufspaltung von interval auf ? interval-types" ist gleich class , dann es gibt ein class time der time beginnt interval .
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(exists
(?TIME)
(and
(instance ?TIME ?CLASS)
(starts ?TIME ?INTERVAL))))
Wenn "Aufspaltung von interval auf ? interval-types" ist gleich class , dann es gibt ein class time der time beendet interval .
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(exists
(?TIME)
(and
(instance ?TIME ?CLASS)
(finishes ?TIME ?INTERVAL))))
- wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
- dann für jeden time1 gilt: wenn time1 ist ein fall von class und time1 beendet interval nicht, dann es gibt ein class time2 der time1 schliesst time2 zeitlich an
.
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(forall
(?TIME1)
(=>
(and
(instance ?TIME1 ?CLASS)
(not
(finishes ?TIME1 ?INTERVAL)))
(exists
(?TIME2)
(and
(instance ?TIME2 ?CLASS)
(meetsTemporally ?TIME1 ?TIME2))))))
- wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
- dann für jeden time1 gilt: wenn time1 ist ein fall von class und time1 beginnt interval nicht, dann es gibt ein class time2 der time2 schliesst time1 zeitlich an
.
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(forall
(?TIME1)
(=>
(and
(instance ?TIME1 ?CLASS)
(not
(starts ?TIME1 ?INTERVAL)))
(exists
(?TIME2)
(and
(instance ?TIME2 ?CLASS)
(meetsTemporally ?TIME2 ?TIME1))))))
- wenn "Aufspaltung von interval auf ? interval-types" ist gleich class ,
- dann für jeden time gilt: wenn time ist ein fall von Zeitpunkt und time ist ein teil von interval , dann es gibt ein class instance der time ist ein teil von instance
.
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(forall
(?TIME)
(=>
(and
(instance ?TIME TimePoint)
(temporalPart ?TIME ?INTERVAL))
(exists
(?INSTANCE)
(and
(instance ?INSTANCE ?CLASS)
(temporalPart ?TIME ?INSTANCE))))))
obj1 deckt sich mit obj2 räumlich nur wenn es gibt ein obj3 der obj3 ist ein teil von obj1 und obj3 ist ein teil von obj2 .
(<=>
(overlapsSpatially ?OBJ1 ?OBJ2)
(exists
(?OBJ3)
(and
(part ?OBJ3 ?OBJ1)
(part ?OBJ3 ?OBJ2))))
Wenn rel ist ein fall von Fallrolle und rel(process,obj) gilt , dann es gibt ein time der "die Stelle wo process an time war" deckt sich mit obj räumlich .
(=>
(and
(instance ?REL CaseRole)
(holds ?REL ?PROCESS ?OBJ))
(exists
(?TIME)
(overlapsSpatially
(WhereFn ?PROCESS ?TIME)
?OBJ)))
obj1 deckt sich mit obj2 teilweise nur wenn - obj1 ist ein teil von obj2 nicht
und - obj2 ist ein teil von obj1 nicht
und - es gibt ein obj3 der obj3 ist ein teil von obj1 und obj3 ist ein teil von obj2
.
(<=>
(overlapsPartially ?OBJ1 ?OBJ2)
(and
(not
(part ?OBJ1 ?OBJ2))
(not
(part ?OBJ2 ?OBJ1))
(exists
(?OBJ3)
(and
(part ?OBJ3 ?OBJ1)
(part ?OBJ3 ?OBJ2)))))
Wenn obj1 ist ein oberflächliches teil von obj2 , dann obj1 ist ein innenteil von obj2 nicht und es gibt kein obj3 der obj3 ist ein innenteil von obj1 .
(=>
(superficialPart ?OBJ1 ?OBJ2)
(and
(not
(interiorPart ?OBJ1 ?OBJ2))
(not
(exists
(?OBJ3)
(interiorPart ?OBJ3 ?OBJ1)))))
Wenn eine seite von object ist side und part ist ein teil von object und part wird an side nicht angeschlossen, dann es gibt ein direct der side ist direct hinsichlich part .
(=>
(and
(side ?SIDE ?OBJECT)
(part ?PART ?OBJECT)
(not
(connected ?PART ?SIDE)))
(exists
(?DIRECT)
(orientation ?SIDE ?PART ?DIRECT)))
Die breite von object ist width nur wenn es gibt ein side1,side2 der eine seite von object ist side1 und eine seite von object ist side2 und der abstand zwischen side1 und side2 ist width.
(<=>
(width ?OBJECT ?WIDTH)
(exists
(?SIDE1 ?SIDE2)
(and
(side ?SIDE1 ?OBJECT)
(side ?SIDE2 ?OBJECT)
(distance ?SIDE1 ?SIDE2 ?WIDTH))))
hole ist ein fall von Loch nur wenn es gibt ein obj der hole ist ein loch in obj .
(<=>
(instance ?HOLE Hole)
(exists
(?OBJ)
(hole ?HOLE ?OBJ)))
Wenn hole ist ein loch in obj1 und hole ist ein loch in obj2 , dann es gibt ein obj3 der obj3 ist ein korrektes teil von "der durchschnitt von den teilen von obj1 und obj2" und hole ist ein loch in obj3 .
(=>
(and
(hole ?HOLE ?OBJ1)
(hole ?HOLE ?OBJ2))
(exists
(?OBJ3)
(and
(properPart
?OBJ3
(MereologicalProductFn ?OBJ1 ?OBJ2))
(hole ?HOLE ?OBJ3))))
Wenn hole1 ist ein fall von Loch , dann es gibt ein hole2 der hole2 ist ein korrektes teil von hole1 .
(=>
(instance ?HOLE1 Hole)
(exists
(?HOLE2)
(properPart ?HOLE2 ?HOLE1)))
Wenn obj1 ist gleich "der wirt von dem Loch hole" , dann für jeden obj2 gilt: obj2 deckt sich mit obj1 räumlich nur wenn es gibt ein obj3 der hole ist ein loch in obj3 und obj2 deckt sich mit obj3 räumlich .
(=>
(equal
?OBJ1
(PrincipalHostFn ?HOLE))
(forall
(?OBJ2)
(<=>
(overlapsSpatially ?OBJ2 ?OBJ1)
(exists
(?OBJ3)
(and
(hole ?HOLE ?OBJ3)
(overlapsSpatially ?OBJ2 ?OBJ3))))))
Wenn hole1 ist ein fall von Loch und hole2 ist ein korrektes teil von hole1 , dann es gibt ein obj der hole1 schliesst obj räumlich an und hole2 schliesst obj räumlich nicht an.
(=>
(and
(instance ?HOLE1 Hole)
(properPart ?HOLE2 ?HOLE1))
(exists
(?OBJ)
(and
(meetsSpatially ?HOLE1 ?OBJ)
(not
(meetsSpatially ?HOLE2 ?OBJ)))))
Wenn es gibt ein time der "obj füllt hole " hält während time , dann fillable ist ein attribut von hole .
(=>
(exists
(?TIME)
(holdsDuring
?TIME
(fills ?OBJ ?HOLE)))
(attribute ?HOLE Fillable))
fillable ist ein attribut von hole1 nur wenn es gibt ein Loch hole2 der hole1 ist ein teil von hole2 .
(<=>
(attribute ?HOLE1 Fillable)
(exists
(?HOLE2)
(and
(instance ?HOLE2 Hole)
(part ?HOLE1 ?HOLE2))))
Wenn obj füllt hole1 teilweise, dann es gibt ein hole2 der hole2 ist ein teil von hole1 und obj füllt hole2 vollständig.
(=>
(partiallyFills ?OBJ ?HOLE1)
(exists
(?HOLE2)
(and
(part ?HOLE2 ?HOLE1)
(completelyFills ?OBJ ?HOLE2))))
Wenn obj füllt hole1 richtig, dann es gibt ein hole2 der hole2 ist ein teil von hole1 und obj füllt hole2 .
(=>
(properlyFills ?OBJ ?HOLE1)
(exists
(?HOLE2)
(and
(part ?HOLE2 ?HOLE1)
(fills ?OBJ ?HOLE2))))
Wenn obj1 füllt hole vollständig, dann es gibt ein obj2 der obj2 ist ein teil von obj1 und obj2 füllt hole .
(=>
(completelyFills ?OBJ1 ?HOLE)
(exists
(?OBJ2)
(and
(part ?OBJ2 ?OBJ1)
(fills ?OBJ2 ?HOLE))))
Wenn obj1 ist gleich "die oberfläche von dem Loch hole" , dann für jeden obj2 gilt: obj2 deckt sich mit obj1 räumlich nur wenn es gibt ein obj3 der obj3 ist ein oberflächliches teil von "der wirt von dem Loch hole" und hole schliesst obj3 räumlich an und obj2 deckt sich mit obj3 räumlich .
(=>
(equal
?OBJ1
(SkinFn ?HOLE))
(forall
(?OBJ2)
(<=>
(overlapsSpatially ?OBJ2 ?OBJ1)
(exists
(?OBJ3)
(and
(superficialPart
?OBJ3
(PrincipalHostFn ?HOLE))
(meetsSpatially ?HOLE ?OBJ3)
(overlapsSpatially ?OBJ2 ?OBJ3))))))
Wenn proc ist ein fall von Prozess und subproc ist ein subProzess von proc, dann es gibt ein time der subproc besteht während time .
(=>
(and
(instance ?PROC Process)
(subProcess ?SUBPROC ?PROC))
(exists
(?TIME)
(time ?SUBPROC ?TIME)))
Wenn proc ist ein fall von biologischer Prozess , dann es gibt ein Organismus obj der proc befindet sich an .
(=>
(instance ?PROC BiologicalProcess)
(exists
(?OBJ)
(and
(instance ?OBJ Organism)
(located ?PROC ?OBJ))))
Wenn birth ist ein fall von Geburt und agent erfährt birth , dann es gibt ein Tod death der agent erfährt death .
(=>
(and
(instance ?BIRTH Birth)
(experiencer ?BIRTH ?AGENT))
(exists
(?DEATH)
(and
(instance ?DEATH Death)
(experiencer ?DEATH ?AGENT))))
Wenn death ist ein fall von Tod und birth ist ein fall von Geburt und agent erfährt death und agent erfährt birth , dann es gibt ein time der "die zeit des Bestehens von birth" schliesst time zeitlich an und time schliesst "die zeit des Bestehens von death" zeitlich an und "living ist ein attribut von agent " hält während time .
(=>
(and
(instance ?DEATH Death)
(instance ?BIRTH Birth)
(experiencer ?DEATH ?AGENT)
(experiencer ?BIRTH ?AGENT))
(exists
(?TIME)
(and
(meetsTemporally
(WhenFn ?BIRTH)
?TIME)
(meetsTemporally
?TIME
(WhenFn ?DEATH))
(holdsDuring
?TIME
(attribute ?AGENT Living)))))
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 digest ist ein fall von digesting , dann es gibt ein chemische Aufspaltung decomp der decomp ist ein subProzess von digest.
(=>
(instance ?DIGEST Digesting)
(exists
(?DECOMP)
(and
(instance ?DECOMP ChemicalDecomposition)
(subProcess ?DECOMP ?DIGEST))))
Wenn rep ist ein fall von Reproduktion , dann es gibt ein reproduktive Körper body der body ist ein resultat von rep .
(=>
(instance ?REP Replication)
(exists
(?BODY)
(and
(instance ?BODY ReproductiveBody)
(result ?REP ?BODY))))
Wenn rep ist ein fall von sexuelle Wiedergabe und organism ist ein resultat von rep , dann es gibt kein mother,father der mother ist die mutter von organism und father ist der vater von organism .
(=>
(and
(instance ?REP SexualReproduction)
(result ?REP ?ORGANISM))
(not
(exists
(?MOTHER ?FATHER)
(and
(mother ?ORGANISM ?MOTHER)
(father ?ORGANISM ?FATHER)))))
Wenn rep ist ein fall von asexuelle Wiedergabe und organism ist ein resultat von rep , dann es gibt kein parent1,parent2 der parent1 ist das elterntiel von organism und parent2 ist das elterntiel von organism und parent1 ist gleich parent2 nicht.
(=>
(and
(instance ?REP AsexualReproduction)
(result ?REP ?ORGANISM))
(not
(exists
(?PARENT1 ?PARENT2)
(and
(parent ?ORGANISM ?PARENT1)
(parent ?ORGANISM ?PARENT2)
(not
(equal ?PARENT1 ?PARENT2))))))
Wenn process ist ein fall von psychologischer Prozess , dann es gibt ein Tier animal der animal erfährt process .
(=>
(instance ?PROCESS PsychologicalProcess)
(exists
(?ANIMAL)
(and
(instance ?ANIMAL Animal)
(experiencer ?PROCESS ?ANIMAL))))
Wenn proc ist ein fall von Organ oder Gewebeprozess , dann es gibt ein thing der proc befindet sich an und thing ist ein fall von Organ oder thing ist ein fall von Gewebe .
(=>
(instance ?PROC OrganOrTissueProcess)
(exists
(?THING)
(and
(located ?PROC ?THING)
(or
(instance ?THING Organ)
(instance ?THING Tissue)))))
Wenn path ist ein fall von pathologischer Prozess und org erfährt path , dann es gibt ein part,Krankheit oder Syndrom disease der part ist ein teil von org und disease ist ein attribut von part .
(=>
(and
(instance ?PATH PathologicProcess)
(experiencer ?PATH ?ORG))
(exists
(?PART ?DISEASE)
(and
(part ?PART ?ORG)
(instance ?DISEASE DiseaseOrSyndrome)
(attribute ?PART ?DISEASE))))
Wenn inj ist ein fall von Verletzen , dann es gibt ein anatomische Struktur struct der struct ist ein patient von inj .
(=>
(instance ?INJ Injuring)
(exists
(?STRUCT)
(and
(instance ?STRUCT AnatomicalStructure)
(patient ?INJ ?STRUCT))))
Wenn poison ist ein fall von Vergiftung , dann es gibt ein thing der thing ist ein patient von poison und thing ist ein fall von Organismus oder thing ist ein fall von anatomische Struktur .
(=>
(instance ?POISON Poisoning)
(exists
(?THING)
(and
(patient ?POISON ?THING)
(or
(instance ?THING Organism)
(instance ?THING AnatomicalStructure)))))
Wenn poison ist ein fall von Vergiftung , dann es gibt ein biologisch Wirkstoff substance der substance ist ein instrument für poison .
(=>
(instance ?POISON Poisoning)
(exists
(?SUBSTANCE)
(and
(instance ?SUBSTANCE BiologicallyActiveSubstance)
(instrument ?POISON ?SUBSTANCE))))
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
(=>
(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
(=>
(and
(instance ?ACT ReligiousProcess)
(agent ?ACT ?AGENT))
(or
(instance ?AGENT ReligiousOrganization)
(exists
(?ORG)
(and
(member ?AGENT ?ORG)
(instance ?ORG ReligiousOrganization)))))
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 increase ist ein fall von Zunehmen und obj ist ein patient von increase , dann es gibt ein unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von increase"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von increase"" und quant2 ist grösserAls quant1 .
(=>
(and
(instance ?INCREASE Increasing)
(patient ?INCREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))
Wenn heat ist ein fall von Erhitzen und obj ist ein patient von heat , dann es gibt ein Temperaturmass unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von heat"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von heat"" und quant2 ist grösserAls quant1 .
(=>
(and
(instance ?HEAT Heating)
(patient ?HEAT ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))
Wenn decrease ist ein fall von Abnehmen und obj ist ein patient von decrease , dann es gibt ein unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von decrease"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von decrease"" und quant2 ist kleinerAls quant1 .
(=>
(and
(instance ?DECREASE Decreasing)
(patient ?DECREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?DECREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DECREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(lessThan ?QUANT2 ?QUANT1))))
Wenn cool ist ein fall von Abkühlen und obj ist ein patient von cool , dann es gibt ein Temperaturmass unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von cool"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von cool"" und quant2 ist kleinerAls quant1 .
(=>
(and
(instance ?COOL Cooling)
(patient ?COOL ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COOL))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COOL))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(lessThan ?QUANT2 ?QUANT1))))
- wenn
- path1 ist der pfad entlang dem process geschieht
und - process beginnet an source
und - process endet an dest
und - die länge von path1 ist measure1
und - es gibt kein path2,measure2 der path2 ist der pfad entlang dem process geschieht und process beginnet an origin und process endet an dest und die länge von path2 ist measure2 und measure2 ist kleinerAls measure1
, - dann für jeden obj gilt: wenn obj ist ein teil von path1 , dann obj ist zwischen source und dest
.
(=>
(and
(path ?PROCESS ?PATH1)
(origin ?PROCESS ?SOURCE)
(destination ?PROCESS ?DEST)
(length ?PATH1 ?MEASURE1)
(not
(exists
(?PATH2 ?MEASURE2)
(and
(path ?PROCESS ?PATH2)
(origin ?PROCESS ?ORIGIN)
(destination ?PROCESS ?DEST)
(length ?PATH2 ?MEASURE2)
(lessThan ?MEASURE2 ?MEASURE1)))))
(forall
(?OBJ)
(=>
(part ?OBJ ?PATH1)
(between ?SOURCE ?OBJ ?DEST))))
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 proc ist ein fall von Umlenkung , dann es gibt ein Richtungsattribut attr der - "proc wird in der Weise von attr durchgeführt" hält während "direkt vor "die zeit des Bestehens von proc"" und "proc wird in der Weise von attr durchgeführt" hält während "sofort nach "die zeit des Bestehens von proc""
oder - "proc wird in der Weise von attr durchgeführt" hält während "sofort nach "die zeit des Bestehens von proc"" und "proc wird in der Weise von attr durchgeführt" hält während "direkt vor "die zeit des Bestehens von proc""
.
(=>
(instance ?PROC DirectionChange)
(exists
(?ATTR)
(and
(instance ?ATTR DirectionalAttribute)
(or
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(manner ?PROC ?ATTR))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(not
(manner ?PROC ?ATTR))))
(and
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(manner ?PROC ?ATTR))
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(not
(manner ?PROC ?ATTR))))))))
Wenn sub ist ein fall von Ersetzen , dann es gibt ein Setzen put,Entfernen remove,obj1,obj2,place der put ist ein subProzess von sub und remove ist ein subProzess von sub und obj1 ist ein patient von remove und remove beginnet an place und obj2 ist ein patient von put und put endet an place und obj1 ist gleich obj2 nicht.
(=>
(instance ?SUB Substituting)
(exists
(?PUT ?REMOVE ?OBJ1 ?OBJ2 ?PLACE)
(and
(instance ?PUT Putting)
(instance ?REMOVE Removing)
(subProcess ?PUT ?SUB)
(subProcess ?REMOVE ?SUB)
(patient ?REMOVE ?OBJ1)
(origin ?REMOVE ?PLACE)
(patient ?PUT ?OBJ2)
(destination ?PUT ?PLACE)
(not
(equal ?OBJ1 ?OBJ2)))))
Wenn impact ist ein fall von Auswirken und obj ist ein patient von impact , dann es gibt ein Nötigen impel der obj ist ein patient von impel und "die zeit des Bestehens von impel" geschieht früh als "die zeit des Bestehens von impact" .
(=>
(and
(instance ?IMPACT Impacting)
(patient ?IMPACT ?OBJ))
(exists
(?IMPEL)
(and
(instance ?IMPEL Impelling)
(patient ?IMPEL ?OBJ)
(earlier
(WhenFn ?IMPEL)
(WhenFn ?IMPACT)))))
Wenn trans ist ein fall von Transport , dann es gibt ein Transportvorrichtung device der device ist ein instrument für trans .
(=>
(instance ?TRANS Transportation)
(exists
(?DEVICE)
(and
(instance ?DEVICE TransportationDevice)
(instrument ?TRANS ?DEVICE))))
Wenn steer ist ein fall von Steürn , dann es gibt ein Transportvorrichtung vehicle der vehicle ist ein patient von steer .
(=>
(instance ?STEER Steering)
(exists
(?VEHICLE)
(and
(instance ?VEHICLE TransportationDevice)
(patient ?STEER ?VEHICLE))))
Wenn education ist ein fall von pädagogischer Prozess und person ist ein patient von education , dann education hat Zweck von "es gibt ein Lernen learn der person ist ein patient von learn " .
(=>
(and
(instance ?EDUCATION EducationalProcess)
(patient ?EDUCATION ?PERSON))
(hasPurpose
?EDUCATION
(exists
(?LEARN)
(and
(instance ?LEARN Learning)
(patient ?LEARN ?PERSON)))))
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 einseitiges Geben , dann es gibt kein Transaktion trans der give ist ein subProzess von trans.
(=>
(instance ?GIVE UnilateralGiving)
(not
(exists
(?TRANS)
(and
(instance ?TRANS Transaction)
(subProcess ?GIVE ?TRANS)))))
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 einseitiges Erhalten , dann es gibt kein Transaktion trans der get ist ein subProzess von trans.
(=>
(instance ?GET UnilateralGetting)
(not
(exists
(?TRANS)
(and
(instance ?TRANS Transaction)
(subProcess ?GET ?TRANS)))))
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 trans ist ein fall von Geldtransaktion , dann es gibt ein Währungma obj der obj ist ein patient von trans .
(=>
(instance ?TRANS FinancialTransaction)
(exists
(?OBJ)
(and
(patient ?TRANS ?OBJ)
(instance ?OBJ CurrencyMeasure))))
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 "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 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 predict ist ein fall von Voraussagen und formula ist ein patient von predict , dann es gibt ein time der formula hält während time und time geschieht vor "die zeit des Bestehens von predict" oder time geschieht früh als "die zeit des Bestehens von predict" .
(=>
(and
(instance ?PREDICT Predicting)
(patient ?PREDICT ?FORMULA))
(exists
(?TIME)
(and
(holdsDuring ?TIME ?FORMULA)
(or
(before
?TIME
(WhenFn ?PREDICT))
(earlier
?TIME
(WhenFn ?PREDICT))))))
Wenn remember ist ein fall von Erinnern und formula ist ein patient von remember , dann es gibt ein time der formula hält während time und time geschieht vor "die zeit des Bestehens von remember" oder time geschieht früh als "die zeit des Bestehens von remember" .
(=>
(and
(instance ?REMEMBER Remembering)
(patient ?REMEMBER ?FORMULA))
(exists
(?TIME)
(and
(holdsDuring ?TIME ?FORMULA)
(or
(before
?TIME
(WhenFn ?REMEMBER))
(earlier
?TIME
(WhenFn ?REMEMBER))))))
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 keep ist ein fall von Halten und obj ist ein patient von keep ,
- dann es gibt ein place der für jeden time gilt: wenn time ist ein teil von "die zeit des Bestehens von keep" , dann "obj befindet sich an " hält während time
.
(=>
(and
(instance ?KEEP Keeping)
(patient ?KEEP ?OBJ))
(exists
(?PLACE)
(forall
(?TIME)
(=>
(temporalPart
?TIME
(WhenFn ?KEEP))
(holdsDuring
?TIME
(located ?OBJ ?PLACE))))))
Wenn confine ist ein fall von Begrenzen , dann es gibt ein Mensch human der human ist ein patient von confine .
(=>
(instance ?CONFINE Confining)
(exists
(?HUMAN)
(and
(instance ?HUMAN Human)
(patient ?CONFINE ?HUMAN))))
Wenn repair ist ein fall von Reparatur und obj ist ein patient von repair , dann es gibt ein Beschädigen damage der obj ist ein patient von damage und "die zeit des Bestehens von damage" geschieht früh als "die zeit des Bestehens von repair" .
(=>
(and
(instance ?REPAIR Repairing)
(patient ?REPAIR ?OBJ))
(exists
(?DAMAGE)
(and
(instance ?DAMAGE Damaging)
(patient ?DAMAGE ?OBJ)
(earlier
(WhenFn ?DAMAGE)
(WhenFn ?REPAIR)))))
Wenn proc ist ein fall von therapeutischer Prozess und bio ist ein patient von proc , dann
(=>
(and
(instance ?PROC TherapeuticProcess)
(patient ?PROC ?BIO))
(or
(instance ?BIO Organism)
(exists
(?ORG)
(and
(instance ?ORG Organism)
(part ?BIO ?ORG)))))
Wenn act ist ein fall von Chirurgie und animal ist ein patient von act , dann es gibt ein Schneiden subact der animal ist ein fall von Tier und cutting ist ein patient von animal und subact ist ein subProzess von act.
(=>
(and
(instance ?ACT Surgery)
(patient ?ACT ?ANIMAL))
(exists
(?SUBACT)
(and
(instance ?SUBACT Cutting)
(instance ?ANIMAL Animal)
(patient ?ANIMAL ?CUTTING)
(subProcess ?SUBACT ?ACT))))
process ist ein fall von Zerstörung nur wenn es gibt ein patient der patient ist ein patient von process und patient besteht während "direkt vor "die zeit des Bestehens von process"" und patient besteht während "sofort nach "die zeit des Bestehens von process"" nicht.
(<=>
(instance ?PROCESS Destruction)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))))))
compound ist ein fall von Verbindung nur wenn es gibt ein elementare Substanz element1,elementare Substanz element2,chemische Synthese process der element1 ist gleich element2 nicht und element1 ist ein hilfmittel für process und element2 ist ein hilfmittel für process und compound ist ein resultat von process .
(<=>
(instance ?COMPOUND CompoundSubstance)
(exists
(?ELEMENT1 ?ELEMENT2 ?PROCESS)
(and
(instance ?ELEMENT1 ElementalSubstance)
(instance ?ELEMENT2 ElementalSubstance)
(not
(equal ?ELEMENT1 ?ELEMENT2))
(instance ?PROCESS ChemicalSynthesis)
(resource ?PROCESS ?ELEMENT1)
(resource ?PROCESS ?ELEMENT2)
(result ?PROCESS ?COMPOUND))))
Wenn combustion ist ein fall von Verbrennung , dann es gibt ein Erhitzen heat,ausstrahlendes Licht light der heat ist ein subProzess von combustion und light ist ein subProzess von combustion.
(=>
(instance ?COMBUSTION Combustion)
(exists
(?HEAT ?LIGHT)
(and
(instance ?HEAT Heating)
(instance ?LIGHT RadiatingLight)
(subProcess ?HEAT ?COMBUSTION)
(subProcess ?LIGHT ?COMBUSTION))))
Wenn change ist ein fall von innere Änderung und obj ist ein patient von change , dann es gibt ein property der
(=>
(and
(instance ?CHANGE InternalChange)
(patient ?CHANGE ?OBJ))
(exists
(?PROPERTY)
(or
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(attribute ?OBJ ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(not
(attribute ?OBJ ?PROPERTY))))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(not
(attribute ?OBJ ?PROPERTY)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(attribute ?OBJ ?PROPERTY))))))
Wenn alt ist ein fall von Oberflächenänderung und obj ist ein patient von alt , dann es gibt ein part,property der part ist ein oberflächliches teil von obj und "property ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von alt"" und "property ist ein attribut von part nicht" hält während "sofort nach "die zeit des Bestehens von alt"" .
(=>
(and
(instance ?ALT SurfaceChange)
(patient ?ALT ?OBJ))
(exists
(?PART ?PROPERTY)
(and
(superficialPart ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?ALT))
(attribute ?PART ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ALT))
(not
(attribute ?PART ?PROPERTY))))))
Wenn alt ist ein fall von Formänderung und obj ist ein patient von alt , dann es gibt ein Formattribut property der
(=>
(and
(instance ?ALT ShapeChange)
(patient ?ALT ?OBJ))
(exists
(?PROPERTY)
(and
(instance ?PROPERTY ShapeAttribute)
(or
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ALT))
(attribute ?OBJ ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ALT))
(not
(attribute ?OBJ ?PROPERTY))))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ALT))
(not
(attribute ?OBJ ?PROPERTY)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ALT))
(attribute ?OBJ ?PROPERTY)))))))
Wenn coloring ist ein fall von Farbe und obj ist ein patient von coloring , dann es gibt ein Farbeattribut property der "property ist ein attribut von obj " hält während "direkt vor "die zeit des Bestehens von coloring"" und "property ist ein attribut von obj nicht" hält während "sofort nach "die zeit des Bestehens von coloring"" .
(=>
(and
(instance ?COLORING Coloring)
(patient ?COLORING ?OBJ))
(exists
(?PROPERTY)
(and
(instance ?PROPERTY ColorAttribute)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COLORING))
(attribute ?OBJ ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COLORING))
(not
(attribute ?OBJ ?PROPERTY))))))
Wenn develop ist ein fall von Inhaltsentwicklung , dann es gibt ein Inhaltsgegenstand obj der obj ist ein patient von develop .
(=>
(instance ?DEVELOP ContentDevelopment)
(exists
(?OBJ)
(and
(instance ?OBJ ContentBearingObject)
(patient ?DEVELOP ?OBJ))))
Wenn read ist ein fall von Lesen , dann es gibt ein Text text,prop der text enthält Informationen über prop und read drükt den Inhalt von prop aus.
(=>
(instance ?READ Reading)
(exists
(?TEXT ?PROP)
(and
(instance ?TEXT Text)
(containsInformation ?TEXT ?PROP)
(realization ?READ ?PROP))))
Wenn decode ist ein fall von Decodieren und doc1 ist ein patient von decode , dann es gibt ein encode,doc2,time der doc2 enthält Informationen über prop und doc1 enthält Informationen über prop und time ist ein teil von "vor "die zeit des Bestehens von decode"" und "encode ist ein fall von Kodieren und doc2 ist ein patient von encode " hält während time .
(=>
(and
(instance ?DECODE Decoding)
(patient ?DECODE ?DOC1))
(exists
(?ENCODE ?DOC2 ?TIME)
(and
(containsInformation ?DOC2 ?PROP)
(containsInformation ?DOC1 ?PROP)
(temporalPart
?TIME
(PastFn
(WhenFn ?DECODE)))
(holdsDuring
?TIME
(and
(instance ?ENCODE Encoding)
(patient ?ENCODE ?DOC2))))))
Wenn wet ist ein fall von Befeuchten , dann es gibt ein obj der liquid ist ein attribut von obj und obj ist ein patient von wet .
(=>
(instance ?WET Wetting)
(exists
(?OBJ)
(and
(attribute ?OBJ Liquid)
(patient ?WET ?OBJ))))
Wenn action ist ein fall von Kreation , dann es gibt ein result der result ist ein resultat von action .
(=>
(instance ?ACTION Creation)
(exists
(?RESULT)
(result ?ACTION ?RESULT)))
process ist ein fall von Kreation nur wenn es gibt ein patient der patient ist ein patient von process und patient besteht während "sofort nach "die zeit des Bestehens von process"" und patient besteht während "direkt vor "die zeit des Bestehens von process"" nicht.
(<=>
(instance ?PROCESS Creation)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))))))
Es gibt ein Konstruieren build der artifact ist ein resultat von build nur wenn artifact ist ein fall von feststehendes Kunstprodukt .
(<=>
(exists
(?BUILD)
(and
(instance ?BUILD Constructing)
(result ?BUILD ?ARTIFACT)))
(instance ?ARTIFACT StationaryArtifact))
Wenn cook ist ein fall von Kochen , dann es gibt ein Nahrung food der food ist ein resultat von cook .
(=>
(instance ?COOK Cooking)
(exists
(?FOOD)
(and
(instance ?FOOD Food)
(result ?COOK ?FOOD))))
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 pretend ist ein fall von Vortäuschen , dann es gibt ein person,prop der pretend hat Zweck von "person glaubt , dass prop" und prop ist true .
(=>
(instance ?PRETEND Pretending)
(exists
(?PERSON ?PROP)
(and
(hasPurpose
?PRETEND
(believes ?PERSON ?PROP))
(true ?PROP True))))
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 disseminate ist ein fall von Verbreitung , dann es gibt ein kognitiver Agent agent1,kognitiver Agent agent2 der disseminate endet an agent1 und disseminate endet an agent2 und agent1 ist gleich agent2 nicht.
(=>
(instance ?DISSEMINATE Disseminating)
(exists
(?AGENT1 ?AGENT2)
(and
(destination ?DISSEMINATE ?AGENT1)
(instance ?AGENT1 CognitiveAgent)
(destination ?DISSEMINATE ?AGENT2)
(instance ?AGENT2 CognitiveAgent)
(not
(equal ?AGENT1 ?AGENT2)))))
Wenn advert ist ein fall von Werbung , dann es gibt ein obj der advert umfasst einen hinweis auf obj und advert hat Zweck von "es gibt ein Verkaufen sale der obj ist ein patient von sale " .
(=>
(instance ?ADVERT Advertising)
(exists
(?OBJ)
(and
(refers ?ADVERT ?OBJ)
(hasPurpose
?ADVERT
(exists
(?SALE)
(and
(instance ?SALE Selling)
(patient ?SALE ?OBJ)))))))
Wenn communicate ist ein fall von linguistic communication , dann es gibt ein linguistischer Ausdruck obj der obj ist ein patient von communicate .
(=>
(instance ?COMMUNICATE LinguisticCommunication)
(exists
(?OBJ)
(and
(instance ?OBJ LinguisticExpression)
(patient ?COMMUNICATE ?OBJ))))
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 , 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 , dann es gibt ein Schlacht battle der battle ist ein subProzess von war.
(=>
(instance ?WAR War)
(exists
(?BATTLE)
(and
(instance ?BATTLE Battle)
(subProcess ?BATTLE ?WAR))))
Wenn battle ist ein fall von Schlacht , dann es gibt ein Krieg war der battle ist ein subProzess von war.
(=>
(instance ?BATTLE Battle)
(exists
(?WAR)
(and
(instance ?WAR War)
(subProcess ?BATTLE ?WAR))))
Wenn battle ist ein fall von Schlacht , dann es gibt ein heftiger Kampf attack der attack ist ein subProzess von battle.
(=>
(instance ?BATTLE Battle)
(exists
(?ATTACK)
(and
(instance ?ATTACK ViolentContest)
(subProcess ?ATTACK ?BATTLE))))
Wenn move ist ein fall von Manöver , dann es gibt ein Kampf contest der move ist ein subProzess von contest.
(=>
(instance ?MOVE Maneuver)
(exists
(?CONTEST)
(and
(instance ?CONTEST Contest)
(subProcess ?MOVE ?CONTEST))))
Wenn see ist ein fall von Sehen und see ist der agent von agent und obj ist ein patient von see , dann
(=>
(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 smell ist ein fall von Geruch und obj ist ein patient von smell , dann es gibt ein Geruchattribut attr der attr ist ein attribut von obj .
(=>
(and
(instance ?SMELL Smelling)
(patient ?SMELL ?OBJ))
(exists
(?ATTR)
(and
(instance ?ATTR OlfactoryAttribute)
(attribute ?OBJ ?ATTR))))
Wenn taste ist ein fall von Geschmack und obj ist ein patient von taste , dann es gibt ein Geschmackattribut attr der attr ist ein attribut von obj .
(=>
(and
(instance ?TASTE Tasting)
(patient ?TASTE ?OBJ))
(exists
(?ATTR)
(and
(instance ?ATTR TasteAttribute)
(attribute ?OBJ ?ATTR))))
Wenn hear ist ein fall von Gehör und obj ist ein patient von hear , dann es gibt ein Tonsattribut attr der attr ist ein attribut von obj .
(=>
(and
(instance ?HEAR Hearing)
(patient ?HEAR ?OBJ))
(exists
(?ATTR)
(and
(instance ?ATTR SoundAttribute)
(attribute ?OBJ ?ATTR))))
Wenn tactile ist ein fall von Tastwahrnehmung , dann es gibt ein Berühren touch der touch ist ein subProzess von tactile.
(=>
(instance ?TACTILE TactilePerception)
(exists
(?TOUCH)
(and
(instance ?TOUCH Touching)
(subProcess ?TOUCH ?TACTILE))))
Es gibt ein ausstrahlendes Licht emit der region ist ein patient von emit und region ist ein fall von Gebiet nur wenn illuminated ist ein attribut von region .
(<=>
(exists
(?EMIT)
(and
(instance ?EMIT RadiatingLight)
(patient ?EMIT ?REGION)
(instance ?REGION Region)))
(attribute ?REGION Illuminated))
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 process ist ein fall von Zustandänderung und obj ist ein patient von process , dann es gibt ein part,körperliche Zustand state1,körperliche Zustand state2 der part ist ein teil von obj und state1 ist gleich state2 nicht und "state1 ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von process"" und "state2 ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .
(=>
(and
(instance ?PROCESS StateChange)
(patient ?PROCESS ?OBJ))
(exists
(?PART ?STATE1 ?STATE2)
(and
(part ?PART ?OBJ)
(instance ?STATE1 PhysicalState)
(instance ?STATE2 PhysicalState)
(not
(equal ?STATE1 ?STATE2))
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROCESS))
(attribute ?PART ?STATE1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FREEZE))
(attribute ?PART ?STATE2)))))
Wenn melt ist ein fall von schmelzend , dann es gibt ein Erhitzen heat der heat ist ein subProzess von melt.
(=>
(instance ?MELT Melting)
(exists
(?HEAT)
(and
(instance ?HEAT Heating)
(subProcess ?HEAT ?MELT))))
Wenn melt ist ein fall von schmelzend und obj ist ein patient von melt , dann es gibt ein part der part ist ein teil von obj und "solid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von melt"" und "liquid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von melt"" .
(=>
(and
(instance ?MELT Melting)
(patient ?MELT ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?MELT))
(attribute ?PART Solid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MELT))
(attribute ?PART Liquid)))))
Wenn boil ist ein fall von kochend , dann es gibt ein Erhitzen heat der heat ist ein subProzess von boil.
(=>
(instance ?BOIL Boiling)
(exists
(?HEAT)
(and
(instance ?HEAT Heating)
(subProcess ?HEAT ?BOIL))))
Wenn boil ist ein fall von kochend und obj ist ein patient von boil , dann es gibt ein part der part ist ein teil von obj und "liquid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von boil"" und "gas ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von boil"" .
(=>
(and
(instance ?BOIL Boiling)
(patient ?BOIL ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?BOIL))
(attribute ?PART Liquid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?BOIL))
(attribute ?PART Gas)))))
Wenn cond ist ein fall von kondensierend , dann es gibt ein Abkühlen cool der cool ist ein subProzess von cond.
(=>
(instance ?COND Condensing)
(exists
(?COOL)
(and
(instance ?COOL Cooling)
(subProcess ?COOL ?COND))))
Wenn cond ist ein fall von kondensierend und obj ist ein patient von cond , dann es gibt ein part der part ist ein teil von obj und "gas ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von cond"" und "liquid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von cond"" .
(=>
(and
(instance ?COND Condensing)
(patient ?COND ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COND))
(attribute ?PART Gas))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COND))
(attribute ?PART Liquid)))))
Wenn freeze ist ein fall von einfrierend , dann es gibt ein Abkühlen cool der cool ist ein subProzess von freeze.
(=>
(instance ?FREEZE Freezing)
(exists
(?COOL)
(and
(instance ?COOL Cooling)
(subProcess ?COOL ?FREEZE))))
Wenn freeze ist ein fall von einfrierend und obj ist ein patient von freeze , dann es gibt ein part der part ist ein teil von obj und "liquid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von freeze"" und "solid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .
(=>
(and
(instance ?FREEZE Freezing)
(patient ?FREEZE ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?FREEZE))
(attribute ?PART Liquid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FREEZE))
(attribute ?PART Solid)))))
Wenn area ist ein fall von Wassergebiet , dann es gibt ein bed,hole,Wasser water der "der wirt von dem Loch hole" ist gleich bed und water füllt hole richtig und "die vereinigung von den teilen von bed und water" ist gleich area .
(=>
(instance ?AREA WaterArea)
(exists
(?BED ?HOLE ?WATER)
(and
(equal
(PrincipalHostFn ?HOLE)
?BED)
(instance ?WATER Water)
(properlyFills ?WATER ?HOLE)
(equal
(MereologicalSumFn ?BED ?WATER)
?AREA))))
Wenn land1 ist ein fall von Landgebiet , dann es gibt ein land2 der land1 ist ein teil von land2 und land2 ist ein fall von Kontinent oder land2 ist ein fall von Insel .
(=>
(instance ?LAND1 LandArea)
(exists
(?LAND2)
(and
(part ?LAND1 ?LAND2)
(or
(instance ?LAND2 Continent)
(instance ?LAND2 Island)))))
Wenn island ist ein fall von Insel , dann es gibt kein Landgebiet area,part1,part2 der part1 ist ein teil von island und part2 ist ein teil von area und island ist ein teil von area nicht und area ist ein teil von island nicht und part1 wird an part2 angeschlossen.
(=>
(instance ?ISLAND Island)
(not
(exists
(?AREA ?PART1 ?PART2)
(and
(instance ?AREA LandArea)
(part ?PART1 ?ISLAND)
(part ?PART2 ?AREA)
(not
(part ?ISLAND ?AREA))
(not
(part ?AREA ?ISLAND))
(connected ?PART1 ?PART2)))))
Wenn state ist ein fall von Staat or Provinz , dann es gibt ein Nation land der state ist ein korrektes teil von land .
(=>
(instance ?STATE StateOrProvince)
(exists
(?LAND)
(and
(instance ?LAND Nation)
(properPart ?STATE ?LAND))))
Wenn "die entwicklungsForm von obj ist attr1" hält während time1 und attr2 ist ein nachfolgerattribut von attr1, dann es gibt ein time2 der time2 geschieht früh als time1 und "die entwicklungsForm von obj ist attr2" hält während time2 .
(=>
(and
(holdsDuring
?TIME1
(developmentalForm ?OBJ ?ATTR1))
(successorAttributeClosure ?ATTR2 ?ATTR1))
(exists
(?TIME2)
(and
(earlier ?TIME2 ?TIME1)
(holdsDuring
?TIME2
(developmentalForm ?OBJ ?ATTR2)))))
Wenn organism ist ein fall von Organismus , dann es gibt ein Geburt birth der organism erfährt birth .
(=>
(instance ?ORGANISM Organism)
(exists
(?BIRTH)
(and
(instance ?BIRTH Birth)
(experiencer ?BIRTH ?ORGANISM))))
Wenn organism wohnt in obj, dann es gibt ein time der "organism befindet sich an " hält während time .
(=>
(inhabits ?ORGANISM ?OBJ)
(exists
(?TIME)
(holdsDuring
?TIME
(located ?ORGANISM ?OBJ))))
Wenn organism ist ein fall von Organismus , dann es gibt ein parent der parent ist das elterntiel von organism .
(=>
(instance ?ORGANISM Organism)
(exists
(?PARENT)
(parent ?ORGANISM ?PARENT)))
animal2 ist die geschwister von animal1 nur wenn es gibt ein father,mother der father ist der vater von animal1 und father ist der vater von animal2 und mother ist die mutter von animal1 und mother ist die mutter von animal2 .
(<=>
(sibling ?ANIMAL1 ?ANIMAL2)
(exists
(?FATHER ?MOTHER)
(and
(father ?ANIMAL1 ?FATHER)
(father ?ANIMAL2 ?FATHER)
(mother ?ANIMAL1 ?MOTHER)
(mother ?ANIMAL2 ?MOTHER))))
Wenn alga ist ein fall von Alge , dann es gibt ein Wasser water der alga wohnt in water.
(=>
(instance ?ALGA Alga)
(exists
(?WATER)
(and
(inhabits ?ALGA ?WATER)
(instance ?WATER Water))))
- wenn bacterium ist ein fall von Bakterium ,
- dann es gibt ein Zelle cell1 der cell1 ist ein bestandteil von bacterium und für jeden cell2 gilt: wenn cell2 ist ein bestandteil von bacterium und cell2 ist ein fall von Zelle , dann cell1 ist gleich cell2
.
(=>
(instance ?BACTERIUM Bacterium)
(exists
(?CELL1)
(and
(component ?CELL1 ?BACTERIUM)
(instance ?CELL1 Cell)
(forall
(?CELL2)
(=>
(and
(component ?CELL2 ?BACTERIUM)
(instance ?CELL2 Cell))
(equal ?CELL1 ?CELL2))))))
(=>
(instance ?VIRUS Virus)
(exists
(?MOL1)
(and
(component ?MOL1 ?VIRUS)
(instance ?MOL1 Molecule)
(forall
(?MOL2)
(=>
(and
(component ?MOL2 ?VIRUS)
(instance ?MOL2 Molecule))
(equal ?MOL1 ?MOL2))))))
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 fish ist ein fall von Fische , dann es gibt ein Wasser water der fish wohnt in water.
(=>
(instance ?FISH Fish)
(exists
(?WATER)
(and
(inhabits ?FISH ?WATER)
(instance ?WATER Water))))
Wenn organism ist ein fall von giftiger Organismus , dann es gibt ein biologisch Wirkstoff substance der substance ist ein teil von organism .
(=>
(instance ?ORGANISM ToxicOrganism)
(exists
(?SUBSTANCE)
(and
(instance ?SUBSTANCE BiologicallyActiveSubstance)
(part ?SUBSTANCE ?ORGANISM))))
Wenn food ist ein fall von Nahrung , dann es gibt ein Nährstoff nutrient der nutrient ist ein teil von food .
(=>
(instance ?FOOD Food)
(exists
(?NUTRIENT)
(and
(instance ?NUTRIENT Nutrient)
(part ?NUTRIENT ?FOOD))))
- wenn food ist ein fall von Nahrung ,
- dann für jeden part1 gilt: wenn part1 ist ein teil von food , dann es gibt ein part2,Tier animal der part1 ist ein teil von part2 und part2 ist ein teil von animal
.
(=>
(instance ?FOOD Food)
(forall
(?PART1)
(=>
(part ?PART1 ?FOOD)
(exists
(?PART2 ?ANIMAL)
(and
(part ?PART1 ?PART2)
(part ?PART2 ?ANIMAL)
(instance ?ANIMAL Animal))))))
- wenn meat ist ein fall von Fleisch ,
- dann für jeden part gilt: wenn part ist ein teil von meat , dann es gibt ein subpart,time,animal der subpart ist ein teil von part und "animal ist ein fall von Tier und subpart ist ein teil von animal " hält während time
.
(=>
(instance ?MEAT Meat)
(forall
(?PART)
(=>
(part ?PART ?MEAT)
(exists
(?SUBPART ?TIME ?ANIMAL)
(and
(part ?SUBPART ?PART)
(holdsDuring
?TIME
(and
(instance ?ANIMAL Animal)
(part ?SUBPART ?ANIMAL))))))))
- wenn veg ist ein fall von Frucht oder Gemüse ,
- dann für jeden part gilt: wenn part ist ein teil von veg , dann es gibt ein subpart,time,plant der subpart ist ein teil von part und "plant ist ein fall von Pflanze und subpart ist ein teil von plant " hält während time
.
(=>
(instance ?VEG FruitOrVegetable)
(forall
(?PART)
(=>
(part ?PART ?VEG)
(exists
(?SUBPART ?TIME ?PLANT)
(and
(part ?SUBPART ?PART)
(holdsDuring
?TIME
(and
(instance ?PLANT Plant)
(part ?SUBPART ?PLANT))))))))
Wenn anat ist ein fall von anatomische Struktur , dann es gibt ein Organismus organism der anat ist ein teil von organism .
(=>
(instance ?ANAT AnatomicalStructure)
(exists
(?ORGANISM)
(and
(instance ?ORGANISM Organism)
(part ?ANAT ?ORGANISM))))
Wenn part ist ein fall von anatomische Struktur , dann es gibt ein Zelle cell der cell ist ein teil von part .
(=>
(instance ?PART AnatomicalStructure)
(exists
(?CELL)
(and
(instance ?CELL Cell)
(part ?CELL ?PART))))
Wenn part ist ein fall von Körperteil , dann es gibt kein pathologischer Prozess proc der part ist ein resultat von proc .
(=>
(instance ?PART BodyPart)
(not
(exists
(?PROC)
(and
(instance ?PROC PathologicProcess)
(result ?PROC ?PART)))))
Wenn cover ist ein fall von Körperbedeckung , dann es gibt ein body der cover ist ein oberflächliches teil von body und body ist ein fall von Organismus oder body ist ein fall von Körperteil .
(=>
(instance ?COVER BodyCovering)
(exists
(?BODY)
(and
(superficialPart ?COVER ?BODY)
(or
(instance ?BODY Organism)
(instance ?BODY BodyPart)))))
Wenn junct ist ein fall von Körperverzweigung , dann es gibt ein Körperteil struct der junct ist ein bestandteil von struct .
(=>
(instance ?JUNCT BodyJunction)
(exists
(?STRUCT)
(and
(instance ?STRUCT BodyPart)
(component ?JUNCT ?STRUCT))))
Wenn junct ist ein fall von Körperverzweigung , dann es gibt ein Körperteil struct1,Körperteil struct2 der junct wird an struct1 angeschlossen und junct wird an struct2 angeschlossen und struct1 ist gleich struct2 nicht.
(=>
(instance ?JUNCT BodyJunction)
(exists
(?STRUCT1 ?STRUCT2)
(and
(connected ?JUNCT ?STRUCT1)
(connected ?JUNCT ?STRUCT2)
(instance ?STRUCT1 BodyPart)
(instance ?STRUCT2 BodyPart)
(not
(equal ?STRUCT1 ?STRUCT2)))))
Wenn organ ist ein fall von Organ , dann es gibt ein purp der organ hat Zweck von purp .
(=>
(instance ?ORGAN Organ)
(exists
(?PURP)
(hasPurpose ?ORGAN ?PURP)))
Wenn stuff ist ein fall von Gewebe , dann es gibt ein Zelle part der part ist ein teil von stuff .
(=>
(instance ?STUFF Tissue)
(exists
(?PART)
(and
(instance ?PART Cell)
(part ?PART ?STUFF))))
Wenn stuff ist ein fall von Gewebe , dann es gibt ein Organismus organism der stuff ist ein teil von organism .
(=>
(instance ?STUFF Tissue)
(exists
(?ORGANISM)
(and
(instance ?ORGANISM Organism)
(part ?STUFF ?ORGANISM))))
Wenn bone ist ein fall von Knochen , dann es gibt ein Wirbeltier vert der bone ist ein teil von vert .
(=>
(instance ?BONE Bone)
(exists
(?VERT)
(and
(instance ?VERT Vertebrate)
(part ?BONE ?VERT))))
Wenn morph ist ein fall von Morphem , dann es gibt kein Morphem othermorph der othermorph ist ein teil von morph und othermorph ist gleich morph nicht.
(=>
(instance ?MORPH Morpheme)
(not
(exists
(?OTHERMORPH)
(and
(instance ?OTHERMORPH Morpheme)
(part ?OTHERMORPH ?MORPH)
(not
(equal ?OTHERMORPH ?MORPH))))))
Wenn morph ist ein fall von Morphem , dann es gibt ein Wort word der morph ist ein teil von word .
(=>
(instance ?MORPH Morpheme)
(exists
(?WORD)
(and
(instance ?WORD Word)
(part ?MORPH ?WORD))))
Wenn word ist ein fall von Wort , dann es gibt ein Morphem part der part ist ein teil von word .
(=>
(instance ?WORD Word)
(exists
(?PART)
(and
(part ?PART ?WORD)
(instance ?PART Morpheme))))
Wenn phrase ist ein fall von Phrase , dann es gibt ein Wort part1,Wort part2 der part1 ist ein teil von phrase und part2 ist ein teil von phrase und part1 ist gleich part2 nicht.
(=>
(instance ?PHRASE Phrase)
(exists
(?PART1 ?PART2)
(and
(part ?PART1 ?PHRASE)
(part ?PART2 ?PHRASE)
(instance ?PART1 Word)
(instance ?PART2 Word)
(not
(equal ?PART1 ?PART2)))))
Wenn sentence ist ein fall von Satz , dann es gibt ein Nominalphrase phrase1,Verbphrase phrase2 der phrase1 ist ein teil von sentence und phrase2 ist ein teil von sentence .
(=>
(instance ?SENTENCE Sentence)
(exists
(?PHRASE1 ?PHRASE2)
(and
(instance ?PHRASE1 NounPhrase)
(instance ?PHRASE2 VerbPhrase)
(part ?PHRASE1 ?SENTENCE)
(part ?PHRASE2 ?SENTENCE))))
Wenn text ist ein fall von Text , dann es gibt ein Proposition prop der text enthält Informationen über prop.
(=>
(instance ?TEXT Text)
(exists
(?PROP)
(and
(instance ?PROP Proposition)
(containsInformation ?TEXT ?PROP))))
Wenn text ist ein fall von Text , dann es gibt ein Satz part der part ist ein teil von text .
(=>
(instance ?TEXT Text)
(exists
(?PART)
(and
(part ?PART ?TEXT)
(instance ?PART Sentence))))
Wenn text ist ein fall von Text , dann es gibt ein Schreiben write der text ist ein resultat von write .
(=>
(instance ?TEXT Text)
(exists
(?WRITE)
(and
(instance ?WRITE Writing)
(result ?WRITE ?TEXT))))
Wenn sent ist ein fall von Satz , dann es gibt ein Nominalphrase noun,Verbphrase verb der noun ist ein teil von sent und verb ist ein teil von sent .
(=>
(instance ?SENT Sentence)
(exists
(?NOUN ?VERB)
(and
(instance ?NOUN NounPhrase)
(instance ?VERB VerbPhrase)
(part ?NOUN ?SENT)
(part ?VERB ?SENT))))
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 text ist ein fall von Zusammenfassung , dann es gibt ein Text text2 der text2 fasst das Inhalt von text zusammen.
(=>
(instance ?TEXT Summary)
(exists
(?TEXT2)
(and
(instance ?TEXT2 Text)
(subsumesContentInstance ?TEXT2 ?TEXT))))
Wenn series ist ein fall von Reihe , dann es gibt ein Buch book1,Buch book2 der series fasst das Inhalt von book1 zusammen und series fasst das Inhalt von book2 zusammen und book1 ist gleich book2 nicht.
(=>
(instance ?SERIES Series)
(exists
(?BOOK1 ?BOOK2)
(and
(instance ?BOOK1 Book)
(instance ?BOOK2 Book)
(subsumesContentInstance ?SERIES ?BOOK1)
(subsumesContentInstance ?SERIES ?BOOK2)
(not
(equal ?BOOK1 ?BOOK2)))))
Wenn article ist ein fall von Artikel , dann es gibt ein Buch book der book fasst das Inhalt von article zusammen.
(=>
(instance ?ARTICLE Article)
(exists
(?BOOK)
(and
(instance ?BOOK Book)
(subsumesContentInstance ?BOOK ?ARTICLE))))
Wenn doc ist ein fall von Bescheinigung und agent besitzt doc , dann es gibt ein proc der doc erlaubt agent, die Aufgabe der Art von proc durchzuführen oder doc zwingt agent, die Aufgabe der Art von proc durchzuführen .
(=>
(and
(instance ?DOC Certificate)
(possesses ?AGENT ?DOC))
(exists
(?PROC)
(or
(confersRight ?PROC ?DOC ?AGENT)
(confersObligation ?PROC ?DOC ?AGENT))))
Wenn mole ist ein fall von Molekül , dann es gibt ein Atom atom1,Atom atom2 der atom1 ist ein teil von mole und atom2 ist ein teil von mole und atom1 ist gleich atom2 nicht.
(=>
(instance ?MOLE Molecule)
(exists
(?ATOM1 ?ATOM2)
(and
(instance ?ATOM1 Atom)
(instance ?ATOM2 Atom)
(part ?ATOM1 ?MOLE)
(part ?ATOM2 ?MOLE)
(not
(equal ?ATOM1 ?ATOM2)))))
artifact ist ein fall von Kunstprodukt nur wenn es gibt ein Bilden making der artifact ist ein resultat von making .
(<=>
(instance ?ARTIFACT Artifact)
(exists
(?MAKING)
(and
(instance ?MAKING Making)
(result ?MAKING ?ARTIFACT))))
Wenn product ist ein fall von Produkt , dann es gibt ein Herstellung manufacture der product ist ein resultat von manufacture .
(=>
(instance ?PRODUCT Product)
(exists
(?MANUFACTURE)
(and
(instance ?MANUFACTURE Manufacture)
(result ?MANUFACTURE ?PRODUCT))))
- wenn artifact ist ein fall von feststehendes Kunstprodukt ,
- dann es gibt ein place der für jeden time gilt: wenn time geschieht vor oder gleichzeitig mit "das ende von "die zeit des Bestehens von artifact"" und "der anfang von "die zeit des Bestehens von artifact"" geschieht vor oder gleichzeitig mit time , dann "die Stelle wo artifact an time war" ist gleich place
.
(=>
(instance ?ARTIFACT StationaryArtifact)
(exists
(?PLACE)
(forall
(?TIME)
(=>
(and
(beforeOrEqual
?TIME
(EndFn
(WhenFn ?ARTIFACT)))
(beforeOrEqual
(BeginFn
(WhenFn ?ARTIFACT))
?TIME))
(equal
(WhereFn ?ARTIFACT ?TIME)
?PLACE)))))
Wenn building ist ein fall von Gebäude , dann es gibt ein Mensch human der - human wohnt in building
oder - 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 room ist ein fall von Zimmer , dann es gibt ein Gebäude build der room ist ein korrektes teil von build .
(=>
(instance ?ROOM Room)
(exists
(?BUILD)
(and
(instance ?BUILD Building)
(properPart ?ROOM ?BUILD))))
Wenn clothing ist ein fall von Kleidung , dann es gibt ein Stoff fabric der fabric ist ein teil von clothing .
(=>
(instance ?CLOTHING Clothing)
(exists
(?FABRIC)
(and
(instance ?FABRIC Fabric)
(part ?FABRIC ?CLOTHING))))
Wenn device ist ein fall von Gerät , dann es gibt ein Prozess proc der device ist fähig , in der Rolle instrument proc zu tun.
(=>
(instance ?DEVICE Device)
(exists
(?PROC)
(and
(subclass ?PROC Process)
(capability ?PROC instrument ?DEVICE))))
Wenn device ist ein fall von Gerät , dann es gibt ein Prozess proc der device hat Zweck von "device ist fähig , in der Rolle instrument proc zu tun" .
(=>
(instance ?DEVICE Device)
(exists
(?PROC)
(and
(subclass ?PROC Process)
(hasPurpose
?DEVICE
(capability ?PROC instrument ?DEVICE)))))
Wenn weapon ist ein fall von Waffe , dann weapon hat Zweck von "es gibt ein Beschädigen dest,patient der patient ist ein patient von dest und " .
(=>
(instance ?WEAPON Weapon)
(hasPurpose
?WEAPON
(exists
(?DEST ?PATIENT)
(and
(instance ?DEST Damaging)
(patient ?DEST ?PATIENT)
(or
(instance ?PATIENT StationaryArtifact)
(instance ?PATIENT Animal)
(exists
(?ANIMAL)
(and
(instance ?ANIMAL Animal)
(inhabits ?ANIMAL ?PATIENT))))))))
- wenn machine ist ein fall von Maschine ,
- dann für jeden proc gilt: wenn machine ist ein instrument für proc , dann es gibt ein resource,result der resource ist ein hilfmittel für proc und result ist ein resultat von proc
.
(=>
(instance ?MACHINE Machine)
(forall
(?PROC)
(=>
(instrument ?PROC ?MACHINE)
(exists
(?RESOURCE ?RESULT)
(and
(resource ?PROC ?RESOURCE)
(result ?PROC ?RESULT))))))
Wenn comp ist ein fall von Technikbestandteil , dann es gibt ein Gerät device der comp ist ein bestandteil von device .
(=>
(instance ?COMP EngineeringComponent)
(exists
(?DEVICE)
(and
(instance ?DEVICE Device)
(component ?COMP ?DEVICE))))
comp1 wird mit comp2 angeschlossen nur wenn es gibt ein connection der connection schliesst comp1 und comp2 an.
(<=>
(connectedEngineeringComponents ?COMP1 ?COMP2)
(exists
(?CONNECTION)
(connectsEngineeringComponents ?CONNECTION ?COMP1 ?COMP2)))
Wenn connection ist ein fall von Technikanschluss , dann es gibt ein comp1,comp2 der connection schliesst comp1 und comp2 an.
(=>
(instance ?CONNECTION EngineeringConnection)
(exists
(?COMP1 ?COMP2)
(connectsEngineeringComponents ?CONNECTION ?COMP1 ?COMP2)))
Wenn organism1 und organism2 sind verwandt, dann es gibt ein organism3 der organism3 und organism1 sind verwandt und organism3 und organism2 sind verwandt.
(=>
(familyRelation ?ORGANISM1 ?ORGANISM2)
(exists
(?ORGANISM3)
(and
(familyRelation ?ORGANISM3 ?ORGANISM1)
(familyRelation ?ORGANISM3 ?ORGANISM2))))
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 plan ist ein fall von Plan und obj ist ein fall von Inhaltsgegenstand und obj enthält Informationen über plan, dann es gibt ein Planen planning der obj ist ein resultat von planning .
(=>
(and
(instance ?PLAN Plan)
(instance ?OBJ ContentBearingObject)
(containsInformation ?OBJ ?PLAN))
(exists
(?PLANNING)
(and
(instance ?PLANNING Planning)
(result ?PLANNING ?OBJ))))
Wenn plan ist ein fall von Plan , dann es gibt ein purp der plan hat Zweck von purp .
(=>
(instance ?PLAN Plan)
(exists
(?PURP)
(hasPurpose ?PLAN ?PURP)))
Wenn org beschäftigt person , dann es gibt ein position der person besetzt die position von position in org.
(=>
(employs ?ORG ?PERSON)
(exists
(?POSITION)
(occupiesPosition ?PERSON ?POSITION ?ORG)))
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)))))
obj ist ein fall von Substanz nur wenn es gibt ein körperliche Zustand attr der attr ist ein attribut von obj .
(<=>
(instance ?OBJ Substance)
(exists
(?ATTR)
(and
(instance ?ATTR PhysicalState)
(attribute ?OBJ ?ATTR))))
Wenn perception ist ein fall von Wahrnehmung und obj ist ein patient von perception , dann es gibt ein Wahrnehmungsattribut prop der prop ist ein attribut von obj .
(=>
(and
(instance ?PERCEPTION Perception)
(patient ?PERCEPTION ?OBJ))
(exists
(?PROP)
(and
(instance ?PROP PerceptualAttribute)
(attribute ?OBJ ?PROP))))
Wenn obj ist ein fall von Nahrung , dann es gibt ein Geschmackattribut attr der attr ist ein attribut von obj .
(=>
(instance ?OBJ Food)
(exists
(?ATTR)
(and
(instance ?ATTR TasteAttribute)
(attribute ?OBJ ?ATTR))))
Wenn polychromatic ist ein attribut von obj , dann es gibt ein part1,part2,Farbeattribut color1,Farbeattribut color2 der part1 ist ein oberflächliches teil von obj und part2 ist ein oberflächliches teil von obj und color1 ist ein attribut von part1 und color2 ist ein attribut von part2 und color1 ist gleich color2 nicht.
(=>
(attribute ?OBJ Polychromatic)
(exists
(?PART1 ?PART2 ?COLOR1 ?COLOR2)
(and
(superficialPart ?PART1 ?OBJ)
(superficialPart ?PART2 ?OBJ)
(attribute ?PART1 ?COLOR1)
(attribute ?PART2 ?COLOR2)
(instance ?COLOR1 ColorAttribute)
(instance ?COLOR2 ColorAttribute)
(not
(equal ?COLOR1 ?COLOR2)))))
Wenn es gibt ein Formänderung change der obj ist ein patient von change , dann pliable ist ein attribut von obj .
(=>
(exists
(?CHANGE)
(and
(instance ?CHANGE ShapeChange)
(patient ?CHANGE ?OBJ)))
(attribute ?OBJ Pliable))
Wenn dry ist ein attribut von obj , dann es gibt kein subobj der subobj ist ein teil von obj und liquid ist ein attribut von subobj .
(=>
(attribute ?OBJ Dry)
(not
(exists
(?SUBOBJ)
(and
(part ?SUBOBJ ?OBJ)
(attribute ?SUBOBJ Liquid)))))
- wenn wet ist ein attribut von obj ,
- dann für jeden part gilt: wenn part ist ein teil von obj , dann es gibt ein subpart der subpart ist ein teil von part und liquid ist ein attribut von subpart
.
(=>
(attribute ?OBJ Wet)
(forall
(?PART)
(=>
(part ?PART ?OBJ)
(exists
(?SUBPART)
(and
(part ?SUBPART ?PART)
(attribute ?SUBPART Liquid))))))
Wenn unbreakable ist ein attribut von obj , dann es gibt kein Beschädigen damage der obj ist ein patient von damage .
(=>
(attribute ?OBJ Unbreakable)
(not
(exists
(?DAMAGE)
(and
(instance ?DAMAGE Damaging)
(patient ?DAMAGE ?OBJ)))))
Wenn org ist ein fall von Organismus , dann es gibt ein Belebtheitsattribut attr der attr ist ein attribut von org .
(=>
(instance ?ORG Organism)
(exists
(?ATTR)
(and
(instance ?ATTR AnimacyAttribute)
(attribute ?ORG ?ATTR))))
Wenn animal ist ein fall von Tier , dann es gibt ein Geschlechtattribut attr der attr ist ein attribut von animal .
(=>
(instance ?ANIMAL Animal)
(exists
(?ATTR)
(and
(instance ?ATTR SexAttribute)
(attribute ?ANIMAL ?ATTR))))
Wenn fully formed ist ein attribut von obj , dann es gibt ein Wachstum growth der obj erfährt growth und "non fully formed ist ein attribut von obj " hält während "der anfang von "die zeit des Bestehens von obj"" .
(=>
(attribute ?OBJ FullyFormed)
(exists
(?GROWTH)
(and
(instance ?GROWTH Growth)
(experiencer ?GROWTH ?OBJ)
(holdsDuring
(BeginFn
(WhenFn ?OBJ))
(attribute ?OBJ NonFullyFormed)))))
Wenn org ist ein fall von Organismus , dann es gibt ein Entwicklungsattribut attr der attr ist ein attribut von org .
(=>
(instance ?ORG Organism)
(exists
(?ATTR)
(and
(instance ?ATTR DevelopmentalAttribute)
(attribute ?ORG ?ATTR))))
Wenn "larval ist ein attribut von org " hält während time , dann "es gibt ein Geburt birth der org erfährt birth " hält während "vor time" .
(=>
(holdsDuring
?TIME
(attribute ?ORG Larval))
(holdsDuring
(PastFn ?TIME)
(exists
(?BIRTH)
(and
(instance ?BIRTH Birth)
(experiencer ?BIRTH ?ORG)))))
Wenn embryonic ist ein attribut von org , dann es gibt ein reproduktive Körper body der org befindet sich an .
(=>
(attribute ?ORG Embryonic)
(exists
(?BODY)
(and
(instance ?BODY ReproductiveBody)
(located ?ORG ?BODY))))
Wenn "embryonic ist ein attribut von org " hält während time , dann "es gibt kein Geburt birth der org erfährt birth " hält während time .
(=>
(holdsDuring
?TIME
(attribute ?ORG Embryonic))
(holdsDuring
?TIME
(not
(exists
(?BIRTH)
(and
(instance ?BIRTH Birth)
(experiencer ?BIRTH ?ORG))))))
agent ist ein fall von empfindungsfähiger Agent und living ist ein attribut von agent nur wenn es gibt ein Bewusstseinsattribut attr der attr ist ein attribut von agent .
(<=>
(and
(instance ?AGENT SentientAgent)
(attribute ?AGENT Living))
(exists
(?ATTR)
(and
(instance ?ATTR ConsciousnessAttribute)
(attribute ?AGENT ?ATTR))))
entity ist ein fall von "die vereinigung aller Elementen von superclass" nur wenn es gibt ein superclass class der entity ist ein fall von class .
(<=>
(instance
?ENTITY
(GeneralizedUnionFn ?SUPERCLASS))
(exists
(?CLASS)
(and
(instance ?CLASS ?SUPERCLASS)
(instance ?ENTITY ?CLASS))))
