and (and)
The truth-functional connective of conjunction.
Ontology
SUMO / STRUCTURAL-ONTOLOGYClass(es)
Coordinate term(s)
<=>
=>
hatZurFolge
exists
forall
not
or
Type restrictions
and(Formel, Formel)
Related WordNet synsets
See more related synsets on a separate page.
Axioms (483)
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)))))
subclass ist eine teilkategorie von class nur wenn
(<=>
(subclass ?SUBCLASS ?CLASS)
(and
(instance ?SUBCLASS SetOrClass)
(instance ?CLASS SetOrClass)
(forall
(?INST)
(=>
(instance ?INST ?SUBCLASS)
(instance ?INST ?CLASS)))))
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 pred1 ist eine teilrelation von pred2 und pred1 hat number argument(e), dann pred2 hat number argument(e).
(=>
(and
(subrelation ?PRED1 ?PRED2)
(valence ?PRED1 ?NUMBER))
(valence ?PRED2 ?NUMBER))
Wenn pred1 ist eine teilrelation von pred2 und die Zahl number Argument von pred2 ist ein fall von class1 , dann die Zahl number Argument von pred1 ist ein fall von class1 .
(=>
(and
(subrelation ?PRED1 ?PRED2)
(domain ?PRED2 ?NUMBER ?CLASS1))
(domain ?PRED1 ?NUMBER ?CLASS1))
Wenn rel1 ist eine teilrelation von rel2 und rel1() gilt , dann rel2() gilt .
(=>
(and
(subrelation ?REL1 ?REL2)
(holds ?REL1 @ROW))
(holds ?REL2 @ROW))
Wenn pred1 ist eine teilrelation von pred2 und pred2 ist ein fall von class und class ist ein fall von inheritable relation , dann pred1 ist ein fall von class .
(=>
(and
(subrelation ?PRED1 ?PRED2)
(instance ?PRED2 ?CLASS)
(instance ?CLASS InheritableRelation))
(instance ?PRED1 ?CLASS))
Wenn die Zahl number Argument von rel ist ein fall von class1 und die Zahl number Argument von rel ist ein fall von class2 , dann class1 ist eine teilkategorie von class2 oder class2 ist eine teilkategorie von class1.
(=>
(and
(domain ?REL ?NUMBER ?CLASS1)
(domain ?REL ?NUMBER ?CLASS2))
(or
(subclass ?CLASS1 ?CLASS2)
(subclass ?CLASS2 ?CLASS1)))
Wenn rel1 ist eine teilrelation von rel2 und die Zahl number Argument von rel2 ist eine teilkategorie von class1 , dann die Zahl number Argument von rel1 ist eine teilkategorie von class1 .
(=>
(and
(subrelation ?REL1 ?REL2)
(domainSubclass ?REL2 ?NUMBER ?CLASS1))
(domainSubclass ?REL1 ?NUMBER ?CLASS1))
Wenn die Zahl number Argument von rel ist eine teilkategorie von class1 und die Zahl number Argument von rel ist eine teilkategorie von class2 , dann class1 ist eine teilkategorie von class2 oder class2 ist eine teilkategorie von class1.
(=>
(and
(domainSubclass ?REL ?NUMBER ?CLASS1)
(domainSubclass ?REL ?NUMBER ?CLASS2))
(or
(subclass ?CLASS1 ?CLASS2)
(subclass ?CLASS2 ?CLASS1)))
- wenn obj1 ist gleich obj2 ,
- dann wenn obj1 ist gleich "numberte mitglied von "()"" und obj2 ist gleich "numberte mitglied von "()"" und "()" ist gleich "()" , dann () gilt nur wenn () gilt
.
(=>
(equal ?OBJ1 ?OBJ2)
(=>
(and
(equal
?OBJ1
(ListOrderFn
(ListFn @ROW1)
?NUMBER))
(equal
?OBJ2
(ListOrderFn
(ListFn @ROW2)
?NUMBER))
(equal
(ListFn @ROW1)
(ListFn @ROW2)))
(<=>
(holds @ROW1)
(holds @ROW2))))
- wenn list1 ist gleich list2 ,
- dann wenn list1 ist gleich "()" und list2 ist gleich "()" , dann für jeden number gilt: "numberte mitglied von "()"" ist gleich "numberte mitglied von "()""
.
(=>
(equal ?LIST1 ?LIST2)
(=>
(and
(equal
?LIST1
(ListFn @ROW1))
(equal
?LIST2
(ListFn @ROW2)))
(forall
(?NUMBER)
(equal
(ListOrderFn
(ListFn @ROW1)
?NUMBER)
(ListOrderFn
(ListFn @ROW2)
?NUMBER)))))
Wenn bildbereich von function ist ein fall von class {nicht} und "function()" ist gleich value , dann value ist ein fall von class .
(=>
(and
(range ?FUNCTION ?CLASS)
(equal
(AssignmentFn ?FUNCTION @ROW)
?VALUE))
(instance ?VALUE ?CLASS))
Wenn rel1 ist eine teilrelation von rel2 und bildbereich von rel2 ist ein fall von class1 {nicht}, dann bildbereich von rel1 ist ein fall von class1 {nicht}.
(=>
(and
(subrelation ?REL1 ?REL2)
(range ?REL2 ?CLASS1))
(range ?REL1 ?CLASS1))
Wenn bildbereich von rel ist ein fall von class1 {nicht} und bildbereich von rel ist ein fall von class2 {nicht}, dann class1 ist eine teilkategorie von class2 oder class2 ist eine teilkategorie von class1.
(=>
(and
(range ?REL ?CLASS1)
(range ?REL ?CLASS2))
(or
(subclass ?CLASS1 ?CLASS2)
(subclass ?CLASS2 ?CLASS1)))
Wenn die werte die function zurückgibt sind teilkategorien von class und "function()" ist gleich value , dann value ist eine teilkategorie von class.
(=>
(and
(rangeSubclass ?FUNCTION ?CLASS)
(equal
(AssignmentFn ?FUNCTION @ROW)
?VALUE))
(subclass ?VALUE ?CLASS))
Wenn rel1 ist eine teilrelation von rel2 und die werte die rel2 zurückgibt sind teilkategorien von class1, dann die werte die rel1 zurückgibt sind teilkategorien von class1.
(=>
(and
(subrelation ?REL1 ?REL2)
(rangeSubclass ?REL2 ?CLASS1))
(rangeSubclass ?REL1 ?CLASS1))
Wenn die werte die rel zurückgibt sind teilkategorien von class1 und die werte die rel zurückgibt sind teilkategorien von class2, dann class1 ist eine teilkategorie von class2 oder class2 ist eine teilkategorie von class1.
(=>
(and
(rangeSubclass ?REL ?CLASS1)
(rangeSubclass ?REL ?CLASS2))
(or
(subclass ?CLASS1 ?CLASS2)
(subclass ?CLASS2 ?CLASS1)))
class1 ist dijunkt von class2 nur wenn
(<=>
(disjoint ?CLASS1 ?CLASS2)
(and
(instance ?CLASS1 SetOrClass)
(instance ?CLASS2 SetOrClass)
(forall
(?INST)
(not
(and
(instance ?INST ?CLASS1)
(instance ?INST ?CLASS2))))))
Wenn und ? werden disjunkt und rel ist ein Mitglied von "()", dann rel ist ein fall von Relation .
(=>
(and
(disjointRelation @ROW)
(inList
?REL
(ListFn @ROW)))
(instance ?REL Relation))
Wenn und ? werden disjunkt und rel1 ist ein Mitglied von "()" und rel2 ist ein Mitglied von "()" und rel1 hat number argument(e), dann rel2 hat number argument(e).
(=>
(and
(disjointRelation @ROW)
(inList
?REL1
(ListFn @ROW))
(inList
?REL2
(ListFn @ROW))
(valence ?REL1 ?NUMBER))
(valence ?REL2 ?NUMBER))
Wenn die Zahl number Argument von rel1 ist ein fall von class1 und die Zahl number Argument von rel2 ist ein fall von class2 und class1 ist dijunkt von class2 , dann rel1 und rel2 werden disjunkt.
(=>
(and
(domain ?REL1 ?NUMBER ?CLASS1)
(domain ?REL2 ?NUMBER ?CLASS2)
(disjoint ?CLASS1 ?CLASS2))
(disjointRelation ?REL1 ?REL2))
Wenn die Zahl number Argument von rel1 ist eine teilkategorie von class1 und die Zahl number Argument von rel2 ist eine teilkategorie von class2 und class1 ist dijunkt von class2 , dann rel1 und rel2 werden disjunkt.
(=>
(and
(domainSubclass ?REL1 ?NUMBER ?CLASS1)
(domainSubclass ?REL2 ?NUMBER ?CLASS2)
(disjoint ?CLASS1 ?CLASS2))
(disjointRelation ?REL1 ?REL2))
Wenn bildbereich von rel1 ist ein fall von class1 {nicht} und bildbereich von rel2 ist ein fall von class2 {nicht} und class1 ist dijunkt von class2 , dann rel1 und rel2 werden disjunkt.
(=>
(and
(range ?REL1 ?CLASS1)
(range ?REL2 ?CLASS2)
(disjoint ?CLASS1 ?CLASS2))
(disjointRelation ?REL1 ?REL2))
Wenn die werte die rel1 zurückgibt sind teilkategorien von class1 und die werte die rel2 zurückgibt sind teilkategorien von class2 und class1 ist dijunkt von class2 , dann rel1 und rel2 werden disjunkt.
(=>
(and
(rangeSubclass ?REL1 ?CLASS1)
(rangeSubclass ?REL2 ?CLASS2)
(disjoint ?CLASS1 ?CLASS2))
(disjointRelation ?REL1 ?REL2))
Wenn und ? werden disjunkt und rel1 ist ein Mitglied von "()" und rel2 ist ein Mitglied von "()" und rel1 ist gleich rel2 nicht und rel1() gilt , dann rel2() gilt nicht.
(=>
(and
(disjointRelation @ROW1)
(inList
?REL1
(ListFn @ROW1))
(inList
?REL2
(ListFn @ROW1))
(not
(equal ?REL1 ?REL2))
(holds ?REL1 @ROW2))
(not
(holds ?REL2 @ROW2)))
- wenn wird ? entgegengesetzet ,
- dann für jeden attr1,attr2 gilt:
- wenn attr1 ist gleich "number1te mitglied von "()"" und attr2 ist gleich "number2te mitglied von "()"" und number1 ist gleich number2 nicht,
- dann wenn obj hat ein attribut attr1 , dann obj hat ein attribut attr2 nicht
.
(=>
(contraryAttribute @ROW)
(forall
(?ATTR1 ?ATTR2)
(=>
(and
(equal
?ATTR1
(ListOrderFn
(ListFn @ROW)
?NUMBER1))
(equal
?ATTR2
(ListOrderFn
(ListFn @ROW)
?NUMBER2))
(not
(equal ?NUMBER1 ?NUMBER2)))
(=>
(property ?OBJ ?ATTR1)
(not
(property ?OBJ ?ATTR2))))))
- 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))))))
wird vollständig in verteilt nur wenn wird mit behandelt und wird zusammenhanglos auf disjunkt.
(<=>
(partition @ROW)
(and
(exhaustiveDecomposition @ROW)
(disjointDecomposition @ROW)))
Wenn attr1 ist ein teilattribut von attr2 und attr2 ist ein fall von class , dann attr1 ist ein fall von class .
(=>
(and
(subAttribute ?ATTR1 ?ATTR2)
(instance ?ATTR2 ?CLASS))
(instance ?ATTR1 ?CLASS))
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)))))
Wenn rel(,inst) gilt und rel ist ein fall von Funktion , dann "rel()" ist gleich inst .
(=>
(and
(holds ?REL @ROW ?INST)
(instance ?REL Function))
(equal
(AssignmentFn ?REL @ROW)
?INST))
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))))
obj1 ist ein korrektes teil von obj2 nur wenn obj1 ist ein teil von obj2 und obj2 ist ein teil von obj1 nicht.
(<=>
(properPart ?OBJ1 ?OBJ2)
(and
(part ?OBJ1 ?OBJ2)
(not
(part ?OBJ2 ?OBJ1))))
Wenn objecttype ist eine teilkategorie von Substanz und object ist ein fall von objecttype und part ist ein teil von object , dann part ist ein fall von objecttype .
(=>
(and
(subclass ?OBJECTTYPE Substance)
(instance ?OBJECT ?OBJECTTYPE)
(part ?PART ?OBJECT))
(instance ?PART ?OBJECTTYPE))
Wenn obj ist ein fall von Substanz und attr ist ein attribut von obj und part ist ein teil von obj , dann attr ist ein attribut von part .
(=>
(and
(instance ?OBJ Substance)
(attribute ?OBJ ?ATTR)
(part ?PART ?OBJ))
(attribute ?PART ?ATTR))
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 atom ist ein fall von Atom ,
- dann für jeden nucleus1,nucleus2 gilt: wenn nucleus1 ist ein bestandteil von atom und nucleus2 ist ein bestandteil von atom und nucleus1 ist ein fall von Atomkern und nucleus2 ist ein fall von Atomkern , dann nucleus1 ist gleich nucleus2
.
(=>
(instance ?ATOM Atom)
(forall
(?NUCLEUS1 ?NUCLEUS2)
(=>
(and
(component ?NUCLEUS1 ?ATOM)
(component ?NUCLEUS2 ?ATOM)
(instance ?NUCLEUS1 AtomicNucleus)
(instance ?NUCLEUS2 AtomicNucleus))
(equal ?NUCLEUS1 ?NUCLEUS2))))
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)))))
coll1 ist eine korrekte teilsammlung von coll2 nur wenn
(<=>
(subCollection ?COLL1 ?COLL2)
(and
(instance ?COLL1 Collection)
(instance ?COLL2 Collection)
(forall
(?MEMBER)
(=>
(member ?MEMBER ?COLL1)
(member ?MEMBER ?COLL2)))))
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 Tiersprache und proc ist der agent von agent und lang ist ein instrument für proc , dann agent ist ein fall von Tier und agent ist ein fall von Mensch nicht.
(=>
(and
(instance ?LANG AnimalLanguage)
(agent ?PROC ?AGENT)
(instrument ?PROC ?LANG))
(and
(instance ?AGENT Animal)
(not
(instance ?AGENT Human))))
Wenn lang ist ein fall von Computersprache und proc ist der agent von agent und lang ist ein instrument für proc , dann agent ist ein fall von Maschine .
(=>
(and
(instance ?LANG ComputerLanguage)
(agent ?PROC ?AGENT)
(instrument ?PROC ?LANG))
(instance ?AGENT Machine))
Wenn lang ist ein fall von menschliche Sprache und proc ist der agent von agent und lang ist ein instrument für proc , dann agent ist ein fall von Mensch .
(=>
(and
(instance ?LANG HumanLanguage)
(agent ?PROC ?AGENT)
(instrument ?PROC ?LANG))
(instance ?AGENT Human))
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))))
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)))))
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))))))
number ist ein fall von nichtnegative reelle Zahl nur wenn number ist grösserAlsOderGleich und number ist ein fall von reelle Zahl .
(<=>
(instance ?NUMBER NonnegativeRealNumber)
(and
(greaterThanOrEqualTo ?NUMBER 0)
(instance ?NUMBER RealNumber)))
number ist ein fall von positive reelle Zahl nur wenn number ist grösserAls und number ist ein fall von reelle Zahl .
(<=>
(instance ?NUMBER PositiveRealNumber)
(and
(greaterThan ?NUMBER 0)
(instance ?NUMBER RealNumber)))
number ist ein fall von negative reelle Zahl nur wenn number ist kleinerAls und number ist ein fall von reelle Zahl .
(<=>
(instance ?NUMBER NegativeRealNumber)
(and
(lessThan ?NUMBER 0)
(instance ?NUMBER RealNumber)))
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)))))))
Wenn function ist ein fall von einstellige konstante Funktionsquantität , dann die Zahl Argument von function ist ein fall von konstante Quantität und bildbereich von function ist ein fall von konstante Quantität {nicht}.
(=>
(instance ?FUNCTION UnaryConstantFunctionQuantity)
(and
(domain ?FUNCTION 1 ConstantQuantity)
(range ?FUNCTION ConstantQuantity)))
rel ist ein fall von einwertige Relation nur wenn für jeden ,item1,item2 gilt: wenn rel(,item1) gilt und rel(,item2) gilt , dann item1 ist gleich item2 .
(<=>
(instance ?REL SingleValuedRelation)
(forall
(@ROW ?ITEM1 ?ITEM2)
(=>
(and
(holds ?REL @ROW ?ITEM1)
(holds ?REL @ROW ?ITEM2))
(equal ?ITEM1 ?ITEM2))))
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 , dann rel ist ein fall von asymmetrische Relation .
(=>
(and
(instance ?REL BinaryRelation)
(or
(domain ?REL 1 ?CLASS1)
(domainSubclass ?REL 1 ?CLASS1))
(or
(domain ?REL 2 ?CLASS2)
(domainSubclass ?REL 2 ?CLASS2)
(range ?REL ?CLASS2)
(rangeSubclass ?REL ?CLASS2))
(disjoint ?CLASS1 ?CLASS2))
(instance ?REL AsymmetricRelation))
- wenn rel ist ein fall von antisymmetrische Relation ,
- dann für jeden inst1,inst2 gilt: wenn rel(inst1,inst2) gilt und rel(inst2,inst1) gilt , dann inst1 ist gleich inst2
.
(=>
(instance ?REL AntisymmetricRelation)
(forall
(?INST1 ?INST2)
(=>
(and
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST1))
(equal ?INST1 ?INST2))))
- wenn rel ist ein fall von transitive Relation ,
- dann für jeden inst1,inst2,inst3 gilt: wenn rel(inst1,inst2) gilt und rel(inst2,inst3) gilt , dann rel(inst1,inst3) gilt
.
(=>
(instance ?REL TransitiveRelation)
(forall
(?INST1 ?INST2 ?INST3)
(=>
(and
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST3))
(holds ?REL ?INST1 ?INST3))))
- wenn rel ist ein fall von intransitive Relation ,
- dann für jeden inst1,inst2,inst3 gilt: wenn rel(inst1,inst2) gilt und rel(inst2,inst3) gilt , dann rel(inst1,inst3) gilt nicht
.
(=>
(instance ?REL IntransitiveRelation)
(forall
(?INST1 ?INST2 ?INST3)
(=>
(and
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST3))
(not
(holds ?REL ?INST1 ?INST3)))))
Wenn formula1 vergrössert die Wahrscheinlichkeit von formula2 und "die wahrscheinlichkeit von formula2" ist gleich number1 und Gesetzt den Fall, dass formula2 gilt, ist die wahrscheinlichkeit von formula1 number2, dann number2 ist grösserAls number1 .
(=>
(and
(increasesLikelihood ?FORMULA1 ?FORMULA2)
(equal
(ProbabilityFn ?FORMULA2)
?NUMBER1)
(conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
(greaterThan ?NUMBER2 ?NUMBER1))
Wenn formula1 verringert die Wahrscheinlichkeit von formula2 und "die wahrscheinlichkeit von formula2" ist gleich number1 und Gesetzt den Fall, dass formula2 gilt, ist die wahrscheinlichkeit von formula1 number2, dann number2 ist kleinerAls number1 .
(=>
(and
(decreasesLikelihood ?FORMULA1 ?FORMULA2)
(equal
(ProbabilityFn ?FORMULA2)
?NUMBER1)
(conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
(lessThan ?NUMBER2 ?NUMBER1))
Wenn Die wahrscheinlichkeit von formula1 und formula2 ist unabhänig und "die wahrscheinlichkeit von formula2" ist gleich number1 und Gesetzt den Fall, dass formula2 gilt, ist die wahrscheinlichkeit von formula1 number2, dann number2 ist gleich number1 .
(=>
(and
(independentProbability ?FORMULA1 ?FORMULA2)
(equal
(ProbabilityFn ?FORMULA2)
?NUMBER1)
(conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
(equal ?NUMBER2 ?NUMBER1))
Wenn formula1 ist ein fall von Formel und formula2 ist ein fall von Formel , dann formula1 vergrössert die Wahrscheinlichkeit von formula2 oder formula1 verringert die Wahrscheinlichkeit von formula2 oder Die wahrscheinlichkeit von formula1 und formula2 ist unabhänig .
(=>
(and
(instance ?FORMULA1 Formula)
(instance ?FORMULA2 Formula))
(or
(increasesLikelihood ?FORMULA1 ?FORMULA2)
(decreasesLikelihood ?FORMULA1 ?FORMULA2)
(independentProbability ?FORMULA1 ?FORMULA2)))
Wenn rel ist ein fall von intentional relation und rel(agent,) gilt und obj ist ein Mitglied von "()", dann agent ist an obj interessiert .
(=>
(and
(instance ?REL IntentionalRelation)
(holds ?REL ?AGENT @ROW)
(inList
?OBJ
(ListFn @ROW)))
(inScopeOfInterest ?AGENT ?OBJ))
- 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))))))))
- 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 class wird zusammenhanglos auf disjunkt,
- dann für jeden item1,item2 gilt: wenn item1 ist ein Mitglied von "()" und item2 ist ein Mitglied von "()" und item1 ist gleich item2 nicht, dann item1 ist dijunkt von item2
.
(=>
(disjointDecomposition ?CLASS @ROW)
(forall
(?ITEM1 ?ITEM2)
(=>
(and
(inList
?ITEM1
(ListFn @ROW))
(inList
?ITEM2
(ListFn @ROW))
(not
(equal ?ITEM1 ?ITEM2)))
(disjoint ?ITEM1 ?ITEM2))))
Wenn list1 ist ein fall von Liste und list2 ist ein fall von Liste und für jeden number gilt: "numberte mitglied von list1" ist gleich "numberte mitglied von list2" , dann list1 ist gleich list2 .
(=>
(and
(instance ?LIST1 List)
(instance ?LIST2 List)
(forall
(?NUMBER)
(equal
(ListOrderFn ?LIST1 ?NUMBER)
(ListOrderFn ?LIST2 ?NUMBER))))
(equal ?LIST1 ?LIST2))
Wenn die Zahl number Argument von rel ist ein fall von class und rel() gilt , dann "numberte mitglied von "()"" ist ein fall von class .
(=>
(and
(domain ?REL ?NUMBER ?CLASS)
(holds ?REL @ROW))
(instance
(ListOrderFn
(ListFn @ROW)
?NUMBER)
?CLASS))
Wenn die Zahl number Argument von rel ist eine teilkategorie von class und rel() gilt , dann "numberte mitglied von "()"" ist eine teilkategorie von class.
(=>
(and
(domainSubclass ?REL ?NUMBER ?CLASS)
(holds ?REL @ROW))
(subclass
(ListOrderFn
(ListFn @ROW)
?NUMBER)
?CLASS))
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))))
list3 ist gleich "die Liste bestanden aus list1 und list2" nur wenn für jeden number1,number2 gilt: wenn number1 ist kleinerAlsOderGleich "Länge von list1" und number2 ist kleinerAlsOderGleich "Länge von list2" und number1 ist ein fall von positive Ganzzahl und number2 ist ein fall von positive Ganzzahl , dann "number1te mitglied von list3" ist gleich "number1te mitglied von list1" und ""("Länge von list1"+number2)"te mitglied von list3" ist gleich "number2te mitglied von list2" .
(<=>
(equal
?LIST3
(ListConcatenateFn ?LIST1 ?LIST2))
(forall
(?NUMBER1 ?NUMBER2)
(=>
(and
(lessThanOrEqualTo
?NUMBER1
(ListLengthFn ?LIST1))
(lessThanOrEqualTo
?NUMBER2
(ListLengthFn ?LIST2))
(instance ?NUMBER1 PositiveInteger)
(instance ?NUMBER2 PositiveInteger))
(and
(equal
(ListOrderFn ?LIST3 ?NUMBER1)
(ListOrderFn ?LIST1 ?NUMBER1))
(equal
(ListOrderFn
?LIST3
(AdditionFn
(ListLengthFn ?LIST1)
?NUMBER2))
(ListOrderFn ?LIST2 ?NUMBER2))))))
- 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 list1 beginnt list2 ,
- dann für jeden number1,number2 gilt: wenn "Länge von list1" ist gleich number1 und number2 ist kleinerAlsOderGleich number1 , dann "number2te mitglied von list1" ist gleich "number2te mitglied von list2"
.
(=>
(initialList ?LIST1 ?LIST2)
(forall
(?NUMBER1 ?NUMBER2)
(=>
(and
(equal
(ListLengthFn ?LIST1)
?NUMBER1)
(lessThanOrEqualTo ?NUMBER2 ?NUMBER1))
(equal
(ListOrderFn ?LIST1 ?NUMBER2)
(ListOrderFn ?LIST2 ?NUMBER2)))))
- wenn fun ist ein fall von eineindeutige Function ,
- dann für jeden arg1,arg2 gilt: wenn die Zahl Argument von fun ist ein fall von class und arg1 ist ein fall von class und arg2 ist ein fall von class und arg1 ist gleich arg2 nicht, dann "fun(arg1)" ist gleich "fun(arg2)" nicht
.
(=>
(instance ?FUN OneToOneFunction)
(forall
(?ARG1 ?ARG2)
(=>
(and
(domain ?FUN 1 ?CLASS)
(instance ?ARG1 ?CLASS)
(instance ?ARG2 ?CLASS)
(not
(equal ?ARG1 ?ARG2)))
(not
(equal
(AssignmentFn ?FUN ?ARG1)
(AssignmentFn ?FUN ?ARG2))))))
Wenn seq ist ein fall von Sequenzfunktion und bildbereich von seq ist ein fall von class {nicht}, dann class ist eine teilkategorie von Ganzzahl.
(=>
(and
(instance ?SEQ SequenceFunction)
(range ?SEQ ?CLASS))
(subclass ?CLASS Integer))
- wenn function ist ein fall von associative Funktion ,
- dann für jeden inst1,inst2,inst3 gilt: wenn die Zahl Argument von function ist ein fall von class und inst1 ist ein fall von class und inst2 ist ein fall von class und inst3 ist ein fall von class , dann "function(inst1,"function(inst2,inst3)")" ist gleich "function("function(inst1,inst2)",inst3)"
.
(=>
(instance ?FUNCTION AssociativeFunction)
(forall
(?INST1 ?INST2 ?INST3)
(=>
(and
(domain ?FUNCTION 1 ?CLASS)
(instance ?INST1 ?CLASS)
(instance ?INST2 ?CLASS)
(instance ?INST3 ?CLASS))
(equal
(AssignmentFn
?FUNCTION
?INST1
(AssignmentFn ?FUNCTION ?INST2 ?INST3))
(AssignmentFn
?FUNCTION
(AssignmentFn ?FUNCTION ?INST1 ?INST2)
?INST3)))))
- wenn function ist ein fall von commutative Funktion ,
- dann für jeden inst1,inst2 gilt: wenn die Zahl Argument von function ist ein fall von class und inst1 ist ein fall von class und inst2 ist ein fall von class , dann "function(inst1,inst2)" ist gleich "function(inst2,inst1)"
.
(=>
(instance ?FUNCTION CommutativeFunction)
(forall
(?INST1 ?INST2)
(=>
(and
(domain ?FUNCTION 1 ?CLASS)
(instance ?INST1 ?CLASS)
(instance ?INST2 ?CLASS))
(equal
(AssignmentFn ?FUNCTION ?INST1 ?INST2)
(AssignmentFn ?FUNCTION ?INST2 ?INST1)))))
- wenn function ist mit class aufgeschlossen und function ist ein fall von einstellige Funktion ,
- dann für jeden inst gilt: wenn inst ist ein fall von class , dann "function(inst)" ist ein fall von class
.
(=>
(and
(closedOn ?FUNCTION ?CLASS)
(instance ?FUNCTION UnaryFunction))
(forall
(?INST)
(=>
(instance ?INST ?CLASS)
(instance
(AssignmentFn ?FUNCTION ?INST)
?CLASS))))
- wenn function ist mit class aufgeschlossen und function ist ein fall von zweistellige Funktion ,
- dann für jeden inst1,inst2 gilt: wenn inst1 ist ein fall von class und inst2 ist ein fall von class , dann "function(inst1,inst2)" ist ein fall von class
.
(=>
(and
(closedOn ?FUNCTION ?CLASS)
(instance ?FUNCTION BinaryFunction))
(forall
(?INST1 ?INST2)
(=>
(and
(instance ?INST1 ?CLASS)
(instance ?INST2 ?CLASS))
(instance
(AssignmentFn ?FUNCTION ?INST1 ?INST2)
?CLASS))))
Wenn relation ist eine teilweise Einrichtung auf class , dann relation ist auf class reflexiv und relation ist ein fall von transitive Relation und relation ist ein fall von antisymmetrische Relation .
(=>
(partialOrderingOn ?RELATION ?CLASS)
(and
(reflexiveOn ?RELATION ?CLASS)
(instance ?RELATION TransitiveRelation)
(instance ?RELATION AntisymmetricRelation)))
relation ist eine gesampteinrichtung auf class nur wenn relation ist eine teilweise Einrichtung auf class und relation ist eine trichotomizierung auf class .
(<=>
(totalOrderingOn ?RELATION ?CLASS)
(and
(partialOrderingOn ?RELATION ?CLASS)
(trichotomizingOn ?RELATION ?CLASS)))
- wenn relation ist eine trichotomizierung auf class ,
- dann für jeden inst1,inst2 gilt: wenn inst1 ist ein fall von class und inst2 ist ein fall von class , dann relation(inst1,inst2) gilt oder relation(inst2,inst1) gilt oder inst1 ist gleich inst2
.
(=>
(trichotomizingOn ?RELATION ?CLASS)
(forall
(?INST1 ?INST2)
(=>
(and
(instance ?INST1 ?CLASS)
(instance ?INST2 ?CLASS))
(or
(holds ?RELATION ?INST1 ?INST2)
(holds ?RELATION ?INST2 ?INST1)
(equal ?INST1 ?INST2)))))
Wenn relation ist eine äquivalenzrelation mit class , dann relation ist ein fall von transitive Relation und relation ist ein fall von symmetrische Relation und relation ist auf class reflexiv .
(=>
(equivalenceRelationOn ?RELATION ?CLASS)
(and
(instance ?RELATION TransitiveRelation)
(instance ?RELATION SymmetricRelation)
(reflexiveOn ?RELATION ?CLASS)))
- wenn function1 ist distributiv über function2,
- dann für jeden inst1,inst2,inst3 gilt: wenn die Zahl Argument von function1 ist ein fall von class1 und inst1 ist ein fall von class1 und inst2 ist ein fall von class1 und inst3 ist ein fall von class1 und die Zahl Argument von function2 ist ein fall von class2 und inst1 ist ein fall von class2 und inst2 ist ein fall von class2 und inst3 ist ein fall von class2 , dann "function1(inst1,"function2(inst2,inst3)")" ist gleich "function2("function1(inst1,inst2)","function1(inst1,inst3)")"
.
(=>
(distributes ?FUNCTION1 ?FUNCTION2)
(forall
(?INST1 ?INST2 ?INST3)
(=>
(and
(domain ?FUNCTION1 1 ?CLASS1)
(instance ?INST1 ?CLASS1)
(instance ?INST2 ?CLASS1)
(instance ?INST3 ?CLASS1)
(domain ?FUNCTION2 1 ?CLASS2)
(instance ?INST1 ?CLASS2)
(instance ?INST2 ?CLASS2)
(instance ?INST3 ?CLASS2))
(equal
(AssignmentFn
?FUNCTION1
?INST1
(AssignmentFn ?FUNCTION2 ?INST2 ?INST3))
(AssignmentFn
?FUNCTION2
(AssignmentFn ?FUNCTION1 ?INST1 ?INST2)
(AssignmentFn ?FUNCTION1 ?INST1 ?INST3))))))
- 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 situation1 hält während time und situation1 hat situation2 zur Folge , dann situation2 hält während time .
(=>
(and
(holdsDuring ?TIME ?SITUATION1)
(entails ?SITUATION1 ?SITUATION2))
(holdsDuring ?TIME ?SITUATION2))
Wenn role ist ein fall von Fallrolle und role(arg1,arg2) gilt und arg1 ist ein fall von proc , dann arg2 ist fähig , in der Rolle role proc zu tun.
(=>
(and
(instance ?ROLE CaseRole)
(holds ?ROLE ?ARG1 ?ARG2)
(instance ?ARG1 ?PROC))
(capability ?PROC ?ROLE ?ARG2))
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 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 time ist ein fall von Zeitposition und "agent1 besitzt obj " hält während time und "agent2 besitzt obj " hält während time , dann agent1 ist gleich agent2 .
(=>
(and
(instance ?TIME TimePosition)
(holdsDuring
?TIME
(possesses ?AGENT1 ?OBJ))
(holdsDuring
?TIME
(possesses ?AGENT2 ?OBJ)))
(equal ?AGENT1 ?AGENT2))
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))))))))
class1 fasst das Inhalt von class2 zusammen und class2 fasst das Inhalt von class1 zusammen nur wenn class1 ist mit class2 gleichwertig.
(<=>
(and
(subsumesContentClass ?CLASS1 ?CLASS2)
(subsumesContentClass ?CLASS2 ?CLASS1))
(equivalentContentClass ?CLASS1 ?CLASS2))
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))))))
obj1 fasst das Inhalt von obj2 zusammen und obj2 fasst das Inhalt von obj1 zusammen nur wenn obj1 ist mit obj2 gleichwertig.
(<=>
(and
(subsumesContentInstance ?OBJ1 ?OBJ2)
(subsumesContentInstance ?OBJ2 ?OBJ1))
(equivalentContentInstance ?OBJ1 ?OBJ2))
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))))
- wenn prop1 ist eine teilangelegenheit von prop2 ,
- dann für jeden obj1,obj2 gilt: wenn obj1 enthält Informationen über prop1 und obj2 enthält Informationen über prop2, dann obj2 fasst das Inhalt von obj1 zusammen
.
(=>
(subProposition ?PROP1 ?PROP2)
(forall
(?OBJ1 ?OBJ2)
(=>
(and
(containsInformation ?OBJ1 ?PROP1)
(containsInformation ?OBJ2 ?PROP2))
(subsumesContentInstance ?OBJ2 ?OBJ1))))
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)))))
"der absolutebetrag von number1" ist gleich number2 und number1 ist ein fall von reelle Zahl und number2 ist ein fall von reelle Zahl nur wenn
(<=>
(and
(equal
(AbsoluteValueFn ?NUMBER1)
?NUMBER2)
(instance ?NUMBER1 RealNumber)
(instance ?NUMBER2 RealNumber))
(or
(and
(instance ?NUMBER1 NonnegativeRealNumber)
(equal ?NUMBER1 ?NUMBER2))
(and
(instance ?NUMBER1 NegativeRealNumber)
(equal
?NUMBER2
(SubtractionFn 0 ?NUMBER1)))))
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)))))))
Wenn "das grössere von number1 und number2" ist gleich number , dann - number ist gleich number1 und number1 ist grösserAls number2
oder - number ist gleich number2 und number2 ist grösserAls number1
oder - number ist gleich number1 und number ist gleich number2
.
(=>
(equal
(MaxFn ?NUMBER1 ?NUMBER2)
?NUMBER)
(or
(and
(equal ?NUMBER ?NUMBER1)
(greaterThan ?NUMBER1 ?NUMBER2))
(and
(equal ?NUMBER ?NUMBER2)
(greaterThan ?NUMBER2 ?NUMBER1))
(and
(equal ?NUMBER ?NUMBER1)
(equal ?NUMBER ?NUMBER2))))
Wenn "das kleinere von number1 und number2" ist gleich number , dann - number ist gleich number1 und number1 ist kleinerAls number2
oder - number ist gleich number2 und number2 ist kleinerAls number1
oder - number ist gleich number1 und number ist gleich number2
.
(=>
(equal
(MinFn ?NUMBER1 ?NUMBER2)
?NUMBER)
(or
(and
(equal ?NUMBER ?NUMBER1)
(lessThan ?NUMBER1 ?NUMBER2))
(and
(equal ?NUMBER ?NUMBER2)
(lessThan ?NUMBER2 ?NUMBER1))
(and
(equal ?NUMBER ?NUMBER1)
(equal ?NUMBER ?NUMBER2))))
- wenn id ist ein identitätsElement von function,
- dann für jeden inst gilt: wenn die Zahl Argument von function ist ein fall von class und inst ist ein fall von class , dann "function(id,inst)" ist gleich inst
.
(=>
(identityElement ?FUNCTION ?ID)
(forall
(?INST)
(=>
(and
(domain ?FUNCTION 1 ?CLASS)
(instance ?INST ?CLASS))
(equal
(AssignmentFn ?FUNCTION ?ID ?INST)
?INST))))
Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int1 ist kleinerAls int2 nicht oder int2 ist kleinerAls "(int1+1)" nicht.
(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT1 ?INT2)
(lessThan
?INT2
(SuccessorFn ?INT1)))))
Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int2 ist kleinerAls int1 nicht oder "(int1+2)" ist kleinerAls int2 nicht.
(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT2 ?INT1)
(lessThan
(PredecessorFn ?INT1)
?INT2))))
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)))))
- wenn superclass ist ein fall von paarweise disjunkte Kategorie ,
- dann für jeden class1,class2 gilt: wenn class1 ist ein fall von superclass und class2 ist ein fall von superclass , dann class1 ist gleich class2 oder class1 ist dijunkt von class2
.
(=>
(instance ?SUPERCLASS PairwiseDisjointClass)
(forall
(?CLASS1 ?CLASS2)
(=>
(and
(instance ?CLASS1 ?SUPERCLASS)
(instance ?CLASS2 ?SUPERCLASS))
(or
(equal ?CLASS1 ?CLASS2)
(disjoint ?CLASS1 ?CLASS2)))))
(=>
(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 "das ausgangsnullpunkt von arc" ist gleich node und "das terminalnullpunkt von arc" ist gleich node , dann arc ist ein fall von Graphschleife .
(=>
(and
(equal
(InitialNodeFn ?ARC)
?NODE)
(equal
(TerminalNodeFn ?ARC)
?NODE))
(instance ?ARC GraphLoop))
Wenn graph1 ist ein teilgraph von graph2 und element ist ein teil von graph1 , dann element ist ein teil von graph2 .
(=>
(and
(subGraph ?GRAPH1 ?GRAPH2)
(graphPart ?ELEMENT ?GRAPH1))
(graphPart ?ELEMENT ?GRAPH2))
- wenn
- "der wert von path" ist gleich sum
und - subpath ist ein teilgraph von path
und - arc1 ist ein teil von path
und - der wert von arc1 ist number1
und - für jeden arc2 gilt: wenn arc2 ist ein teil von path , dann arc2 ist ein teil von subpath oder arc2 ist gleich arc1
, - dann sum ist gleich "("der wert von subpath"+number1)"
.
(=>
(and
(equal
(PathWeightFn ?PATH)
?SUM)
(subGraph ?SUBPATH ?PATH)
(graphPart ?ARC1 ?PATH)
(arcWeight ?ARC1 ?NUMBER1)
(forall
(?ARC2)
(=>
(graphPart ?ARC2 ?PATH)
(or
(graphPart ?ARC2 ?SUBPATH)
(equal ?ARC2 ?ARC1)))))
(equal
?SUM
(AdditionFn
(PathWeightFn ?SUBPATH)
?NUMBER1)))
- wenn
- "der wert von path" ist gleich sum
und - arc1 ist ein teil von path
und - arc2 ist ein teil von path
und - der wert von arc1 ist number1
und - der wert von arc2 ist number2
und - für jeden arc3 gilt: wenn arc3 ist ein teil von path , dann arc3 ist gleich arc1 oder arc3 ist gleich arc2
, - dann "der wert von path" ist gleich "(number1+number2)"
.
(=>
(and
(equal
(PathWeightFn ?PATH)
?SUM)
(graphPart ?ARC1 ?PATH)
(graphPart ?ARC2 ?PATH)
(arcWeight ?ARC1 ?NUMBER1)
(arcWeight ?ARC2 ?NUMBER2)
(forall
(?ARC3)
(=>
(graphPart ?ARC3 ?PATH)
(or
(equal ?ARC3 ?ARC1)
(equal ?ARC3 ?ARC2)))))
(equal
(PathWeightFn ?PATH)
(AdditionFn ?NUMBER1 ?NUMBER2)))
- wenn "der Pfad der niedrigsten Kosten zwischen node1 und node2" ist gleich path und "der wert von path" ist gleich number ,
- dann für jeden path2 gilt: wenn path2 ist ein fall von "die menge von Pfaden zwischen node1 und node2" und "der wert von path2" ist gleich number2 , dann number2 ist grösserAlsOderGleich number1
.
(=>
(and
(equal
(MinimalWeightedPathFn ?NODE1 ?NODE2)
?PATH)
(equal
(PathWeightFn ?PATH)
?NUMBER))
(forall
(?PATH2)
(=>
(and
(instance
?PATH2
(GraphPathFn ?NODE1 ?NODE2))
(equal
(PathWeightFn ?PATH2)
?NUMBER2))
(greaterThanOrEqualTo ?NUMBER2 ?NUMBER1))))
- wenn "der Pfad der höchsten Kosten zwischen node1 und node2" ist gleich path und "der wert von path" ist gleich number ,
- dann für jeden path2 gilt: wenn path2 ist ein fall von "die menge von Pfaden zwischen node1 und node2" und "der wert von path2" ist gleich number2 , dann number2 ist kleinerAlsOderGleich number1
.
(=>
(and
(equal
(MaximalWeightedPathFn ?NODE1 ?NODE2)
?PATH)
(equal
(PathWeightFn ?PATH)
?NUMBER))
(forall
(?PATH2)
(=>
(and
(instance
?PATH2
(GraphPathFn ?NODE1 ?NODE2))
(equal
(PathWeightFn ?PATH2)
?NUMBER2))
(lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))
Wenn path ist ein teil von graph und graph ist ein fall von gerichtetes Graph nicht, dann "die menge von Pfaden zwischen node1 und node2" ist gleich path nur wenn "die menge von Pfaden zwischen node2 und node1" ist gleich path .
(=>
(and
(graphPart ?PATH ?GRAPH)
(not
(instance ?GRAPH DirectedGraph)))
(<=>
(equal
(GraphPathFn ?NODE1 ?NODE2)
?PATH)
(equal
(GraphPathFn ?NODE2 ?NODE1)
?PATH)))
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 "number unit(s)" ist gleich quant und unit ist eine teilkategorie von quanttype, dann quant ist ein fall von quanttype .
(=>
(and
(equal
(MeasureFn ?NUMBER ?UNIT)
?QUANT)
(subclass ?UNIT ?QUANTTYPE))
(instance ?QUANT ?QUANTTYPE))
(=>
(and
(instance ?REL RelationExtendedToQuantities)
(instance ?REL TernaryRelation)
(instance ?NUMBER1 RealNumber)
(instance ?NUMBER2 RealNumber)
(holds ?REL ?NUMBER1 ?NUMBER2 ?VALUE))
(forall
(?UNIT)
(=>
(instance ?UNIT UnitOfMeasure)
(holds
?REL
(MeasureFn ?NUMBER1 ?UNIT)
(MeasureFn ?NUMBER2 ?UNIT)
(MeasureFn ?VALUE ?UNIT)))))
(=>
(and
(instance ?REL RelationExtendedToQuantities)
(instance ?REL BinaryRelation)
(instance ?NUMBER1 RealNumber)
(instance ?NUMBER2 RealNumber)
(holds ?REL ?NUMBER1 ?NUMBER2))
(forall
(?UNIT)
(=>
(instance ?UNIT UnitOfMeasure)
(holds
?REL
(MeasureFn ?NUMBER1 ?UNIT)
(MeasureFn ?NUMBER2 ?UNIT)))))
quantity ist ein fall von "der zeitabstand von from nach to" nur wenn quantity ist grösserAlsOderGleich from und quantity ist kleinerAlsOderGleich to .
(<=>
(instance
?QUANTITY
(IntervalFn ?FROM ?TO))
(and
(greaterThanOrEqualTo ?QUANTITY ?FROM)
(lessThanOrEqualTo ?QUANTITY ?TO)))
Wenn number ist ein fall von reelle Zahl und unit ist ein fall von Masseinheit , dann "die grösse von "number unit(s)"" ist gleich number .
(=>
(and
(instance ?NUMBER RealNumber)
(instance ?UNIT UnitOfMeasure))
(equal
(MagnitudeFn
(MeasureFn ?NUMBER ?UNIT))
?NUMBER))
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))))
(=>
(larger ?OBJ1 ?OBJ2)
(forall
(?QUANT1 ?QUANT2)
(=>
(and
(measure
?OBJ1
(MeasureFn ?QUANT1 LengthMeasure))
(measure
?OBJ2
(MeasureFn ?QUANT2 LengthMeasure)))
(greaterThan ?QUANT1 ?QUANT2))))
Wenn point ist ein fall von Zeitpunkt und point ist gleich positive infinity nicht, dann point geschieht vor positive infinity .
(=>
(and
(instance ?POINT TimePoint)
(not
(equal ?POINT PositiveInfinity)))
(before ?POINT PositiveInfinity))
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 negative infinity geschieht vor point .
(=>
(and
(instance ?POINT TimePoint)
(not
(equal ?POINT NegativeInfinity)))
(before NegativeInfinity ?POINT))
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 situation hält während time1 und time2 ist ein teil von time1 , dann situation hält während time2 .
(=>
(and
(holdsDuring ?TIME1 ?SITUATION)
(temporalPart ?TIME2 ?TIME1))
(holdsDuring ?TIME2 ?SITUATION))
Wenn "rel(inst1,inst2) gilt " hält während interval und inst1 ist ein fall von körperlicher Gegenstand und inst2 ist ein fall von körperlicher Gegenstand , dann inst1 besteht während interval und inst2 besteht während interval .
(=>
(and
(holdsDuring
?INTERVAL
(holds ?REL ?INST1 ?INST2))
(instance ?INST1 Physical)
(instance ?INST2 Physical))
(and
(time ?INST1 ?INTERVAL)
(time ?INST2 ?INTERVAL)))
- wenn "der anfang von interval" ist gleich point ,
- dann für jeden otherpoint gilt: wenn otherpoint ist ein teil von interval und otherpoint ist gleich point nicht, dann point geschieht vor otherpoint
.
(=>
(equal
(BeginFn ?INTERVAL)
?POINT)
(forall
(?OTHERPOINT)
(=>
(and
(temporalPart ?OTHERPOINT ?INTERVAL)
(not
(equal ?OTHERPOINT ?POINT)))
(before ?POINT ?OTHERPOINT))))
- wenn "das ende von interval" ist gleich point ,
- dann für jeden otherpoint gilt: wenn otherpoint ist ein teil von interval und otherpoint ist gleich point nicht, dann otherpoint geschieht vor point
.
(=>
(equal
(EndFn ?INTERVAL)
?POINT)
(forall
(?OTHERPOINT)
(=>
(and
(temporalPart ?OTHERPOINT ?INTERVAL)
(not
(equal ?OTHERPOINT ?POINT)))
(before ?OTHERPOINT ?POINT))))
interval1 beginnt interval2 nur wenn "der anfang von interval1" ist gleich "der anfang von interval2" und "das ende von interval1" geschieht vor "das ende von interval2" .
(<=>
(starts ?INTERVAL1 ?INTERVAL2)
(and
(equal
(BeginFn ?INTERVAL1)
(BeginFn ?INTERVAL2))
(before
(EndFn ?INTERVAL1)
(EndFn ?INTERVAL2))))
interval1 beendet interval2 nur wenn "der anfang von interval2" geschieht vor "der anfang von interval1" und "das ende von interval2" ist gleich "das ende von interval1" .
(<=>
(finishes ?INTERVAL1 ?INTERVAL2)
(and
(before
(BeginFn ?INTERVAL2)
(BeginFn ?INTERVAL1))
(equal
(EndFn ?INTERVAL2)
(EndFn ?INTERVAL1))))
- 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))))))
point2 ist zwischen point1 und point3 nur wenn point1 geschieht vor point2 und point2 geschieht vor point3 .
(<=>
(temporallyBetween ?POINT1 ?POINT2 ?POINT3)
(and
(before ?POINT1 ?POINT2)
(before ?POINT2 ?POINT3)))
point2 ist zwischen oder gleichzeitig mit point1 und point3 nur wenn point1 geschieht vor oder gleichzeitig mit point2 und point2 geschieht vor oder gleichzeitig mit point3 .
(<=>
(temporallyBetweenOrEqual ?POINT1 ?POINT2 ?POINT3)
(and
(beforeOrEqual ?POINT1 ?POINT2)
(beforeOrEqual ?POINT2 ?POINT3)))
phys besteht während time und time ist ein fall von Zeitpunkt nur wenn time ist zwischen oder gleichzeitig mit "der anfang von "die zeit des Bestehens von phys"" und "das ende von "die zeit des Bestehens von phys"".
(<=>
(and
(time ?PHYS ?TIME)
(instance ?TIME TimePoint))
(temporallyBetweenOrEqual
(BeginFn
(WhenFn ?PHYS))
?TIME
(EndFn
(WhenFn ?PHYS))))
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 rel ist ein fall von räumliche Relation und rel(obj1,obj2) gilt , dann "die zeit des Bestehens von obj2" deckt sich mit "die zeit des Bestehens von obj1" .
(=>
(and
(instance ?REL SpatialRelation)
(holds ?REL ?OBJ1 ?OBJ2))
(overlapsTemporally
(WhenFn ?OBJ1)
(WhenFn ?OBJ2)))
Wenn interval1 geschieht während interval2 , dann "das ende von interval1" geschieht vor "das ende von interval2" und "der anfang von interval2" geschieht vor "der anfang von interval1" .
(=>
(during ?INTERVAL1 ?INTERVAL2)
(and
(before
(EndFn ?INTERVAL1)
(EndFn ?INTERVAL2))
(before
(BeginFn ?INTERVAL2)
(BeginFn ?INTERVAL1))))
Wenn "der anfang von interval1" ist gleich "der anfang von interval2" und "das ende von interval1" ist gleich "das ende von interval2" , dann interval1 ist gleich interval2 .
(=>
(and
(equal
(BeginFn ?INTERVAL1)
(BeginFn ?INTERVAL2))
(equal
(EndFn ?INTERVAL1)
(EndFn ?INTERVAL2)))
(equal ?INTERVAL1 ?INTERVAL2))
Wenn "abstand zwischen point1 und point2" ist gleich interval , dann "der anfang von interval" ist gleich point1 und "das ende von interval" ist gleich point2 .
(=>
(equal
(TimeIntervalFn ?POINT1 ?POINT2)
?INTERVAL)
(and
(equal
(BeginFn ?INTERVAL)
?POINT1)
(equal
(EndFn ?INTERVAL)
?POINT2)))
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 obj ist ein hilfmittel für proc und "das mass von obj ist quant1 " hält während "direkt vor "die zeit des Bestehens von proc"" und "das mass von obj ist quant2 " hält während "sofort nach "die zeit des Bestehens von proc"" , dann quant1 ist grösserAls quant2 .
(=>
(and
(resource ?PROC ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT2)))
(greaterThan ?QUANT1 ?QUANT2))
Wenn day1 ist ein fall von "der tag number1" und day2 ist ein fall von "der tag number2" und "(number2-number1)" ist gleich , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance
?DAY1
(DayFn ?NUMBER1 ?MONTH))
(instance
?DAY2
(DayFn ?NUMBER2 ?MONTH))
(equal
(SubtractionFn ?NUMBER2 ?NUMBER1)
1))
(meetsTemporally ?DAY1 ?DAY2))
Wenn hour1 ist ein fall von "die stunde number1" und hour2 ist ein fall von "die stunde number2" und "(number2-number1)" ist gleich , dann hour1 schliesst hour2 zeitlich an.
(=>
(and
(instance
?HOUR1
(HourFn ?NUMBER1 ?DAY))
(instance
?HOUR2
(HourFn ?NUMBER2 ?DAY))
(equal
(SubtractionFn ?NUMBER2 ?NUMBER1)
1))
(meetsTemporally ?HOUR1 ?HOUR2))
Wenn minute1 ist ein fall von "die minute number1" und minute2 ist ein fall von "die minute number2" und "(number2-number1)" ist gleich , dann minute1 schliesst minute2 zeitlich an.
(=>
(and
(instance
?MINUTE1
(MinuteFn ?NUMBER1 ?HOUR))
(instance
?MINUTE2
(MinuteFn ?NUMBER2 ?HOUR))
(equal
(SubtractionFn ?NUMBER2 ?NUMBER1)
1))
(meetsTemporally ?MINUTE1 ?MINUTE2))
Wenn second1 ist ein fall von "die sekund number1" und second2 ist ein fall von "die sekund number2" und "(number2-number1)" ist gleich , dann second1 schliesst second2 zeitlich an.
(=>
(and
(instance
?SECOND1
(SecondFn ?NUMBER1 ?MINUTE))
(instance
?SECOND2
(SecondFn ?NUMBER2 ?MINUTE))
(equal
(SubtractionFn ?NUMBER2 ?NUMBER1)
1))
(meetsTemporally ?SECOND1 ?SECOND2))
Wenn year1 ist ein fall von Jahr und year2 ist ein fall von Jahr und "(year2-year1)" ist gleich , dann year1 schliesst year2 zeitlich an.
(=>
(and
(instance ?YEAR1 Year)
(instance ?YEAR2 Year)
(equal
(SubtractionFn ?YEAR2 ?YEAR1)
1))
(meetsTemporally ?YEAR1 ?YEAR2))
Wenn leap ist ein fall von Schaltjahr und leap ist gleich "number Jahr(s)" , dann - "number betrag " ist gleich und "number betrag " ist gleich nicht
oder - "number betrag " ist gleich
.
(=>
(and
(instance ?LEAP LeapYear)
(equal
?LEAP
(MeasureFn ?NUMBER Year)))
(or
(and
(equal
(RemainderFn ?NUMBER 4)
0)
(not
(equal
(RemainderFn ?NUMBER 100)
0)))
(equal
(RemainderFn ?NUMBER 400)
0)))
Wenn month1 ist gleich "der monat Januar" und month2 ist gleich "der monat Februar" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn January ?YEAR))
(equal
?MONTH2
(MonthFn February ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn "der monat Februar" ist gleich month und year ist ein fall von Schaltjahr nicht, dann dauer von month ist " day duration(s)" .
(=>
(and
(equal
(MonthFn February ?YEAR)
?MONTH)
(not
(instance ?YEAR LeapYear)))
(duration
?MONTH
(MeasureFn 28 DayDuration)))
Wenn "der monat Februar" ist gleich month und year ist ein fall von Schaltjahr , dann dauer von month ist " day duration(s)" .
(=>
(and
(equal
(MonthFn February ?YEAR)
?MONTH)
(instance ?YEAR LeapYear))
(duration
?MONTH
(MeasureFn 29 DayDuration)))
Wenn month1 ist gleich "der monat Februar" und month2 ist gleich "der monat März" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn February ?YEAR))
(equal
?MONTH2
(MonthFn March ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat März" und month2 ist gleich "der monat April" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn March ?YEAR))
(equal
?MONTH2
(MonthFn April ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat April" und month2 ist gleich "der monat Mai" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn April ?YEAR))
(equal
?MONTH2
(MonthFn May ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat Mai" und month2 ist gleich "der monat Juni" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn May ?YEAR))
(equal
?MONTH2
(MonthFn June ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat Juni" und month2 ist gleich "der monat Juli" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn June ?YEAR))
(equal
?MONTH2
(MonthFn July ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat Juli" und month2 ist gleich "der monat August" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn July ?YEAR))
(equal
?MONTH2
(MonthFn August ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat August" und month2 ist gleich "der monat September" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn August ?YEAR))
(equal
?MONTH2
(MonthFn September ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat September" und month2 ist gleich "der monat Oktober" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn September ?YEAR))
(equal
?MONTH2
(MonthFn October ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat Oktober" und month2 ist gleich "der monat November" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn October ?YEAR))
(equal
?MONTH2
(MonthFn November ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat November" und month2 ist gleich "der monat Dezember" , dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn November ?YEAR))
(equal
?MONTH2
(MonthFn December ?YEAR)))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn month1 ist gleich "der monat Dezember" und month2 ist gleich "der monat Januar" und year1 schliesst year2 zeitlich an, dann month1 schliesst month2 zeitlich an.
(=>
(and
(equal
?MONTH1
(MonthFn December ?YEAR1))
(equal
?MONTH2
(MonthFn January ?YEAR2))
(meetsTemporally ?YEAR1 ?YEAR2))
(meetsTemporally ?MONTH1 ?MONTH2))
Wenn day1 ist ein fall von Montag und day2 ist ein fall von Dienstag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Monday)
(instance ?DAY2 Tuesday)
(instance ?WEEK Week)
(temporalPart ?DAY1 ?WEEK)
(temporalPart ?DAY2 ?WEEK))
(meetsTemporally ?DAY1 ?DAY2))
Wenn day1 ist ein fall von Dienstag und day2 ist ein fall von Mittwoch und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Tuesday)
(instance ?DAY2 Wednesday)
(instance ?WEEK Week)
(temporalPart ?DAY1 ?WEEK)
(temporalPart ?DAY2 ?WEEK))
(meetsTemporally ?DAY1 ?DAY2))
Wenn day1 ist ein fall von Mittwoch und day2 ist ein fall von Donnerstag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Wednesday)
(instance ?DAY2 Thursday)
(instance ?WEEK Week)
(temporalPart ?DAY1 ?WEEK)
(temporalPart ?DAY2 ?WEEK))
(meetsTemporally ?DAY1 ?DAY2))
Wenn day1 ist ein fall von Donnerstag und day2 ist ein fall von Freitag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Thursday)
(instance ?DAY2 Friday)
(instance ?WEEK Week)
(temporalPart ?DAY1 ?WEEK)
(temporalPart ?DAY2 ?WEEK))
(meetsTemporally ?DAY1 ?DAY2))
Wenn day1 ist ein fall von Freitag und day2 ist ein fall von Samstag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Friday)
(instance ?DAY2 Saturday)
(instance ?WEEK Week)
(temporalPart ?DAY1 ?WEEK)
(temporalPart ?DAY2 ?WEEK))
(meetsTemporally ?DAY1 ?DAY2))
Wenn day1 ist ein fall von Samstag und day2 ist ein fall von Sonntag und week ist ein fall von Woche und day1 ist ein teil von week und day2 ist ein teil von week , dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Saturday)
(instance ?DAY2 Sunday)
(instance ?WEEK Week)
(temporalPart ?DAY1 ?WEEK)
(temporalPart ?DAY2 ?WEEK))
(meetsTemporally ?DAY1 ?DAY2))
Wenn day1 ist ein fall von Sonntag und day2 ist ein fall von Montag und week1 ist ein fall von Woche und week2 ist ein fall von Woche und day1 ist ein teil von week1 und day2 ist ein teil von week2 und week1 schliesst week2 zeitlich an, dann day1 schliesst day2 zeitlich an.
(=>
(and
(instance ?DAY1 Sunday)
(instance ?DAY2 Monday)
(instance ?WEEK1 Week)
(instance ?WEEK2 Week)
(temporalPart ?DAY1 ?WEEK1)
(temporalPart ?DAY2 ?WEEK2)
(meetsTemporally ?WEEK1 ?WEEK2))
(meetsTemporally ?DAY1 ?DAY2))
- 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 für jeden time1,time2 gilt: wenn time1 ist ein fall von class und time2 ist ein fall von class und time1 ist gleich time2 nicht, dann time1 schliesst time2 zeitlich an oder time2 schliesst time1 zeitlich an oder time1 geschieht früh als time2 oder time2 geschieht früh als time1
.
(=>
(equal
(TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
?CLASS)
(forall
(?TIME1 ?TIME2)
(=>
(and
(instance ?TIME1 ?CLASS)
(instance ?TIME2 ?CLASS)
(not
(equal ?TIME1 ?TIME2)))
(or
(meetsTemporally ?TIME1 ?TIME2)
(meetsTemporally ?TIME2 ?TIME1)
(earlier ?TIME1 ?TIME2)
(earlier ?TIME2 ?TIME1)))))
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))))))
Wenn month ist ein fall von Monat und dauer von month ist "number day duration(s)" , dann "die Zahl Fällen in "Aufspaltung von month auf ? Tags"" ist gleich number .
(=>
(and
(instance ?MONTH Month)
(duration
?MONTH
(MeasureFn ?NUMBER DayDuration)))
(equal
(CardinalityFn
(TemporalCompositionFn ?MONTH Day))
?NUMBER))
obj1 schleisst obj2 und obj3 an nur wenn obj1 wird an obj2 angeschlossen und obj1 wird an obj3 angeschlossen und obj2 wird an obj3 nicht angeschlossen.
(<=>
(connects ?OBJ1 ?OBJ2 ?OBJ3)
(and
(connected ?OBJ1 ?OBJ2)
(connected ?OBJ1 ?OBJ3)
(not
(connected ?OBJ2 ?OBJ3))))
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 obj1 ist ein Mitglied von coll und obj2 ist ein Mitglied von coll und obj1 ist gleich obj2 nicht, dann obj1 deckt sich mit obj2 räumlich nicht.
(=>
(and
(member ?OBJ1 ?COLL)
(member ?OBJ2 ?COLL)
(not
(equal ?OBJ1 ?OBJ2)))
(not
(overlapsSpatially ?OBJ1 ?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 die unterseite von object ist bottom und part ist ein teil von object und part wird an bottom nicht angeschlossen, dann part ist above hinsichlich bottom .
(=>
(and
(bottom ?BOTTOM ?OBJECT)
(part ?PART ?OBJECT)
(not
(connected ?PART ?BOTTOM)))
(orientation ?PART ?BOTTOM Above))
Wenn die oberseite von object ist top und part ist ein teil von object und part wird an top nicht angeschlossen, dann part ist below hinsichlich top .
(=>
(and
(top ?TOP ?OBJECT)
(part ?PART ?OBJECT)
(not
(connected ?PART ?TOP)))
(orientation ?PART ?TOP Below))
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))))
Wenn die höhe von object ist height und die oberseite von object ist top und die unterseite von object ist bottom, dann der abstand zwischen top und bottom ist height.
(=>
(and
(height ?OBJECT ?HEIGHT)
(top ?TOP ?OBJECT)
(bottom ?BOTTOM ?OBJECT))
(distance ?TOP ?BOTTOM ?HEIGHT))
Wenn obj3 ist gleich "der durchschnitt von den teilen von obj1 und obj2" , dann für jeden part gilt: part ist ein teil von obj3 nur wenn part ist ein teil von obj1 und part ist ein teil von obj2 .
(=>
(equal
?OBJ3
(MereologicalProductFn ?OBJ1 ?OBJ2))
(forall
(?PART)
(<=>
(part ?PART ?OBJ3)
(and
(part ?PART ?OBJ1)
(part ?PART ?OBJ2)))))
Wenn obj3 ist gleich "die differenz zwischen den Teilen von obj1 und obj2" , dann für jeden part gilt: part ist ein teil von obj3 nur wenn part ist ein teil von obj1 und part ist ein teil von obj2 nicht.
(=>
(equal
?OBJ3
(MereologicalDifferenceFn ?OBJ1 ?OBJ2))
(forall
(?PART)
(<=>
(part ?PART ?OBJ3)
(and
(part ?PART ?OBJ1)
(not
(part ?PART ?OBJ2))))))
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 loch in obj und hole2 ist ein loch in obj ,
- dann für jeden hole3 gilt: wenn hole3 ist ein teil von "die vereinigung von den teilen von hole1 und hole2" , dann hole3 ist ein loch in obj
.
(=>
(and
(hole ?HOLE1 ?OBJ)
(hole ?HOLE2 ?OBJ))
(forall
(?HOLE3)
(=>
(part
?HOLE3
(MereologicalSumFn ?HOLE1 ?HOLE2))
(hole ?HOLE3 ?OBJ))))
Wenn hole ist ein loch in obj1 und obj1 ist ein teil von obj2 , dann hole deckt sich mit obj2 räumlich oder hole ist ein loch in obj2 .
(=>
(and
(hole ?HOLE ?OBJ1)
(part ?OBJ1 ?OBJ2))
(or
(overlapsSpatially ?HOLE ?OBJ2)
(hole ?HOLE ?OBJ2)))
Wenn hole1 ist ein loch in obj1 und hole2 ist ein loch in obj2 und hole1 deckt sich mit hole2 räumlich , dann obj1 deckt sich mit obj2 räumlich .
(=>
(and
(hole ?HOLE1 ?OBJ1)
(hole ?HOLE2 ?OBJ2)
(overlapsSpatially ?HOLE1 ?HOLE2))
(overlapsSpatially ?OBJ1 ?OBJ2))
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)))))
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 füllt hole und fillable ist ein attribut von obj2 , dann obj1 deckt sich mit obj2 räumlich nicht.
(=>
(and
(fills ?OBJ1 ?HOLE)
(attribute ?OBJ2 Fillable))
(not
(overlapsSpatially ?OBJ1 ?OBJ2)))
Wenn obj1 füllt hole richtig und obj2 wird an obj1 angeschlossen, dann hole wird an obj2 angeschlossen.
(=>
(and
(properlyFills ?OBJ1 ?HOLE)
(connected ?OBJ2 ?OBJ1))
(connected ?HOLE ?OBJ2))
Wenn obj füllt hole1 und hole2 ist ein korrektes teil von hole1 , dann obj füllt hole2 vollständig.
(=>
(and
(fills ?OBJ ?HOLE1)
(properPart ?HOLE2 ?HOLE1))
(completelyFills ?OBJ ?HOLE2))
Wenn obj1 füllt hole und obj2 ist ein korrektes teil von obj1 , dann obj2 füllt hole richtig.
(=>
(and
(fills ?OBJ1 ?HOLE)
(properPart ?OBJ2 ?OBJ1))
(properlyFills ?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 proc ist ein fall von biologischer Prozess und org erfährt proc , dann org ist ein fall von Organismus .
(=>
(and
(instance ?PROC BiologicalProcess)
(experiencer ?PROC ?ORG))
(instance ?ORG Organism))
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 agent erfährt death , dann "dead ist ein attribut von agent " hält während "nach "die zeit des Bestehens von death"" .
(=>
(and
(instance ?DEATH Death)
(experiencer ?DEATH ?AGENT))
(holdsDuring
(FutureFn
(WhenFn ?DEATH))
(attribute ?AGENT Dead)))
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 act ist ein fall von Einnehmen und food ist ein patient von act , dann food ist ein fall von Nahrung .
(=>
(and
(instance ?ACT Ingesting)
(patient ?ACT ?FOOD))
(instance ?FOOD Food))
Wenn act ist ein fall von Essen und food ist ein patient von act , dann solid ist ein attribut von food .
(=>
(and
(instance ?ACT Eating)
(patient ?ACT ?FOOD))
(attribute ?FOOD Solid))
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 und rep ist der agent von parent und child ist ein resultat von rep , dann parent ist das elterntiel von child .
(=>
(and
(instance ?REP Replication)
(agent ?REP ?PARENT)
(result ?REP ?CHILD))
(parent ?CHILD ?PARENT))
Wenn 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))))
inj ist ein fall von Verletzen nur wenn inj ist ein fall von Beschädigen und Organismus ist ein patient von inj .
(<=>
(instance ?INJ Injuring)
(and
(instance ?INJ Damaging)
(patient ?INJ Organism)))
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 join ist ein fall von gehen zu einer Organisation und org ist ein fall von Organisation und join ist der agent von org und person ist ein patient von join , dann "person ist ein Mitglied von org " hält während "sofort nach "die zeit des Bestehens von join"" .
(=>
(and
(instance ?JOIN JoiningAnOrganization)
(instance ?ORG Organization)
(agent ?JOIN ?ORG)
(patient ?JOIN ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?JOIN))
(member ?PERSON ?ORG)))
Wenn leave ist ein fall von verlassen eine Organisation und org ist ein fall von Organisation und leave ist der agent von org und person ist ein patient von leave , dann "person ist ein Mitglied von org nicht" hält während "sofort nach "die zeit des Bestehens von leave"" .
(=>
(and
(instance ?LEAVE LeavingAnOrganization)
(instance ?ORG Organization)
(agent ?LEAVE ?ORG)
(patient ?LEAVE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?LEAVE))
(not
(member ?PERSON ?ORG))))
Wenn grad ist ein fall von Abschluss und grad ist der agent von org und person ist ein patient von grad , dann org ist ein fall von pädagogishe Organisation .
(=>
(and
(instance ?GRAD Graduation)
(agent ?GRAD ?ORG)
(patient ?GRAD ?PERSON))
(instance ?ORG EducationalOrganization))
Wenn mat ist ein fall von Immatrikulation und mat ist der agent von org und person ist ein patient von mat , dann org ist ein fall von pädagogishe Organisation .
(=>
(and
(instance ?MAT Matriculation)
(agent ?MAT ?ORG)
(patient ?MAT ?PERSON))
(instance ?ORG EducationalOrganization))
Wenn hire ist ein fall von Einstellen und org ist ein fall von Organisation und hire ist der agent von org und person ist ein patient von hire , dann "org beschäftigt person " hält während "sofort nach "die zeit des Bestehens von hire"" .
(=>
(and
(instance ?HIRE Hiring)
(instance ?ORG Organization)
(agent ?HIRE ?ORG)
(patient ?HIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HIRE))
(employs ?ORG ?PERSON)))
Wenn fire ist ein fall von Beenden Beschäftigung und org ist ein fall von Organisation und fire ist der agent von org und person ist ein patient von fire , dann "org beschäftigt person nicht" hält während "sofort nach "die zeit des Bestehens von fire"" .
(=>
(and
(instance ?FIRE TerminatingEmployment)
(instance ?ORG Organization)
(agent ?FIRE ?ORG)
(patient ?FIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FIRE))
(not
(employs ?ORG ?PERSON))))
Wenn proc ist ein fall von politischer Prozess , dann es gibt ein Regierung gov der proc ist der agent von gov oder gov ist ein patient von proc .
(=>
(instance ?PROC PoliticalProcess)
(exists
(?GOV)
(and
(instance ?GOV Government)
(or
(agent ?PROC ?GOV)
(patient ?PROC ?GOV)))))
Wenn 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 motion ist ein fall von Bewegung und obj ist ein patient von motion und motion beginnet an place , dann "obj befindet sich an " hält während "direkt vor "die zeit des Bestehens von motion"" .
(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(origin ?MOTION ?PLACE))
(holdsDuring
(ImmediatePastFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))
Wenn motion ist ein fall von Bewegung und obj ist ein patient von motion und motion endet an place , dann "obj befindet sich an " hält während "sofort nach "die zeit des Bestehens von motion"" .
(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(destination ?MOTION ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))
- 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 transfer ist ein fall von Übertragung und transfer ist der agent von agent und patient ist ein patient von transfer , dann agent ist gleich patient nicht.
(=>
(and
(instance ?TRANSFER Transfer)
(agent ?TRANSFER ?AGENT)
(patient ?TRANSFER ?PATIENT))
(not
(equal ?AGENT ?PATIENT)))
Wenn remove ist ein fall von Entfernen und remove beginnet an place und obj ist ein patient von remove , dann "obj befindet sich an " hält während "direkt vor "die zeit des Bestehens von remove"" und "obj befindet sich an nicht" hält während "sofort nach "die zeit des Bestehens von remove"" .
(=>
(and
(instance ?REMOVE Removing)
(origin ?REMOVE ?PLACE)
(patient ?REMOVE ?OBJ))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?REMOVE))
(located ?OBJ ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?REMOVE))
(not
(located ?OBJ ?PLACE)))))
Wenn put ist ein fall von Setzen und put endet an place und obj ist ein patient von put , dann "obj befindet sich an nicht" hält während "direkt vor "die zeit des Bestehens von put"" und "obj befindet sich an " hält während "sofort nach "die zeit des Bestehens von put"" .
(=>
(and
(instance ?PUT Putting)
(destination ?PUT ?PLACE)
(patient ?PUT ?OBJ))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?PUT))
(not
(located ?OBJ ?PLACE)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PUT))
(located ?OBJ ?PLACE))))
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 touch ist ein fall von Berühren und touch ist der agent von obj1 und obj2 ist ein patient von touch , dann "obj1 wird an obj2 angeschlossen" hält während "sofort nach "die zeit des Bestehens von touch"" .
(=>
(and
(instance ?TOUCH Touching)
(agent ?TOUCH ?OBJ1)
(patient ?TOUCH ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?TOUCH))
(connected ?OBJ1 ?OBJ2)))
Wenn 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 change ist ein fall von Änderung des Besitzes und obj ist ein patient von change und "agent1 besitzt obj " hält während "direkt vor "die zeit des Bestehens von change"" und "agent2 besitzt obj " hält während "sofort nach "die zeit des Bestehens von change"" , dann agent1 ist gleich agent2 nicht.
(=>
(and
(instance ?CHANGE ChangeOfPossession)
(patient ?CHANGE ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(possesses ?AGENT1 ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(possesses ?AGENT2 ?OBJ)))
(not
(equal ?AGENT1 ?AGENT2)))
Wenn change ist ein fall von Änderung des Besitzes und change beginnet an agent1 und change endet an agent2 und agent2 ist ein fall von Agent und obj ist ein patient von change , dann "agent1 besitzt obj " hält während "direkt vor "die zeit des Bestehens von change"" und "agent2 besitzt obj " hält während "sofort nach "die zeit des Bestehens von change"" .
(=>
(and
(instance ?CHANGE ChangeOfPossession)
(origin ?CHANGE ?AGENT1)
(destination ?CHANGE ?AGENT2)
(instance ?AGENT2 Agent)
(patient ?CHANGE ?OBJ))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(possesses ?AGENT1 ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(possesses ?AGENT2 ?OBJ))))
Wenn give ist ein fall von Geben und give ist der agent von agent1 und give endet an agent2 und agent2 ist ein fall von Agent und obj ist ein patient von give , dann es gibt ein Erhalten get der get ist der agent von agent2 und get beginnet an agent1 und obj ist ein patient von get .
(=>
(and
(instance ?GIVE Giving)
(agent ?GIVE ?AGENT1)
(destination ?GIVE ?AGENT2)
(instance ?AGENT2 Agent)
(patient ?GIVE ?OBJ))
(exists
(?GET)
(and
(instance ?GET Getting)
(agent ?GET ?AGENT2)
(origin ?GET ?AGENT1)
(patient ?GET ?OBJ))))
Wenn give ist ein fall von Geben und give ist der agent von agent , dann give beginnet an agent .
(=>
(and
(instance ?GIVE Giving)
(agent ?GIVE ?AGENT))
(origin ?GIVE ?AGENT))
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 Erhalten und get ist der agent von agent , dann get endet an agent .
(=>
(and
(instance ?GET Getting)
(agent ?GET ?AGENT))
(destination ?GET ?AGENT))
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))))
Wenn buy ist ein fall von Kaufen und buy ist der agent von agent , dann buy endet an agent .
(=>
(and
(instance ?BUY Buying)
(agent ?BUY ?AGENT))
(destination ?BUY ?AGENT))
Es gibt ein Kaufen buy der buy ist der agent von agent1 und buy beginnet an agent2 und object ist ein patient von buy nur wenn es gibt ein Verkaufen sell der sell ist der agent von agent2 und sell endet an agent1 und object ist ein patient von sell .
(<=>
(exists
(?BUY)
(and
(instance ?BUY Buying)
(agent ?BUY ?AGENT1)
(origin ?BUY ?AGENT2)
(patient ?BUY ?OBJECT)))
(exists
(?SELL)
(and
(instance ?SELL Selling)
(agent ?SELL ?AGENT2)
(destination ?SELL ?AGENT1)
(patient ?SELL ?OBJECT))))
Wenn sell ist ein fall von Verkaufen und sell ist der agent von agent , dann sell beginnet an agent .
(=>
(and
(instance ?SELL Selling)
(agent ?SELL ?AGENT))
(origin ?SELL ?AGENT))
Wenn learn ist ein fall von Lernen und learn ist der agent von agent , dann agent ist ein fall von kognitiver Agent .
(=>
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT))
(instance ?AGENT CognitiveAgent))
Wenn "es gibt ein Lernen learn der learn ist der agent von agent und prop ist ein patient von learn " hält während time , dann "agent glaubt , dass prop" hält während "sofort nach time" .
(=>
(holdsDuring
?TIME
(exists
(?LEARN)
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT)
(patient ?LEARN ?PROP))))
(holdsDuring
(ImmediateFutureFn ?TIME)
(believes ?AGENT ?PROP)))
Wenn 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 confine ist ein fall von Begrenzen und person ist ein patient von confine , dann person wünscht "person ist ein patient von confine " nicht.
(=>
(and
(instance ?CONFINE Confining)
(patient ?CONFINE ?PERSON))
(not
(desires
?PERSON
(patient ?CONFINE ?PERSON))))
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)))))))
Wenn kill ist ein fall von Tötung und kill ist der agent von agent und patient ist ein patient von kill , dann agent ist ein fall von Organismus und patient ist ein fall von Organismus .
(=>
(and
(instance ?KILL Killing)
(agent ?KILL ?AGENT)
(patient ?KILL ?PATIENT))
(and
(instance ?AGENT Organism)
(instance ?PATIENT Organism)))
Wenn kill ist ein fall von Tötung und patient ist ein patient von kill , dann "living ist ein attribut von patient " hält während "direkt vor "die zeit des Bestehens von kill"" und "dead ist ein attribut von patient " hält während "nach "die zeit des Bestehens von kill"" .
(=>
(and
(instance ?KILL Killing)
(patient ?KILL ?PATIENT))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?KILL))
(attribute ?PATIENT Living))
(holdsDuring
(FutureFn
(WhenFn ?KILL))
(attribute ?PATIENT Dead))))
Wenn poke ist ein fall von Stossen und poke ist der agent von agent und obj ist ein patient von poke und inst ist ein instrument für poke , dann "inst schleisst agent und obj an" hält während "die zeit des Bestehens von poke" .
(=>
(and
(instance ?POKE Poking)
(agent ?POKE ?AGENT)
(patient ?POKE ?OBJ)
(instrument ?POKE ?INST))
(holdsDuring
(WhenFn ?POKE)
(connects ?INST ?AGENT ?OBJ)))
Wenn attach ist ein fall von Befestigung und obj1 ist ein patient von attach und obj2 ist ein patient von attach , dann "obj1 wird an obj2 nicht angeschlossen" hält während "direkt vor "die zeit des Bestehens von attach"" und "obj1 wird an obj2 angeschlossen" hält während "sofort nach "die zeit des Bestehens von attach"" .
(=>
(and
(instance ?ATTACH Attaching)
(patient ?ATTACH ?OBJ1)
(patient ?ATTACH ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ATTACH))
(not
(connected ?OBJ1 ?OBJ2)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ATTACH))
(connected ?OBJ1 ?OBJ2))))
Wenn detach ist ein fall von Abtrennen und obj1 ist ein patient von detach und obj2 ist ein patient von detach , dann "obj1 wird an obj2 angeschlossen" hält während "direkt vor "die zeit des Bestehens von detach"" und "obj1 wird an obj2 nicht angeschlossen" hält während "sofort nach "die zeit des Bestehens von detach"" .
(=>
(and
(instance ?DETACH Detaching)
(patient ?DETACH ?OBJ1)
(patient ?DETACH ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?DETACH))
(connected ?OBJ1 ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DETACH))
(not
(connected ?OBJ1 ?OBJ2)))))
combine ist ein fall von Kombinieren und obj1 ist ein hilfmittel für combine und obj2 ist ein resultat von combine nur wenn "obj1 ist ein teil von obj2 nicht" hält während "direkt vor "die zeit des Bestehens von combine"" und "obj1 ist ein teil von obj2 " hält während "sofort nach "die zeit des Bestehens von combine"" .
(<=>
(and
(instance ?COMBINE Combining)
(resource ?COMBINE ?OBJ1)
(result ?COMBINE ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?COMBINE))
(not
(part ?OBJ1 ?OBJ2)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COMBINE))
(part ?OBJ1 ?OBJ2))))
Wenn , dann stuff ist ein fall von reine Substanz .
(=>
(and
(instance ?PROC ChemicalProcess)
(or
(resource ?PROC ?STUFF)
(result ?PROC ?STUFF)))
(instance ?STUFF PureSubstance))
Wenn substance1 ist ein hilfmittel für proc und substance2 ist ein resultat von proc und substance1 ist ein fall von elementare Substanz und substance2 ist ein fall von Verbindung , dann proc ist ein fall von chemische Synthese .
(=>
(and
(resource ?PROC ?SUBSTANCE1)
(result ?PROC ?SUBSTANCE2)
(instance ?SUBSTANCE1 ElementalSubstance)
(instance ?SUBSTANCE2 CompoundSubstance))
(instance ?PROC ChemicalSynthesis))
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 substance1 ist ein hilfmittel für proc und substance2 ist ein resultat von proc und substance1 ist ein fall von Verbindung und substance2 ist ein fall von elementare Substanz , dann proc ist ein fall von chemische Aufspaltung .
(=>
(and
(resource ?PROC ?SUBSTANCE1)
(result ?PROC ?SUBSTANCE2)
(instance ?SUBSTANCE1 CompoundSubstance)
(instance ?SUBSTANCE2 ElementalSubstance))
(instance ?PROC ChemicalDecomposition))
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 und obj ist ein patient von wet , dann "wet ist ein attribut von obj oder damp ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von wet"" .
(=>
(and
(instance ?WET Wetting)
(patient ?WET ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?WET))
(or
(attribute ?OBJ Wet)
(attribute ?OBJ Damp))))
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 dry ist ein fall von Trocknen und obj ist ein patient von dry , dann "dry ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von dry"" .
(=>
(and
(instance ?DRY Drying)
(patient ?DRY ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DRY))
(attribute ?OBJ Dry)))
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 pub ist ein fall von Publikation und text ist ein patient von pub , dann text ist eine teilkategorie von Text.
(=>
(and
(instance ?PUB Publication)
(patient ?PUB ?TEXT))
(subclass ?TEXT Text))
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 search ist ein fall von Suchen und search ist der agent von agent und entity ist ein patient von search , dann agent ist an entity interessiert .
(=>
(and
(instance ?SEARCH Searching)
(agent ?SEARCH ?AGENT)
(patient ?SEARCH ?ENTITY))
(inScopeOfInterest ?AGENT ?ENTITY))
Wenn pursue ist ein fall von Verfolgen und pursue ist der agent von agent und obj ist ein patient von pursue , dann "agent wünscht obj " hält während pursue .
(=>
(and
(instance ?PURSUE Pursuing)
(agent ?PURSUE ?AGENT)
(patient ?PURSUE ?OBJ))
(holdsDuring
?PURSUE
(wants ?AGENT ?OBJ)))
Wenn pursue ist ein fall von Verfolgen und pursue ist der agent von agent und obj ist ein patient von pursue , dann "agent besitzt obj nicht" hält während pursue .
(=>
(and
(instance ?PURSUE Pursuing)
(agent ?PURSUE ?AGENT)
(patient ?PURSUE ?OBJ))
(holdsDuring
?PURSUE
(not
(possesses ?AGENT ?OBJ))))
Wenn investigate ist ein fall von Untersuchen und prop ist ein patient von investigate , dann prop ist ein fall von Formel .
(=>
(and
(instance ?INVESTIGATE Investigating)
(patient ?INVESTIGATE ?PROP))
(instance ?PROP Formula))
Wenn investigate ist ein fall von Untersuchen und investigate ist der agent von agent und prop ist ein patient von investigate , dann "agent kennt prop nicht" hält während "die zeit des Bestehens von investigate" .
(=>
(and
(instance ?INVESTIGATE Investigating)
(agent ?INVESTIGATE ?AGENT)
(patient ?INVESTIGATE ?PROP))
(holdsDuring
(WhenFn ?INVESTIGATE)
(not
(knows ?AGENT ?PROP))))
Wenn proc ist ein fall von Diagnoseprozess und proc ist der agent von agent , dann es gibt ein cause der proc hat Zweck von "agent kennt "cause verursacht proc " " für agent .
(=>
(and
(instance ?PROC DiagnosticProcess)
(agent ?PROC ?AGENT))
(exists
(?CAUSE)
(hasPurposeForAgent
?PROC
(knows
?AGENT
(causes ?CAUSE ?PROC))
?AGENT)))
Wenn interaction ist ein fall von Sozialunterhaltung , dann es gibt ein agent1,agent2 der interaction ist der agent von agent1 und interaction ist der agent von agent2 und agent1 ist gleich agent2 nicht.
(=>
(instance ?INTERACTION SocialInteraction)
(exists
(?AGENT1 ?AGENT2)
(and
(agent ?INTERACTION ?AGENT1)
(agent ?INTERACTION ?AGENT2)
(not
(equal ?AGENT1 ?AGENT2)))))
Wenn 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 state ist ein fall von Darlegen und state ist der agent von agent und formula ist ein patient von state und formula ist ein fall von Formel , dann "agent glaubt , dass formula" hält während "die zeit des Bestehens von state" .
(=>
(and
(instance ?STATE Stating)
(agent ?STATE ?AGENT)
(patient ?STATE ?FORMULA)
(instance ?FORMULA Formula))
(holdsDuring
(WhenFn ?STATE)
(believes ?AGENT ?FORMULA)))
Wenn order ist ein fall von Bestellen und formula ist ein patient von order , dann die Aussage formula hat die modale Kraft von obligation.
(=>
(and
(instance ?ORDER Ordering)
(patient ?ORDER ?FORMULA))
(modalAttribute ?FORMULA Obligation))
Wenn request ist ein fall von Ersuchen und request ist der agent von agent und formula ist ein patient von request und formula ist ein fall von Formel , dann agent wünscht formula .
(=>
(and
(instance ?REQUEST Requesting)
(agent ?REQUEST ?AGENT)
(patient ?REQUEST ?FORMULA)
(instance ?FORMULA Formula))
(desires ?AGENT ?FORMULA))
Wenn question ist ein fall von Ausfragen und question ist der agent von agent und formula ist ein patient von question und formula ist ein fall von Formel , dann "agent kennt formula nicht" hält während "die zeit des Bestehens von question" .
(=>
(and
(instance ?QUESTION Questioning)
(agent ?QUESTION ?AGENT)
(patient ?QUESTION ?FORMULA)
(instance ?FORMULA Formula))
(holdsDuring
(WhenFn ?QUESTION)
(not
(knows ?AGENT ?FORMULA))))
Wenn commit ist ein fall von Festlegung und formula ist ein patient von commit und formula ist ein fall von Formel , dann die Aussage formula hat die modale Kraft von promise.
(=>
(and
(instance ?COMMIT Committing)
(patient ?COMMIT ?FORMULA)
(instance ?FORMULA Formula))
(modalAttribute ?FORMULA Promise))
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 meet ist ein fall von Sitzung und meet ist der agent von agent1 und meet ist der agent von agent2 , dann "agent1 ist near hinsichlich agent2 " hält während "die zeit des Bestehens von meet" .
(=>
(and
(instance ?MEET Meeting)
(agent ?MEET ?AGENT1)
(agent ?MEET ?AGENT2))
(holdsDuring
(WhenFn ?MEET)
(orientation ?AGENT1 ?AGENT2 Near)))
Wenn meet ist ein fall von Sitzung , dann es gibt ein agent1,agent2 der meet ist der agent von agent1 und meet ist der agent von agent2 und meet hat Zweck von "es gibt ein Kommunikation comm der comm ist der agent von agent1 und comm ist der agent von agent2 " .
(=>
(instance ?MEET Meeting)
(exists
(?AGENT1 ?AGENT2)
(and
(agent ?MEET ?AGENT1)
(agent ?MEET ?AGENT2)
(hasPurpose
?MEET
(exists
(?COMM)
(and
(instance ?COMM Communication)
(agent ?COMM ?AGENT1)
(agent ?COMM ?AGENT2)))))))
Wenn contest ist ein fall von Kampf , dann es gibt ein agent1,agent2,purp1,purp2 der contest ist der agent von agent1 und contest ist der agent von agent2 und contest hat Zweck von purp1 für agent1 und contest hat Zweck von purp2 für agent2 und agent1 ist gleich agent2 nicht und purp1 ist gleich purp2 nicht.
(=>
(instance ?CONTEST Contest)
(exists
(?AGENT1 ?AGENT2 ?PURP1 ?PURP2)
(and
(agent ?CONTEST ?AGENT1)
(agent ?CONTEST ?AGENT2)
(hasPurposeForAgent ?CONTEST ?PURP1 ?AGENT1)
(hasPurposeForAgent ?CONTEST ?PURP2 ?AGENT2)
(not
(equal ?AGENT1 ?AGENT2))
(not
(equal ?PURP1 ?PURP2)))))
Wenn war ist ein fall von Krieg , 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 war ist ein fall von Krieg und war ist der agent von agent ,
- dann
.
(=>
(and
(instance ?WAR War)
(agent ?WAR ?AGENT))
(or
(instance ?AGENT Nation)
(and
(instance ?AGENT Organization)
(forall
(?MEMBER)
(=>
(member ?MEMBER ?AGENT)
(instance ?MEMBER Nation))))))
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 percept ist ein fall von Wahrnehmung und percept ist der agent von agent , dann agent ist ein fall von Tier .
(=>
(and
(instance ?PERCEPT Perception)
(agent ?PERCEPT ?AGENT))
(instance ?AGENT Animal))
Wenn percept ist ein fall von Wahrnehmung und percept ist der agent von agent und object ist ein patient von percept , dann agent beachtet object .
(=>
(and
(instance ?PERCEPT Perception)
(agent ?PERCEPT ?AGENT)
(patient ?PERCEPT ?OBJECT))
(notices ?AGENT ?OBJECT))
Wenn see ist ein fall von Sehen und see ist der agent von agent und obj ist ein patient von see , dann
(=>
(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 parent ist das elterntiel von child und class ist eine teilkategorie von Organismus und parent ist ein fall von class , dann child ist ein fall von class .
(=>
(and
(parent ?CHILD ?PARENT)
(subclass ?CLASS Organism)
(instance ?PARENT ?CLASS))
(instance ?CHILD ?CLASS))
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 fungus ist ein fall von Pilz und fungus wohnt in obj, dann obj ist ein fall von Organismus .
(=>
(and
(instance ?FUNGUS Fungus)
(inhabits ?FUNGUS ?OBJ))
(instance ?OBJ Organism))
- 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))))))
Wenn bacterium ist ein fall von Bakterium und bacterium wohnt in obj, dann obj ist ein fall von Organismus .
(=>
(and
(instance ?BACTERIUM Bacterium)
(inhabits ?BACTERIUM ?OBJ))
(instance ?OBJ Organism))
(=>
(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 virus wohnt in obj, dann obj ist ein fall von Organismus .
(=>
(and
(instance ?VIRUS Virus)
(inhabits ?VIRUS ?OBJ))
(instance ?OBJ Organism))
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 drink ist ein fall von Trinken und bev ist ein patient von drink , dann bev ist ein fall von Getränk .
(=>
(and
(instance ?DRINK Drinking)
(patient ?DRINK ?BEV))
(instance ?BEV Beverage))
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 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 "ausgabe int1 von text" ist gleich edition1 und "ausgabe int2 von text" ist gleich edition2 und int2 ist grösserAls int1 und pub1 ist ein fall von Publikation und pub2 ist ein fall von Publikation und edition1 ist ein patient von pub1 und edition2 ist ein patient von pub2 und datum von pub1 ist date1 und datum von pub2 ist date2 , dann "das ende von date1" geschieht vor "das ende von date2" .
(=>
(and
(equal
(EditionFn ?TEXT ?INT1)
?EDITION1)
(equal
(EditionFn ?TEXT ?INT2)
?EDITION2)
(greaterThan ?INT2 ?INT1)
(instance ?PUB1 Publication)
(instance ?PUB2 Publication)
(patient ?PUB1 ?EDITION1)
(patient ?PUB2 ?EDITION2)
(date ?PUB1 ?DATE1)
(date ?PUB2 ?DATE2))
(before
(EndFn ?DATE1)
(EndFn ?DATE2)))
Wenn text ist eine teilkategorie von Zeitschrift und "Band int1 in der reihe text" ist gleich volume1 und "Band int2 in der reihe text" ist gleich volume2 und int2 ist grösserAls int1 und pub1 ist ein fall von Publikation und pub2 ist ein fall von Publikation und volume1 ist ein patient von pub1 und volume2 ist ein patient von pub2 und datum von pub1 ist date1 und datum von pub2 ist date2 , dann "das ende von date1" geschieht vor "das ende von date2" .
(=>
(and
(subclass ?TEXT Periodical)
(equal
(SeriesVolumeFn ?TEXT ?INT1)
?VOLUME1)
(equal
(SeriesVolumeFn ?TEXT ?INT2)
?VOLUME2)
(greaterThan ?INT2 ?INT1)
(instance ?PUB1 Publication)
(instance ?PUB2 Publication)
(patient ?PUB1 ?VOLUME1)
(patient ?PUB2 ?VOLUME2)
(date ?PUB1 ?DATE1)
(date ?PUB2 ?DATE2))
(before
(EndFn ?DATE1)
(EndFn ?DATE2)))
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))))
Wenn comp1 wird mit comp2 angeschlossen, dann comp1 ist eine komponente von comp2 und comp2 ist eine komponente von comp1.
(=>
(connectedEngineeringComponents ?COMP1 ?COMP2)
(and
(not
(engineeringSubcomponent ?COMP1 ?COMP2))
(not
(engineeringSubcomponent ?COMP2 ?COMP1))))
Wenn group ist ein fall von Gruppe und memb ist ein Mitglied von group , dann memb ist ein fall von Agent .
(=>
(and
(instance ?GROUP Group)
(member ?MEMB ?GROUP))
(instance ?MEMB Agent))
- wenn group ist ein fall von Altersklasse ,
- dann für jeden memb1,memb2,age1,age2 gilt: wenn memb1 ist ein Mitglied von group und memb2 ist ein Mitglied von group und das alter von memb1 ist age1 und das alter von memb2 ist age2 , dann age1 ist gleich age2
.
(=>
(instance ?GROUP AgeGroup)
(forall
(?MEMB1 ?MEMB2 ?AGE1 ?AGE2)
(=>
(and
(member ?MEMB1 ?GROUP)
(member ?MEMB2 ?GROUP)
(age ?MEMB1 ?AGE1)
(age ?MEMB2 ?AGE2))
(equal ?AGE1 ?AGE2))))
(=>
(instance ?GROUP FamilyGroup)
(forall
(?MEMB1 ?MEMB2)
(=>
(and
(member ?MEMB1 ?GROUP)
(member ?MEMB2 ?GROUP))
(familyRelation ?MEMB1 ?MEMB2))))
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 "die zugelassene organisatorishe Gruppe von unit" ist gleich org und attr ist ein fall von normatives Attribut , dann attr ist ein attribut von unit nur wenn attr ist ein attribut von org .
(=>
(and
(equal
(OrganizationFn ?UNIT)
?ORG)
(instance ?ATTR NormativeAttribute))
(<=>
(attribute ?UNIT ?ATTR)
(attribute ?ORG ?ATTR)))
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 obj1 ist attr1 hinsichlich obj2 und wird ? entgegengesetzet und attr1 ist ein Mitglied von "()" und attr2 ist ein Mitglied von "()" und attr1 ist gleich attr2 nicht, dann obj1 ist attr2 hinsichlich obj2 nicht.
(=>
(and
(orientation ?OBJ1 ?OBJ2 ?ATTR1)
(contraryAttribute @ROW)
(inList
?ATTR1
(ListFn @ROW))
(inList
?ATTR2
(ListFn @ROW))
(not
(equal ?ATTR1 ?ATTR2)))
(not
(orientation ?OBJ1 ?OBJ2 ?ATTR2)))
Wenn item hat ein attribut value und value ist ein fall von Wahrheitswert , dann item ist ein fall von Satz oder item ist ein fall von Proposition .
(=>
(and
(property ?ITEM ?VALUE)
(instance ?VALUE TruthValue))
(or
(instance ?ITEM Sentence)
(instance ?ITEM Proposition)))
Wenn obj1 ist attr1 hinsichlich obj2 und attr1 ist ein fall von Richtungsattribut und attr2 ist ein fall von Richtungsattribut und attr1 ist gleich attr2 nicht, dann obj1 ist attr2 hinsichlich obj2 nicht.
(=>
(and
(orientation ?OBJ1 ?OBJ2 ?ATTR1)
(instance ?ATTR1 DirectionalAttribute)
(instance ?ATTR2 DirectionalAttribute)
(not
(equal ?ATTR1 ?ATTR2)))
(not
(orientation ?OBJ1 ?OBJ2 ?ATTR2)))
Wenn direct ist ein fall von Richtungsattribut und obj1 ist direct hinsichlich obj2 und obj2 ist direct hinsichlich obj3 , dann obj2 ist zwischen obj1 und obj33 .
(=>
(and
(instance ?DIRECT DirectionalAttribute)
(orientation ?OBJ1 ?OBJ2 ?DIRECT)
(orientation ?OBJ2 ?OBJ3 ?DIRECT))
(between ?OBJ1 ?OBJ2 ?OBJ33))
Wenn attribute ist ein attribut von person und attribute ist ein fall von Sozialrolle , dann person ist ein fall von Mensch .
(=>
(and
(attribute ?PERSON ?ATTRIBUTE)
(instance ?ATTRIBUTE SocialRole))
(instance ?PERSON Human))
Für jeden org gilt: org beschäftigt person nicht und person ist ein fall von Mensch nur wenn unemployed ist ein attribut von person .
(<=>
(forall
(?ORG)
(and
(not
(employs ?ORG ?PERSON))
(instance ?PERSON Human)))
(attribute ?PERSON Unemployed))
Wenn die Aussage formula1 hat die modale Kraft von prop und formula1 hat formula2 zur Folge , dann die Aussage formula2 hat die modale Kraft von prop.
(=>
(and
(modalAttribute ?FORMULA1 ?PROP)
(entails ?FORMULA1 ?FORMULA2))
(modalAttribute ?FORMULA2 ?PROP))
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))))
(=>
(and
(attribute ?OBJ Monochromatic)
(superficialPart ?PART ?OBJ)
(attribute ?PART ?COLOR)
(instance ?COLOR PrimaryColor))
(forall
(?ELEMENT)
(=>
(superficialPart ?ELEMENT ?OBJ)
(attribute ?ELEMENT ?COLOR))))
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 attribute ist ein fall von Beschaffenheitsattribut und attribute ist ein attribut von obj und surface ist eine fläche von obj , dann attribute ist ein attribut von surface .
(=>
(and
(instance ?ATTRIBUTE TextureAttribute)
(attribute ?OBJ ?ATTRIBUTE)
(surface ?SURFACE ?OBJ))
(attribute ?SURFACE ?ATTRIBUTE))
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 att ist ein attribut von org und att ist ein fall von biologisches Attribut , dann org ist ein fall von Organismus .
(=>
(and
(attribute ?ORG ?ATT)
(instance ?ATT BiologicalAttribute))
(instance ?ORG Organism))
Wenn organism ist ein fall von Organismus und process ist der agent von organism , dann "living ist ein attribut von organism " hält während "die zeit des Bestehens von process" .
(=>
(and
(instance ?ORGANISM Organism)
(agent ?PROCESS ?ORGANISM))
(holdsDuring
(WhenFn ?PROCESS)
(attribute ?ORGANISM Living)))
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 body ist ein fall von reproduktive Körper und body ist ein teil von org und org ist ein fall von Organismus , dann female ist ein attribut von org .
(=>
(and
(instance ?BODY ReproductiveBody)
(part ?BODY ?ORG)
(instance ?ORG Organism))
(attribute ?ORG Female))
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))))))
Wenn attr ist ein fall von psychologisches Attribut und attr ist ein attribut von agent , dann agent ist ein fall von empfindungsfähiger Agent .
(=>
(and
(instance ?ATTR PsychologicalAttribute)
(attribute ?AGENT ?ATTR))
(instance ?AGENT SentientAgent))
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 "der durchschnitt von class1 und class2" nur wenn entity ist ein fall von class1 und entity ist ein fall von class2 .
(<=>
(instance
?ENTITY
(IntersectionFn ?CLASS1 ?CLASS2))
(and
(instance ?ENTITY ?CLASS1)
(instance ?ENTITY ?CLASS2)))
Wenn class1 ist ein fall von Menge oder Kategorie und class2 ist ein fall von Menge oder Kategorie , dann "der unterschied zwischen class1 und class2" ist gleich "der durchschnitt von class1 und "die ergänzung von class2"" .
(=>
(and
(instance ?CLASS1 SetOrClass)
(instance ?CLASS2 SetOrClass))
(equal
(RelativeComplementFn ?CLASS1 ?CLASS2)
(IntersectionFn
?CLASS1
(ComplementFn ?CLASS2))))
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))))
