=> (=>)
The truth-functional connective of implication.
Ontology
SUMO / STRUCTURAL-ONTOLOGYClass(es)
Coordinate term(s)
<=>
and
hatZurFolge
exists
forall
not
or
Type restrictions
=>(Formel, Formel)
Related WordNet synsets
See more related synsets on a separate page.
Axioms (679)
Wenn entity ist ein direkter fall von class, dann es gibt kein class subclass der entity ist ein fall von subclass .
(=>
(immediateInstance ?ENTITY ?CLASS)
(not
(exists
(?SUBCLASS)
(and
(subclass ?SUBCLASS ?CLASS)
(instance ?ENTITY ?SUBCLASS)))))
Wenn rel1 ist eine inverse von rel2 , dann für jeden inst1,inst2 gilt: rel1(inst1,inst2) gilt nur wenn rel2(inst2,inst1) gilt .
(=>
(inverse ?REL1 ?REL2)
(forall
(?INST1 ?INST2)
(<=>
(holds ?REL1 ?INST1 ?INST2)
(holds ?REL2 ?INST2 ?INST1))))
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 thing1 ist gleich thing2 , dann für jeden attr gilt: thing1 hat ein attribut attr nur wenn thing2 hat ein attribut attr .
(=>
(equal ?THING1 ?THING2)
(forall
(?ATTR)
(<=>
(property ?THING1 ?ATTR)
(property ?THING2 ?ATTR))))
Wenn attr1 ist gleich attr2 , dann für jeden thing gilt: thing hat ein attribut attr1 nur wenn thing hat ein attribut attr2 .
(=>
(equal ?ATTR1 ?ATTR2)
(forall
(?THING)
(<=>
(property ?THING ?ATTR1)
(property ?THING ?ATTR2))))
Wenn thing1 ist gleich thing2 , dann für jeden class gilt: thing1 ist ein fall von class nur wenn thing2 ist ein fall von class .
(=>
(equal ?THING1 ?THING2)
(forall
(?CLASS)
(<=>
(instance ?THING1 ?CLASS)
(instance ?THING2 ?CLASS))))
Wenn class1 ist gleich class2 , dann für jeden thing gilt: thing ist ein fall von class1 nur wenn thing ist ein fall von class2 .
(=>
(equal ?CLASS1 ?CLASS2)
(forall
(?THING)
(<=>
(instance ?THING ?CLASS1)
(instance ?THING ?CLASS2))))
Wenn rel1 ist gleich rel2 , dann für jeden gilt: rel1() gilt nur wenn rel2() gilt .
(=>
(equal ?REL1 ?REL2)
(forall
(@ROW)
(<=>
(holds ?REL1 @ROW)
(holds ?REL2 @ROW))))
- 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)))
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)))
(=>
(contraryAttribute @ROW)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(instance ?ELEMENT Attribute)))
- 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))))))
(=>
(exhaustiveAttribute ?CLASS @ROW)
(=>
(inList
?ATTR
(ListFn @ROW))
(instance ?ATTR Attribute)))
- wenn exhaustive attribute(class,) gilt,
- dann für jeden obj gilt: wenn attr1 ist ein fall von class , dann es gibt ein attr2 der attr2 ist ein Mitglied von "()" und attr1 ist gleich attr2
.
(=>
(exhaustiveAttribute ?CLASS @ROW)
(forall
(?OBJ)
(=>
(instance ?ATTR1 ?CLASS)
(exists
(?ATTR2)
(and
(inList
?ATTR2
(ListFn @ROW))
(equal ?ATTR1 ?ATTR2))))))
- wenn wird mit behandelt,
- dann wenn element ist ein Mitglied von "()", dann element ist ein fall von Kategorie
.
(=>
(exhaustiveDecomposition @ROW)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(instance ?ELEMENT Class)))
- wenn wird zusammenhanglos auf disjunkt,
- dann wenn element ist ein Mitglied von "()", dann element ist ein fall von Kategorie
.
(=>
(disjointDecomposition @ROW)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(instance ?ELEMENT Class)))
(=>
(subAttribute ?ATTR1 ?ATTR2)
(forall
(?OBJ)
(=>
(property ?OBJ ?ATTR1)
(property ?OBJ ?ATTR2))))
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 attr1 ist ein direkter nachfolgerattribut von attr2, dann attr1 ist ein nachfolgerattribut von attr2.
(=>
(successorAttribute ?ATTR1 ?ATTR2)
(successorAttributeClosure ?ATTR1 ?ATTR2))
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))
Wenn class ist ein fall von Kategorie , dann class ist eine teilkategorie von Wesen.
(=>
(instance ?CLASS Class)
(subclass ?CLASS Entity))
Wenn obj ist ein fall von selbstverbundener Gegenstand , dann "die frontseite von obj" ist ein teil von obj .
(=>
(instance ?OBJ SelfConnectedObject)
(part
(FrontFn ?OBJ)
?OBJ))
Wenn obj ist ein fall von selbstverbundener Gegenstand , dann "die rückseite von obj" ist ein teil von obj .
(=>
(instance ?OBJ SelfConnectedObject)
(part
(BackFn ?OBJ)
?OBJ))
- wenn substance1 ist ein stück von substance2 ,
- dann für jeden class gilt: wenn substance1 ist ein fall von class , dann substance2 ist ein fall von class
.
(=>
(piece ?SUBSTANCE1 ?SUBSTANCE2)
(forall
(?CLASS)
(=>
(instance ?SUBSTANCE1 ?CLASS)
(instance ?SUBSTANCE2 ?CLASS))))
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)))))
Wenn region ist ein fall von Gebiet , dann es gibt ein phys der phys befindet sich an .
(=>
(instance ?REGION Region)
(exists
(?PHYS)
(located ?PHYS ?REGION)))
Wenn coll ist ein fall von Ansammlung , dann es gibt ein obj der obj ist ein Mitglied von coll .
(=>
(instance ?COLL Collection)
(exists
(?OBJ)
(member ?OBJ ?COLL)))
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))))))
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)))
Wenn function ist ein fall von zeitabhängige Quantität , dann die Zahl Argument von function ist ein fall von Zeitmass .
(=>
(instance ?FUNCTION TimeDependentQuantity)
(domain ?FUNCTION 1 TimeMeasure))
Wenn rel ist ein fall von Relation , dann rel() gilt nur wenn rel() gilt.
(=>
(instance ?REL Relation)
(<=>
(holds ?REL @ROW)
(?REL @ROW)))
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 rel ist ein fall von zweiwertige Relation , dann es gibt kein item1,item2,item3, der rel(item1,item2,item3,) gilt .
(=>
(instance ?REL BinaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 @ROW))))
- wenn rel ist ein fall von reflexive Relation ,
- dann wenn rel(inst1,inst2) gilt oder rel(inst2,inst1) gilt , dann rel(inst1,inst1) gilt
.
(=>
(instance ?REL ReflexiveRelation)
(=>
(or
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST1))
(holds ?REL ?INST1 ?INST1)))
Wenn rel ist ein fall von irreflexive Relation , dann für jeden inst gilt: rel(inst,inst) gilt nicht.
(=>
(instance ?REL IrreflexiveRelation)
(forall
(?INST)
(not
(holds ?REL ?INST ?INST))))
- wenn rel ist ein fall von symmetrische Relation ,
- dann für jeden inst1,inst2 gilt: wenn rel(inst1,inst2) gilt , dann rel(inst2,inst1) gilt
.
(=>
(instance ?REL SymmetricRelation)
(forall
(?INST1 ?INST2)
(=>
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST1))))
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 trichotomizierende Relation , dann für jeden inst1,inst2 gilt: rel(inst1,inst2) gilt oder inst1 ist gleich inst2 oder rel(inst2,inst1) gilt .
(=>
(instance ?REL TrichotomizingRelation)
(forall
(?INST1 ?INST2)
(or
(holds ?REL ?INST1 ?INST2)
(equal ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST1))))
- 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 rel ist ein fall von Totalordnungsrelation , dann für jeden inst1,inst2 gilt: rel(inst1,inst2) gilt oder rel(inst2,inst1) gilt .
(=>
(instance ?REL TotalOrderingRelation)
(forall
(?INST1 ?INST2)
(or
(holds ?REL ?INST1 ?INST2)
(holds ?REL ?INST2 ?INST1))))
Wenn process ist ein fall von Prozess , dann es gibt ein cause der process ist der agent von cause .
(=>
(instance ?PROCESS Process)
(exists
(?CAUSE)
(agent ?PROCESS ?CAUSE)))
Wenn 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 agent bevorzugt formula1 über formula2 ,
- dann wenn formula1 ist true , dann formula2 ist false
.
(=>
(prefers ?AGENT ?FORMULA1 ?FORMULA2)
(=>
(true ?FORMULA1 True)
(true ?FORMULA2 False)))
Wenn agent braucht object , dann agent wünscht object .
(=>
(needs ?AGENT ?OBJECT)
(wants ?AGENT ?OBJECT))
Wenn agent wünscht obj , dann es gibt ein purp der obj hat Zweck von purp für agent .
(=>
(wants ?AGENT ?OBJ)
(exists
(?PURP)
(hasPurposeForAgent ?OBJ ?PURP ?AGENT)))
Wenn agent wünscht obj , dann agent wünscht "agent besitzt obj " .
(=>
(wants ?AGENT ?OBJ)
(desires
?AGENT
(possesses ?AGENT ?OBJ)))
Wenn agent glaubt , dass formula, dann es gibt ein time der "agent betrachtet formula " hält während time .
(=>
(believes ?AGENT ?FORMULA)
(exists
(?TIME)
(holdsDuring
?TIME
(considers ?AGENT ?FORMULA))))
Wenn agent kennt formula , dann agent glaubt , dass formula.
(=>
(knows ?AGENT ?FORMULA)
(believes ?AGENT ?FORMULA))
Wenn agent kennt formula , dann formula ist true .
(=>
(knows ?AGENT ?FORMULA)
(true ?FORMULA True))
Wenn rel ist ein fall von dreiwertige Relation , dann es gibt kein item1,item2,item3,item4, der rel(item1,item2,item3,item4,) gilt .
(=>
(instance ?REL TernaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))
Wenn rel ist ein fall von viewwertige Relation , dann es gibt kein item1,item2,item3,item4,item5, der rel(item1,item2,item3,item4,item5,) gilt .
(=>
(instance ?REL QuaternaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW))))
Wenn rel ist ein fall von fünfwertige Relation , dann es gibt kein item1,item2,item3,item4,item5,item6, der rel(item1,item2,item3,item4,item5,item6,) gilt .
(=>
(instance ?REL QuintaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW))))
- wenn list ist ein fall von Liste ,
- dann es gibt ein number1 der es gibt ein item1 der "number1te mitglied von list" ist gleich item1 nicht und für jeden number2 gilt: wenn number2 ist ein fall von positive Ganzzahl und number2 ist kleinerAls number1 , dann es gibt ein item2 der "number2te mitglied von list" ist gleich item2
.
(=>
(instance ?LIST List)
(exists
(?NUMBER1)
(exists
(?ITEM1)
(and
(not
(equal
(ListOrderFn ?LIST ?NUMBER1)
?ITEM1))
(forall
(?NUMBER2)
(=>
(and
(instance ?NUMBER2 PositiveInteger)
(lessThan ?NUMBER2 ?NUMBER1))
(exists
(?ITEM2)
(equal
(ListOrderFn ?LIST ?NUMBER2)
?ITEM2))))))))
list ist ein fall von einzigartige Liste nur wenn für jeden number1,number2 gilt: wenn "number1te mitglied von list" ist gleich "number2te mitglied von list" , dann number1 ist gleich number2 .
(<=>
(instance ?LIST UniqueList)
(forall
(?NUMBER1 ?NUMBER2)
(=>
(equal
(ListOrderFn ?LIST ?NUMBER1)
(ListOrderFn ?LIST ?NUMBER2))
(equal ?NUMBER1 ?NUMBER2))))
- 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 item gilt: wenn item ist ein Mitglied von "()", dann item ist eine teilkategorie von class
.
(=>
(disjointDecomposition ?CLASS @ROW)
(forall
(?ITEM)
(=>
(inList
?ITEM
(ListFn @ROW))
(subclass ?ITEM ?CLASS))))
- 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 list" ist gleich number1 , dann für jeden number2 gilt: es gibt ein item der "number2te mitglied von list" ist gleich item nur wenn number2 ist kleinerAlsOderGleich number1 .
(=>
(equal
(ListLengthFn ?LIST)
?NUMBER1)
(forall
(?NUMBER2)
(<=>
(exists
(?ITEM)
(equal
(ListOrderFn ?LIST ?NUMBER2)
?ITEM))
(lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))
- wenn rel hat number argument(e),
- dann für jeden gilt: wenn rel() gilt , dann "Länge von "()"" ist gleich number
.
(=>
(valence ?REL ?NUMBER)
(forall
(@ROW)
(=>
(holds ?REL @ROW)
(equal
(ListLengthFn
(ListFn @ROW))
?NUMBER))))
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 für jeden item gilt: wenn item ist ein Mitglied von list1, dann item ist ein Mitglied von list2
.
(=>
(subList ?LIST1 ?LIST2)
(forall
(?ITEM)
(=>
(inList ?ITEM ?LIST1)
(inList ?ITEM ?LIST2))))
- 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 function ist ein fall von einstellige Funktion , dann function hat argument(e).
(=>
(instance ?FUNCTION UnaryFunction)
(valence ?FUNCTION 1))
- 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 zweistellige Funktion , dann function hat argument(e).
(=>
(instance ?FUNCTION BinaryFunction)
(valence ?FUNCTION 2))
- 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 ein fall von dreistellige Funktion , dann function hat argument(e).
(=>
(instance ?FUNCTION TernaryFunction)
(valence ?FUNCTION 3))
Wenn function ist ein fall von vierstellige funktion , dann function hat argument(e).
(=>
(instance ?FUNCTION QuaternaryFunction)
(valence ?FUNCTION 4))
Wenn rel ist ein fall von zweistellige Prädikat , dann rel hat argument(e).
(=>
(instance ?REL BinaryPredicate)
(valence ?REL 2))
Wenn rel ist ein fall von dreistellige Prädikat , dann rel hat argument(e).
(=>
(instance ?REL TernaryPredicate)
(valence ?REL 3))
Wenn rel ist ein fall von vierstellige Prädikat , dann rel hat argument(e).
(=>
(instance ?REL QuaternaryPredicate)
(valence ?REL 4))
Wenn rel ist ein fall von fünfstellige Prädikat , dann rel hat argument(e).
(=>
(instance ?REL QuintaryPredicate)
(valence ?REL 5))
Wenn rel ist ein fall von Relation mit veränderlicher Anzahl Argumente , dann es gibt kein int der rel hat int argument(e).
(=>
(instance ?REL VariableArityRelation)
(not
(exists
(?INT)
(valence ?REL ?INT))))
- wenn 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 auf class reflexiv ,
- dann für jeden inst gilt: wenn inst ist ein fall von class , dann relation(inst,inst) gilt
.
(=>
(reflexiveOn ?RELATION ?CLASS)
(forall
(?INST)
(=>
(instance ?INST ?CLASS)
(holds ?RELATION ?INST ?INST))))
- wenn relation ist irreflexiv auf class ,
- dann für jeden inst gilt: wenn inst ist ein fall von class , dann relation(inst,inst) gilt nicht
.
(=>
(irreflexiveOn ?RELATION ?CLASS)
(forall
(?INST)
(=>
(instance ?INST ?CLASS)
(not
(holds ?RELATION ?INST ?INST)))))
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)))
- 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 proc1 ist ein fall von Prozess , dann es gibt ein proc2 der proc2 verursacht proc1 .
(=>
(instance ?PROC1 Process)
(exists
(?PROC2)
(causes ?PROC2 ?PROC1)))
- wenn causes subclass(proc1,proc2) gilt,
- dann für jeden inst2 gilt: wenn inst2 ist ein fall von proc2 , dann es gibt ein proc1 inst1 der inst1 verursacht inst2
.
(=>
(causesSubclass ?PROC1 ?PROC2)
(forall
(?INST2)
(=>
(instance ?INST2 ?PROC2)
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(causes ?INST1 ?INST2))))))
- wenn obj1 ist eine genaue kopie von obj2,
- dann für jeden attr gilt: wenn attr ist ein attribut von obj1 , dann attr ist ein attribut von obj2
.
(=>
(copy ?OBJ1 ?OBJ2)
(forall
(?ATTR)
(=>
(attribute ?OBJ1 ?ATTR)
(attribute ?OBJ2 ?ATTR))))
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 "situation" hält während time , dann situation hält während time nicht.
(=>
(holdsDuring
?TIME
(not ?SITUATION))
(not
(holdsDuring ?TIME ?SITUATION)))
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 thing hat Zweck von purpose , dann es gibt ein agent der thing hat Zweck von purpose für agent .
(=>
(hasPurpose ?THING ?PURPOSE)
(exists
(?AGENT)
(hasPurposeForAgent ?THING ?PURPOSE ?AGENT)))
Wenn agent hat die Fähigkeit, zum proc zu tun , dann agent ist fähig , in der Rolle agent proc zu tun.
(=>
(hasSkill ?PROC ?AGENT)
(capability ?PROC agent ?AGENT))
Wenn agent hat das Recht, process durchzuführen , dann agent ist fähig , in der Rolle agent process zu tun.
(=>
(holdsRight ?PROCESS ?AGENT)
(capability ?PROCESS agent ?AGENT))
Wenn agent1 erlaubt agent2, die Aufgabe der Art von process durchzuführen , dann agent2 hat das Recht, process durchzuführen .
(=>
(confersRight ?PROCESS ?AGENT1 ?AGENT2)
(holdsRight ?PROCESS ?AGENT2))
Wenn agent wird gezwungen, die Aufgabe der Art von process durchzuführen , dann agent ist fähig , in der Rolle agent process zu tun.
(=>
(holdsObligation ?PROCESS ?AGENT)
(capability ?PROCESS agent ?AGENT))
Wenn agent1 zwingt agent2, die Aufgabe der Art von process durchzuführen , dann agent2 wird gezwungen, die Aufgabe der Art von process durchzuführen .
(=>
(confersObligation ?PROCESS ?AGENT1 ?AGENT2)
(holdsObligation ?PROCESS ?AGENT2))
- wenn obj befindet sich an ,
- dann für jeden subobj gilt: wenn subobj ist ein teil von obj , dann subobj befindet sich an
.
(=>
(located ?OBJ ?REGION)
(forall
(?SUBOBJ)
(=>
(part ?SUBOBJ ?OBJ)
(located ?SUBOBJ ?REGION))))
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 obj1 überquert obj2, dann obj1 kreuzt obj2 oder obj1 dringt obj2 ein.
(=>
(traverses ?OBJ1 ?OBJ2)
(or
(crosses ?OBJ1 ?OBJ2)
(penetrates ?OBJ1 ?OBJ2)))
- 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 ist eine vorbedingung von proc2,
- dann wenn es gibt ein inst2 der inst2 ist ein fall von proc2 , dann es gibt ein inst1 der inst1 ist ein fall von proc1
.
(=>
(precondition ?PROC1 ?PROC2)
(=>
(exists
(?INST2)
(instance ?INST2 ?PROC2))
(exists
(?INST1)
(instance ?INST1 ?PROC1))))
Wenn proc1 hemmt proc2, dann für jeden time,place gilt: ""es gibt ein proc1 inst1 der inst1 befindet sich an " hält während time " verringert die Wahrscheinlichkeit von ""es gibt ein proc2 inst2 der inst2 befindet sich an " hält während time " .
(=>
(inhibits ?PROC1 ?PROC2)
(forall
(?TIME ?PLACE)
(decreasesLikelihood
(holdsDuring
?TIME
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(located ?INST1 ?PLACE))))
(holdsDuring
?TIME
(exists
(?INST2)
(and
(instance ?INST2 ?PROC2)
(located ?INST2 ?PLACE)))))))
- wenn proc1 verhindert das Auftreten von proc2,
- dann für jeden time,place gilt: wenn "es gibt ein proc1 inst1 der inst1 befindet sich an " hält während time , dann "es gibt ein proc2 inst2 der inst2 befindet sich an " hält während time nicht
.
(=>
(prevents ?PROC1 ?PROC2)
(forall
(?TIME ?PLACE)
(=>
(holdsDuring
?TIME
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(located ?INST1 ?PLACE))))
(not
(holdsDuring
?TIME
(exists
(?INST2)
(and
(instance ?INST2 ?PROC2)
(located ?INST2 ?PLACE))))))))
Wenn agent verwendet rep, um für entity zu stehen, dann rep drückt entity aus.
(=>
(representsForAgent ?REP ?ENTITY ?AGENT)
(represents ?REP ?ENTITY))
Wenn rep ist in Sprache entity ausgedrückt, dann es gibt ein agent der agent verwendet rep, um für entity zu stehen.
(=>
(representsInLanguage ?REP ?ENTITY ?LANGUAGE)
(exists
(?AGENT)
(representsForAgent ?REP ?ENTITY ?AGENT)))
class1 fasst das Inhalt von class2 zusammen nur wenn für jeden obj2,info gilt: wenn obj2 ist ein fall von class2 und obj2 enthält Informationen über info, dann es gibt ein class1 obj1 der obj1 enthält Informationen über info.
(<=>
(subsumesContentClass ?CLASS1 ?CLASS2)
(forall
(?OBJ2 ?INFO)
(=>
(and
(instance ?OBJ2 ?CLASS2)
(containsInformation ?OBJ2 ?INFO))
(exists
(?OBJ1)
(and
(instance ?OBJ1 ?CLASS1)
(containsInformation ?OBJ1 ?INFO))))))
obj1 fasst das Inhalt von obj2 zusammen nur wenn für jeden info gilt: wenn obj2 enthält Informationen über info, dann obj1 enthält Informationen über info.
(<=>
(subsumesContentInstance ?OBJ1 ?OBJ2)
(forall
(?INFO)
(=>
(containsInformation ?OBJ2 ?INFO)
(containsInformation ?OBJ1 ?INFO))))
Wenn process drükt den Inhalt von prop aus, dann es gibt ein Inhaltsgegenstand obj der obj enthält Informationen über prop.
(=>
(realization ?PROCESS ?PROP)
(exists
(?OBJ)
(and
(instance ?OBJ ContentBearingObject)
(containsInformation ?OBJ ?PROP))))
- 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)))))
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 für jeden element gilt: wenn element ist ein Mitglied von "()", dann "element betrag number" ist gleich
.
(=>
(equal
(GreatestCommonDivisorFn @ROW)
?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?ELEMENT ?NUMBER)
0))))
- 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 für jeden element gilt: wenn element ist ein Mitglied von "()", dann "number betrag element" ist gleich
.
(=>
(equal
(LeastCommonMultipleFn @ROW)
?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?NUMBER ?ELEMENT)
0))))
- 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 number ist ein fall von Eigenschaft , dann "der reziprokerwert von number" ist gleich "number in der te Potenz" .
(=>
(instance ?NUMBER Quantity)
(equal
(ReciprocalFn ?NUMBER)
(ExponentiationFn ?NUMBER -1)))
Wenn number ist ein fall von Eigenschaft , dann ist gleich "number*"der reziprokerwert von number"" .
(=>
(instance ?NUMBER Quantity)
(equal
1
(MultiplicationFn
?NUMBER
(ReciprocalFn ?NUMBER))))
Wenn "number1 betrag number2" ist gleich number , dann "das zeichen von number2" ist gleich "das zeichen von number" .
(=>
(equal
(RemainderFn ?NUMBER1 ?NUMBER2)
?NUMBER)
(equal
(SignumFn ?NUMBER2)
(SignumFn ?NUMBER)))
Wenn number ist ein fall von gerade Ganzzahl , dann "number betrag " ist gleich .
(=>
(instance ?NUMBER EvenInteger)
(equal
(RemainderFn ?NUMBER 2)
0))
Wenn number ist ein fall von ungerade Ganzzahl , dann "number betrag " ist gleich .
(=>
(instance ?NUMBER OddInteger)
(equal
(RemainderFn ?NUMBER 2)
1))
- wenn prime ist ein fall von Hauptzahl ,
- dann für jeden number gilt: wenn "prime betrag number" ist gleich , dann number ist gleich oder number ist gleich prime
.
(=>
(instance ?PRIME PrimeNumber)
(forall
(?NUMBER)
(=>
(equal
(RemainderFn ?PRIME ?NUMBER)
0)
(or
(equal ?NUMBER 1)
(equal ?NUMBER ?PRIME)))))
- wenn "number1 gerundet" ist gleich number2 ,
- dann
- wenn "(number1-"die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number1")" ist kleinerAls , dann number2 ist gleich "die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number1"
oder - wenn "(number1-"die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number1")" ist grösserAlsOderGleich , dann number2 ist gleich "die oberstegrenze von number1"
.
(=>
(equal
(RoundFn ?NUMBER1)
?NUMBER2)
(or
(=>
(lessThan
(SubtractionFn
?NUMBER1
(FloorFn ?NUMBER1))
0.5)
(equal
?NUMBER2
(FloorFn ?NUMBER1)))
(=>
(greaterThanOrEqualTo
(SubtractionFn
?NUMBER1
(FloorFn ?NUMBER1))
0.5)
(equal
?NUMBER2
(CeilingFn ?NUMBER1)))))
Wenn number ist ein fall von nichtnegative reelle Zahl , dann "das zeichen von number" ist gleich oder "das zeichen von number" ist gleich .
(=>
(instance ?NUMBER NonnegativeRealNumber)
(or
(equal
(SignumFn ?NUMBER)
1)
(equal
(SignumFn ?NUMBER)
0)))
Wenn number ist ein fall von positive reelle Zahl , dann "das zeichen von number" ist gleich .
(=>
(instance ?NUMBER PositiveRealNumber)
(equal
(SignumFn ?NUMBER)
1))
Wenn number ist ein fall von negative reelle Zahl , dann "das zeichen von number" ist gleich .
(=>
(instance ?NUMBER NegativeRealNumber)
(equal
(SignumFn ?NUMBER)
-1))
Wenn "die quadratwurzel von number1" ist gleich number2 , dann "number2*number2" ist gleich number1 .
(=>
(equal
(SquareRootFn ?NUMBER1)
?NUMBER2)
(equal
(MultiplicationFn ?NUMBER2 ?NUMBER2)
?NUMBER1))
Wenn degree ist ein fall von Ebenerwinkelmass , dann "der tangens von degree" ist gleich ""der Sinus von degree"/"der Kosinus von degree"" .
(=>
(instance ?DEGREE PlaneAngleMeasure)
(equal
(TangentFn ?DEGREE)
(DivisionFn
(SineFn ?DEGREE)
(CosineFn ?DEGREE))))
- 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+1)" ist gleich "(int2+1)" , dann int1 ist gleich int2 .
(=>
(equal
(SuccessorFn ?INT1)
(SuccessorFn ?INT2))
(equal ?INT1 ?INT2))
Wenn int ist ein fall von Ganzzahl , dann int ist kleinerAls "(int+1)" .
(=>
(instance ?INT Integer)
(lessThan
?INT
(SuccessorFn ?INT)))
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 int ist ein fall von Ganzzahl , dann int ist gleich "("(int+2)"+1)" .
(=>
(instance ?INT Integer)
(equal
?INT
(SuccessorFn
(PredecessorFn ?INT))))
Wenn int ist ein fall von Ganzzahl , dann int ist gleich "("(int+1)"+2)" .
(=>
(instance ?INT Integer)
(equal
?INT
(PredecessorFn
(SuccessorFn ?INT))))
Wenn "(int1+2)" ist gleich "(int2+2)" , dann int1 ist gleich int2 .
(=>
(equal
(PredecessorFn ?INT1)
(PredecessorFn ?INT2))
(equal ?INT1 ?INT2))
Wenn int ist ein fall von Ganzzahl , dann int ist grösserAls "(int+2)" .
(=>
(instance ?INT Integer)
(greaterThan
?INT
(PredecessorFn ?INT)))
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 subset ist eine teilmenge von set ,
- dann für jeden element gilt: wenn element ist ein element von subset , dann element ist ein element von set
.
(=>
(subset ?SUBSET ?SET)
(forall
(?ELEMENT)
(=>
(element ?ELEMENT ?SUBSET)
(element ?ELEMENT ?SET))))
Wenn für jeden element gilt: element ist ein element von set1 nur wenn element ist ein element von set2 , dann set1 ist gleich set2 .
(=>
(forall
(?ELEMENT)
(<=>
(element ?ELEMENT ?SET1)
(element ?ELEMENT ?SET2)))
(equal ?SET1 ?SET2))
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)))))))
Wenn part ist ein fall von Graphelement , dann es gibt ein Graph graph der part ist ein teil von graph .
(=>
(instance ?PART GraphElement)
(exists
(?GRAPH)
(and
(instance ?GRAPH Graph)
(graphPart ?PART ?GRAPH))))
Wenn node ist ein fall von Graphknoten , dann es gibt ein other,arc der arc verbindet node und other .
(=>
(instance ?NODE GraphNode)
(exists
(?OTHER ?ARC)
(links ?NODE ?OTHER ?ARC)))
Wenn arc ist ein fall von Graphbogen , dann es gibt ein node1,node2 der arc verbindet node1 und node2 .
(=>
(instance ?ARC GraphArc)
(exists
(?NODE1 ?NODE2)
(links ?NODE1 ?NODE2 ?ARC)))
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 arc verbindet node1 und node2 , dann arc verbindet node2 und node1 .
(=>
(links ?NODE1 ?NODE2 ?ARC)
(links ?NODE2 ?NODE1 ?ARC))
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 , dann path ist ein fall von "die menge von Pfaden zwischen node1 und node2" .
(=>
(equal
(MinimalWeightedPathFn ?NODE1 ?NODE2)
?PATH)
(instance
?PATH
(GraphPathFn ?NODE1 ?NODE2)))
- 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 , dann path ist ein fall von "die menge von Pfaden zwischen node1 und node2" .
(=>
(equal
(MaximalWeightedPathFn ?NODE1 ?NODE2)
?PATH)
(instance
?PATH
(GraphPathFn ?NODE1 ?NODE2)))
- 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)))
Wenn graph ist ein fall von Graph , dann "die menge von minimalen Pfaden die graph in zwei verschiedene Graphen schnitten" ist eine teilkategorie von "die menge von Pfaden die graph in zwei verschiedene Graphen schnitten".
(=>
(instance ?GRAPH Graph)
(subclass
(MinimalCutSetFn ?GRAPH)
(CutSetFn ?GRAPH)))
- wenn "die menge von minimalen Pfaden die graph in zwei verschiedene Graphen schnitten" ist gleich pathclass ,
- dann es gibt ein number der für jeden path gilt: wenn path ist ein fall von pathclass , dann die länge von path ist number
.
(=>
(equal
(MinimalCutSetFn ?GRAPH)
?PATHCLASS)
(exists
(?NUMBER)
(forall
(?PATH)
(=>
(instance ?PATH ?PATHCLASS)
(pathLength ?PATH ?NUMBER)))))
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)))))
Wenn unit ist ein fall von Masseinheit , dann "1 tausend unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(KiloFn ?UNIT)
(MeasureFn 1000 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "1 million unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MegaFn ?UNIT)
(MeasureFn 1000000 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "1 milliarde unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(GigaFn ?UNIT)
(MeasureFn 1000000000 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "1 trillion unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(TeraFn ?UNIT)
(MeasureFn 1000000000000 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "ein tausendstes einer unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MilliFn ?UNIT)
(MeasureFn 0.001 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "ein millionstel einer unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(MicroFn ?UNIT)
(MeasureFn 0.000001 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "ein milliardstel einer unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(NanoFn ?UNIT)
(MeasureFn 0.000000001 ?UNIT)))
Wenn unit ist ein fall von Masseinheit , dann "ein trillionstel einer unit" ist gleich " unit(s)" .
(=>
(instance ?UNIT UnitOfMeasure)
(equal
(PicoFn ?UNIT)
(MeasureFn 0.000000000001 ?UNIT)))
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 mass von object ist "distance pro &2 in ref in der Richtung direction" , dann das mass von object ist "distance pro &2" .
(=>
(measure
?OBJECT
(VelocityFn ?DISTANCE ?TIME ?REF ?DIRECTION))
(measure
?OBJECT
(SpeedFn ?DISTANCE ?TIME)))
Wenn number ist ein fall von reelle Zahl , dann "number centimeter(s)" ist gleich ""number*" meter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Centimeter)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
Meter)))
Wenn number ist ein fall von reelle Zahl , dann "number celsius degree(s)" ist gleich ""(number-)" kelvin degree(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER CelsiusDegree)
(MeasureFn
(SubtractionFn ?NUMBER 273.15)
KelvinDegree)))
Wenn number ist ein fall von reelle Zahl , dann "number celsius degree(s)" ist gleich """(number-)"/" fahrenheit degree(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER CelsiusDegree)
(MeasureFn
(DivisionFn
(SubtractionFn ?NUMBER 32)
1.8)
FahrenheitDegree)))
Wenn number ist ein fall von reelle Zahl , dann "number day duration(s)" ist gleich ""number*" hour duration(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER DayDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 24)
HourDuration)))
Wenn number ist ein fall von reelle Zahl , dann "number hour duration(s)" ist gleich ""number*" minute duration(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER HourDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 60)
MinuteDuration)))
Wenn number ist ein fall von reelle Zahl , dann "number minute duration(s)" ist gleich ""number*" second duration(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER MinuteDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 60)
SecondDuration)))
Wenn number ist ein fall von reelle Zahl , dann "number week duration(s)" ist gleich ""number*" day duration(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER WeekDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 7)
DayDuration)))
Wenn number ist ein fall von reelle Zahl , dann "number year duration(s)" ist gleich ""number*" day duration(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER YearDuration)
(MeasureFn
(MultiplicationFn ?NUMBER 365)
DayDuration)))
Wenn number ist ein fall von reelle Zahl , dann "number amu(s)" ist gleich ""number**" gram(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Amu)
(MeasureFn
(MultiplicationFn ?NUMBER 1.6605402 E-24)
Gram)))
Wenn number ist ein fall von reelle Zahl , dann "number electron volt(s)" ist gleich ""number**" joule(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER ElectronVolt)
(MeasureFn
(MultiplicationFn ?NUMBER 1.60217733 E-19)
Joule)))
Wenn number ist ein fall von reelle Zahl , dann "number angstrom(s)" ist gleich ""number**" meter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Angstrom)
(MeasureFn
(MultiplicationFn ?NUMBER 1.0 E-10)
Meter)))
Wenn number ist ein fall von reelle Zahl , dann "number foot(s)" ist gleich ""number*" meter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Foot)
(MeasureFn
(MultiplicationFn ?NUMBER 0.3048)
Meter)))
Wenn number ist ein fall von reelle Zahl , dann "number inch(s)" ist gleich ""number*" meter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Inch)
(MeasureFn
(MultiplicationFn ?NUMBER 0.0254)
Meter)))
Wenn number ist ein fall von reelle Zahl , dann "number mile(s)" ist gleich ""number*" meter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Mile)
(MeasureFn
(MultiplicationFn ?NUMBER 1609.344)
Meter)))
Wenn number ist ein fall von reelle Zahl , dann "number united states gallon(s)" ist gleich ""number*" liter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedStatesGallon)
(MeasureFn
(MultiplicationFn ?NUMBER 3.785411784)
Liter)))
Wenn number ist ein fall von reelle Zahl , dann "number quart(s)" ist gleich ""number/" united states gallon(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Quart)
(MeasureFn
(DivisionFn ?NUMBER 4)
UnitedStatesGallon)))
Wenn number ist ein fall von reelle Zahl , dann "number pint(s)" ist gleich ""number/" quart(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Pint)
(MeasureFn
(DivisionFn ?NUMBER 2)
Quart)))
Wenn number ist ein fall von reelle Zahl , dann "number cup(s)" ist gleich ""number/" pint(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Cup)
(MeasureFn
(DivisionFn ?NUMBER 2)
Pint)))
Wenn number ist ein fall von reelle Zahl , dann "number ounce(s)" ist gleich ""number/" cup(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Ounce)
(MeasureFn
(DivisionFn ?NUMBER 8)
Cup)))
Wenn number ist ein fall von reelle Zahl , dann "number united kingdom gallon(s)" ist gleich ""number*" liter(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedKingdomGallon)
(MeasureFn
(MultiplicationFn ?NUMBER 4.54609)
Liter)))
Wenn number ist ein fall von reelle Zahl , dann "number pound mass(s)" ist gleich ""number*" gram(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER PoundMass)
(MeasureFn
(MultiplicationFn ?NUMBER 453.59237)
Gram)))
Wenn number ist ein fall von reelle Zahl , dann "number slug(s)" ist gleich ""number*" gram(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Slug)
(MeasureFn
(MultiplicationFn ?NUMBER 14593.90)
Gram)))
Wenn number ist ein fall von reelle Zahl , dann "number rankine degree(s)" ist gleich ""number*" kelvin degree(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER RankineDegree)
(MeasureFn
(MultiplicationFn ?NUMBER 1.8)
KelvinDegree)))
Wenn number ist ein fall von reelle Zahl , dann "number pound force(s)" ist gleich ""number*" newton(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER PoundForce)
(MeasureFn
(MultiplicationFn ?NUMBER 4.448222)
Newton)))
Wenn number ist ein fall von reelle Zahl , dann "number calorie(s)" ist gleich ""number*" joule(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Calorie)
(MeasureFn
(MultiplicationFn ?NUMBER 4.1868)
Joule)))
Wenn number ist ein fall von reelle Zahl , dann "number british thermal unit(s)" ist gleich ""number*" joule(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER BritishThermalUnit)
(MeasureFn
(MultiplicationFn ?NUMBER 1055.05585262)
Joule)))
Wenn number ist ein fall von reelle Zahl , dann "number angular degree(s)" ist gleich ""number*"Pi/"" radian(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER AngularDegree)
(MeasureFn
(MultiplicationFn
?NUMBER
(DivisionFn Pi 180))
Radian)))
Wenn number ist ein fall von reelle Zahl , dann "number united states cent(s)" ist gleich ""number*" united states dollar(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER UnitedStatesCent)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
UnitedStatesDollar)))
Wenn number ist ein fall von reelle Zahl , dann "number euro cent(s)" ist gleich ""number*" euro dollar(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER EuroCent)
(MeasureFn
(MultiplicationFn ?NUMBER 0.01)
EuroDollar)))
Wenn number ist ein fall von reelle Zahl , dann "number byte(s)" ist gleich ""number*" bit(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER Byte)
(MeasureFn
(MultiplicationFn ?NUMBER 8)
Bit)))
Wenn number ist ein fall von reelle Zahl , dann "number kilo byte(s)" ist gleich ""number*" byte(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER KiloByte)
(MeasureFn
(MultiplicationFn ?NUMBER 1024)
Byte)))
Wenn number ist ein fall von reelle Zahl , dann "number mega byte(s)" ist gleich ""number*" kilo byte(s)" .
(=>
(instance ?NUMBER RealNumber)
(equal
(MeasureFn ?NUMBER MegaByte)
(MeasureFn
(MultiplicationFn ?NUMBER 1024)
KiloByte)))
Wenn der abstand zwischen obj1 und obj2 ist quant, dann der abstand zwischen obj2 und obj1 ist quant.
(=>
(distance ?OBJ1 ?OBJ2 ?QUANT)
(distance ?OBJ2 ?OBJ1 ?QUANT))
Wenn das altitude von obj1 ist obj2 , dann obj1 ist above hinsichlich obj2 .
(=>
(altitude ?OBJ1 ?OBJ2 ?HEIGHT)
(orientation ?OBJ1 ?OBJ2 Above))
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 obj1 ist below hinsichlich obj2 .
(=>
(depth ?OBJ1 ?OBJ2 ?DEPTH)
(orientation ?OBJ1 ?OBJ2 Below))
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 process beginnet an obj , dann "die Stelle wo process an "der anfang von "die zeit des Bestehens von process"" war" befindet sich an .
(=>
(origin ?PROCESS ?OBJ)
(located
(WhereFn
?PROCESS
(BeginFn
(WhenFn ?PROCESS)))
(WhereFn
?OBJ
(BeginFn
(WhenFn ?OBJ)))))
- 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))))
- 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))))))
- wenn obj ist ein resultat von proc ,
- dann für jeden time gilt: wenn time geschieht vor "der anfang von "die zeit des Bestehens von proc"" , dann obj besteht während time nicht
.
(=>
(result ?PROC ?OBJ)
(forall
(?TIME)
(=>
(before
?TIME
(BeginFn
(WhenFn ?PROC)))
(not
(time ?OBJ ?TIME)))))
Wenn point1 geschieht vor oder gleichzeitig mit point2 , dann point1 geschieht vor point2 oder point1 ist gleich point2 .
(=>
(beforeOrEqual ?POINT1 ?POINT2)
(or
(before ?POINT1 ?POINT2)
(equal ?POINT1 ?POINT2)))
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 "abstand zwischen point1 und point2" ist gleich interval , dann für jeden point gilt: point ist zwischen oder gleichzeitig mit point1 und point2 nur wenn point ist ein teil von interval .
(=>
(equal
(TimeIntervalFn ?POINT1 ?POINT2)
?INTERVAL)
(forall
(?POINT)
(<=>
(temporallyBetweenOrEqual ?POINT1 ?POINT ?POINT2)
(temporalPart ?POINT ?INTERVAL))))
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 thing ist ein fall von körperlicher Gegenstand , dann "der anfang von "die zeit des Bestehens von thing"" geschieht vor "das ende von "die zeit des Bestehens von thing"" .
(=>
(instance ?THING Physical)
(before
(BeginFn
(WhenFn ?THING))
(EndFn
(WhenFn ?THING))))
Wenn thing ist ein fall von körperlicher Gegenstand , dann "vor "die zeit des Bestehens von thing"" schliesst "die zeit des Bestehens von thing" zeitlich an.
(=>
(instance ?THING Physical)
(meetsTemporally
(PastFn
(WhenFn ?THING))
(WhenFn ?THING)))
Wenn process ist ein fall von körperlicher Gegenstand , dann "vor "die zeit des Bestehens von process"" ist gleich "abstand zwischen negative infinity und "der anfang von "die zeit des Bestehens von process""" .
(=>
(instance ?PROCESS Physical)
(equal
(PastFn
(WhenFn ?PROCESS))
(TimeIntervalFn
NegativeInfinity
(BeginFn
(WhenFn ?PROCESS)))))
Wenn thing ist ein fall von körperlicher Gegenstand , dann "direkt vor "die zeit des Bestehens von thing"" beendet "vor "die zeit des Bestehens von thing"" .
(=>
(instance ?THING Physical)
(finishes
(ImmediatePastFn
(WhenFn ?THING))
(PastFn
(WhenFn ?THING))))
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 thing ist ein fall von körperlicher Gegenstand , dann "die zeit des Bestehens von thing" schliesst "nach "die zeit des Bestehens von thing"" zeitlich an.
(=>
(instance ?THING Physical)
(meetsTemporally
(WhenFn ?THING)
(FutureFn
(WhenFn ?THING))))
Wenn process ist ein fall von körperlicher Gegenstand , dann "nach "die zeit des Bestehens von process"" ist gleich "abstand zwischen "das ende von "die zeit des Bestehens von process"" und positive infinity" .
(=>
(instance ?PROCESS Physical)
(equal
(FutureFn
(WhenFn ?PROCESS))
(TimeIntervalFn
(EndFn
(WhenFn ?PROCESS))
PositiveInfinity)))
Wenn thing ist ein fall von körperlicher Gegenstand , dann "sofort nach "die zeit des Bestehens von thing"" beginnt "nach "die zeit des Bestehens von thing"" .
(=>
(instance ?THING Physical)
(starts
(ImmediateFutureFn
(WhenFn ?THING))
(FutureFn
(WhenFn ?THING))))
Wenn day ist ein fall von "der tag number" , dann number ist kleinerAlsOderGleich .
(=>
(instance
?DAY
(DayFn ?NUMBER ?MONTH))
(lessThanOrEqualTo ?NUMBER 31))
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 hour ist ein fall von "die stunde number" , dann number ist kleinerAls .
(=>
(instance
?HOUR
(HourFn ?NUMBER ?DAY))
(lessThan ?NUMBER 24))
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 minute ist ein fall von "die minute number" , dann number ist kleinerAls .
(=>
(instance
?MINUTE
(MinuteFn ?NUMBER ?HOUR))
(lessThan ?NUMBER 60))
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 second ist ein fall von "die sekund number" , dann number ist kleinerAls .
(=>
(instance
?SECOND
(SecondFn ?NUMBER ?MINUTE))
(lessThan ?NUMBER 60))
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 year ist ein fall von Jahr , dann dauer von year ist " year duration(s)" .
(=>
(instance ?YEAR Year)
(duration
?YEAR
(MeasureFn 1 YearDuration)))
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 month ist ein fall von Januar , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH January)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 month ist ein fall von März , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH March)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 month ist ein fall von April , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH April)
(duration
?MONTH
(MeasureFn 30 DayDuration)))
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 month ist ein fall von Mai , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH May)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 month ist ein fall von Juni , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH June)
(duration
?MONTH
(MeasureFn 30 DayDuration)))
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 month ist ein fall von Juli , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH July)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 month ist ein fall von August , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH August)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 month ist ein fall von September , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH September)
(duration
?MONTH
(MeasureFn 30 DayDuration)))
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 month ist ein fall von Oktober , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH October)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 month ist ein fall von November , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH November)
(duration
?MONTH
(MeasureFn 30 DayDuration)))
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 month ist ein fall von Dezember , dann dauer von month ist " day duration(s)" .
(=>
(instance ?MONTH December)
(duration
?MONTH
(MeasureFn 31 DayDuration)))
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 day ist ein fall von Tag , dann dauer von day ist " day duration(s)" .
(=>
(instance ?DAY Day)
(duration
?DAY
(MeasureFn 1 DayDuration)))
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 week ist ein fall von Woche , dann dauer von week ist " week duration(s)" .
(=>
(instance ?WEEK Week)
(duration
?WEEK
(MeasureFn 1 WeekDuration)))
Wenn hour ist ein fall von Stunde , dann dauer von hour ist " hour duration(s)" .
(=>
(instance ?HOUR Hour)
(duration
?HOUR
(MeasureFn 1 HourDuration)))
Wenn minute ist ein fall von Minute , dann dauer von minute ist " minute duration(s)" .
(=>
(instance ?MINUTE Minute)
(duration
?MINUTE
(MeasureFn 1 MinuteDuration)))
Wenn second ist ein fall von Sekunde , dann dauer von second ist " second duration(s)" .
(=>
(instance ?SECOND Second)
(duration
?SECOND
(MeasureFn 1 SecondDuration)))
- 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 year ist ein fall von Jahr , dann "die Zahl Fällen in "Aufspaltung von year auf ? Monats"" ist gleich .
(=>
(instance ?YEAR Year)
(equal
(CardinalityFn
(TemporalCompositionFn ?YEAR Month))
12))
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))
Wenn week ist ein fall von Woche , dann "die Zahl Fällen in "Aufspaltung von week auf ? Tags"" ist gleich .
(=>
(instance ?WEEK Week)
(equal
(CardinalityFn
(TemporalCompositionFn ?WEEK Day))
7))
Wenn day ist ein fall von Tag , dann "die Zahl Fällen in "Aufspaltung von day auf ? Stundes"" ist gleich .
(=>
(instance ?DAY Day)
(equal
(CardinalityFn
(TemporalCompositionFn ?DAY Hour))
24))
Wenn hour ist ein fall von Stunde , dann "die Zahl Fällen in "Aufspaltung von hour auf ? Minutes"" ist gleich .
(=>
(instance ?HOUR Hour)
(equal
(CardinalityFn
(TemporalCompositionFn ?HOUR Minute))
60))
Wenn minute ist ein fall von Minute , dann "die Zahl Fällen in "Aufspaltung von minute auf ? Sekundes"" ist gleich .
(=>
(instance ?MINUTE Minute)
(equal
(CardinalityFn
(TemporalCompositionFn ?MINUTE Second))
60))
Wenn obj1 wird an obj2 angeschlossen, dann obj1 schliesst obj2 räumlich an oder obj1 deckt sich mit obj2 räumlich .
(=>
(connected ?OBJ1 ?OBJ2)
(or
(meetsSpatially ?OBJ1 ?OBJ2)
(overlapsSpatially ?OBJ1 ?OBJ2)))
obj ist ein fall von selbstverbundener Gegenstand nur wenn für jeden part1,part2 gilt: wenn obj ist gleich "die vereinigung von den teilen von part1 und part2" , dann part1 wird an part2 angeschlossen.
(<=>
(instance ?OBJ SelfConnectedObject)
(forall
(?PART1 ?PART2)
(=>
(equal
?OBJ
(MereologicalSumFn ?PART1 ?PART2))
(connected ?PART1 ?PART2))))
Wenn obj befindet sich teils an , dann obj deckt sich mit region räumlich .
(=>
(partlyLocated ?OBJ ?REGION)
(overlapsSpatially ?OBJ ?REGION))
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)))
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 obj1 ist eine fläche von obj2 ,
- dann für jeden obj3 gilt: wenn obj3 ist ein oberflächliches teil von obj2 , dann obj3 ist ein teil von obj1
.
(=>
(surface ?OBJ1 ?OBJ2)
(forall
(?OBJ3)
(=>
(superficialPart ?OBJ3 ?OBJ2)
(part ?OBJ3 ?OBJ1))))
- wenn obj1 ist ein innenteil von obj2 ,
- dann für jeden part gilt: wenn part ist ein oberflächliches teil von obj2 , dann obj1 deckt sich mit part räumlich nicht
.
(=>
(interiorPart ?OBJ1 ?OBJ2)
(forall
(?PART)
(=>
(superficialPart ?PART ?OBJ2)
(not
(overlapsSpatially ?OBJ1 ?PART)))))
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)))
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 "die vereinigung 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 oder part ist ein teil von obj2 .
(=>
(equal
?OBJ3
(MereologicalSumFn ?OBJ1 ?OBJ2))
(forall
(?PART)
(<=>
(part ?PART ?OBJ3)
(or
(part ?PART ?OBJ1)
(part ?PART ?OBJ2)))))
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 obj , dann obj ist ein fall von Loch nicht.
(=>
(hole ?HOLE ?OBJ)
(not
(instance ?OBJ Hole)))
Wenn hole ist ein loch in obj , dann hole deckt sich mit obj räumlich nicht.
(=>
(hole ?HOLE ?OBJ)
(not
(overlapsSpatially ?HOLE ?OBJ)))
Wenn hole ist ein loch in obj1 und hole ist ein loch in obj2 , dann es gibt ein obj3 der obj3 ist ein korrektes teil von "der durchschnitt von den teilen von obj1 und obj2" und hole ist ein loch in obj3 .
(=>
(and
(hole ?HOLE ?OBJ1)
(hole ?HOLE ?OBJ2))
(exists
(?OBJ3)
(and
(properPart
?OBJ3
(MereologicalProductFn ?OBJ1 ?OBJ2))
(hole ?HOLE ?OBJ3))))
- wenn hole1 ist ein 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 hole1 ist ein fall von Loch , dann es gibt ein hole2 der hole2 ist ein korrektes teil von hole1 .
(=>
(instance ?HOLE1 Hole)
(exists
(?HOLE2)
(properPart ?HOLE2 ?HOLE1)))
Wenn obj1 ist gleich "der wirt von dem Loch hole" , dann für jeden obj2 gilt: obj2 deckt sich mit obj1 räumlich nur wenn es gibt ein obj3 der hole ist ein loch in obj3 und obj2 deckt sich mit obj3 räumlich .
(=>
(equal
?OBJ1
(PrincipalHostFn ?HOLE))
(forall
(?OBJ2)
(<=>
(overlapsSpatially ?OBJ2 ?OBJ1)
(exists
(?OBJ3)
(and
(hole ?HOLE ?OBJ3)
(overlapsSpatially ?OBJ2 ?OBJ3))))))
Wenn hole ist ein loch in obj , dann hole wird an obj angeschlossen.
(=>
(hole ?HOLE ?OBJ)
(connected ?HOLE ?OBJ))
Wenn hole1 ist ein fall von Loch und hole2 ist ein korrektes teil von hole1 , dann es gibt ein obj der hole1 schliesst obj räumlich an und hole2 schliesst obj räumlich nicht an.
(=>
(and
(instance ?HOLE1 Hole)
(properPart ?HOLE2 ?HOLE1))
(exists
(?OBJ)
(and
(meetsSpatially ?HOLE1 ?OBJ)
(not
(meetsSpatially ?HOLE2 ?OBJ)))))
Wenn es gibt ein time der "obj füllt hole " hält während time , dann fillable ist ein attribut von hole .
(=>
(exists
(?TIME)
(holdsDuring
?TIME
(fills ?OBJ ?HOLE)))
(attribute ?HOLE Fillable))
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 vollständig,
- dann für jeden obj2 gilt: wenn obj2 wird an hole angeschlossen, dann obj2 wird an obj1 angeschlossen
.
(=>
(completelyFills ?OBJ1 ?HOLE)
(forall
(?OBJ2)
(=>
(connected ?OBJ2 ?HOLE)
(connected ?OBJ2 ?OBJ1))))
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 subproc ist ein subProzess von proc, dann "die zeit des Bestehens von subproc" ist gleich "die zeit des Bestehens von proc" oder "die zeit des Bestehens von subproc" geschieht während "die zeit des Bestehens von proc" .
(=>
(subProcess ?SUBPROC ?PROC)
(or
(equal
(WhenFn ?SUBPROC)
(WhenFn ?PROC))
(during
(WhenFn ?SUBPROC)
(WhenFn ?PROC))))
- wenn subproc ist ein subProzess von proc,
- dann für jeden region gilt: wenn proc befindet sich an , dann subproc befindet sich an
.
(=>
(subProcess ?SUBPROC ?PROC)
(forall
(?REGION)
(=>
(located ?PROC ?REGION)
(located ?SUBPROC ?REGION))))
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))))
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)))))
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))
Wenn sell ist ein fall von Verkaufen und sell ist der agent von agent , dann sell beginnet an agent .
(=>
(and
(instance ?SELL Selling)
(agent ?SELL ?AGENT))
(origin ?SELL ?AGENT))
Wenn learn ist ein fall von Lernen und learn ist der agent von agent , dann agent ist ein fall von kognitiver Agent .
(=>
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT))
(instance ?AGENT CognitiveAgent))
Wenn "es gibt ein Lernen learn der learn ist der agent von agent und prop ist ein patient von learn " hält während time , dann "agent glaubt , dass prop" hält während "sofort nach time" .
(=>
(holdsDuring
?TIME
(exists
(?LEARN)
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT)
(patient ?LEARN ?PROP))))
(holdsDuring
(ImmediateFutureFn ?TIME)
(believes ?AGENT ?PROP)))
Wenn agent ist ein fall von kognitiver Agent , dann agent ist fähig , in der Rolle agent logisches Denken zu tun.
(=>
(instance ?AGENT CognitiveAgent)
(capability Reasoning agent ?AGENT))
Wenn meas ist ein fall von Messen und meas ist der agent von agent und obj ist ein patient von meas , dann es gibt ein quant,unit der "agent kennt "das mass von obj ist "quant unit(s)" " " hält während "sofort nach "die zeit des Bestehens von meas"" .
(=>
(and
(instance ?MEAS Measuring)
(agent ?MEAS ?AGENT)
(patient ?MEAS ?OBJ))
(exists
(?QUANT ?UNIT)
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MEAS))
(knows
?AGENT
(measure
?OBJ
(MeasureFn ?QUANT ?UNIT))))))
Wenn count ist ein fall von Zählen und count ist der agent von agent und entity ist ein patient von count , dann es gibt ein number der agent kennt ""die Zahl Fällen in entity" ist gleich number " .
(=>
(and
(instance ?COUNT Counting)
(agent ?COUNT ?AGENT)
(patient ?COUNT ?ENTITY))
(exists
(?NUMBER)
(knows
?AGENT
(equal
(CardinalityFn ?ENTITY)
?NUMBER))))
Wenn 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))))
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)))))
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))
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)))
Wenn action ist ein fall von Kreation , dann es gibt ein result der result ist ein resultat von action .
(=>
(instance ?ACTION Creation)
(exists
(?RESULT)
(result ?ACTION ?RESULT)))
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 cooperate ist ein fall von Mitarbeit ,
- dann es gibt ein purp der für jeden agent gilt: wenn cooperate ist der agent von agent , dann cooperate hat Zweck von purp für agent
.
(=>
(instance ?COOPERATE Cooperation)
(exists
(?PURP)
(forall
(?AGENT)
(=>
(agent ?COOPERATE ?AGENT)
(hasPurposeForAgent ?COOPERATE ?PURP ?AGENT)))))
Wenn meet ist ein fall von Sitzung und meet ist der agent von agent1 und meet ist der agent von agent2 , dann "agent1 ist near hinsichlich agent2 " hält während "die zeit des Bestehens von meet" .
(=>
(and
(instance ?MEET Meeting)
(agent ?MEET ?AGENT1)
(agent ?MEET ?AGENT2))
(holdsDuring
(WhenFn ?MEET)
(orientation ?AGENT1 ?AGENT2 Near)))
Wenn meet ist ein fall von Sitzung , dann es gibt ein agent1,agent2 der meet ist der agent von agent1 und meet ist der agent von agent2 und meet hat Zweck von "es gibt ein Kommunikation comm der comm ist der agent von agent1 und comm ist der agent von agent2 " .
(=>
(instance ?MEET Meeting)
(exists
(?AGENT1 ?AGENT2)
(and
(agent ?MEET ?AGENT1)
(agent ?MEET ?AGENT2)
(hasPurpose
?MEET
(exists
(?COMM)
(and
(instance ?COMM Communication)
(agent ?COMM ?AGENT1)
(agent ?COMM ?AGENT2)))))))
Wenn contest ist ein fall von Kampf , dann es gibt ein agent1,agent2,purp1,purp2 der contest ist der agent von agent1 und contest ist der agent von agent2 und contest hat Zweck von purp1 für agent1 und contest hat Zweck von purp2 für agent2 und agent1 ist gleich agent2 nicht und purp1 ist gleich purp2 nicht.
(=>
(instance ?CONTEST Contest)
(exists
(?AGENT1 ?AGENT2 ?PURP1 ?PURP2)
(and
(agent ?CONTEST ?AGENT1)
(agent ?CONTEST ?AGENT2)
(hasPurposeForAgent ?CONTEST ?PURP1 ?AGENT1)
(hasPurposeForAgent ?CONTEST ?PURP2 ?AGENT2)
(not
(equal ?AGENT1 ?AGENT2))
(not
(equal ?PURP1 ?PURP2)))))
Wenn war ist ein fall von Krieg , 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 agent ist ein fall von empfindungsfähiger Agent , dann agent ist fähig , in der Rolle experiencer Wahrnehmung zu tun.
(=>
(instance ?AGENT SentientAgent)
(capability Perception experiencer ?AGENT))
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))))
Wenn emit ist ein fall von ausstrahlender Ton und emit ist der agent von sound , dann es gibt ein Tonsattribut attr der attr ist ein attribut von sound .
(=>
(and
(instance ?EMIT RadiatingSound)
(agent ?EMIT ?SOUND))
(exists
(?ATTR)
(and
(instance ?ATTR SoundAttribute)
(attribute ?SOUND ?ATTR))))
Wenn process ist ein fall von Zustandänderung und obj ist ein patient von process , dann es gibt ein part,körperliche Zustand state1,körperliche Zustand state2 der part ist ein teil von obj und state1 ist gleich state2 nicht und "state1 ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von process"" und "state2 ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .
(=>
(and
(instance ?PROCESS StateChange)
(patient ?PROCESS ?OBJ))
(exists
(?PART ?STATE1 ?STATE2)
(and
(part ?PART ?OBJ)
(instance ?STATE1 PhysicalState)
(instance ?STATE2 PhysicalState)
(not
(equal ?STATE1 ?STATE2))
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROCESS))
(attribute ?PART ?STATE1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FREEZE))
(attribute ?PART ?STATE2)))))
Wenn melt ist ein fall von schmelzend , dann es gibt ein Erhitzen heat der heat ist ein subProzess von melt.
(=>
(instance ?MELT Melting)
(exists
(?HEAT)
(and
(instance ?HEAT Heating)
(subProcess ?HEAT ?MELT))))
Wenn melt ist ein fall von schmelzend und obj ist ein patient von melt , dann es gibt ein part der part ist ein teil von obj und "solid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von melt"" und "liquid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von melt"" .
(=>
(and
(instance ?MELT Melting)
(patient ?MELT ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?MELT))
(attribute ?PART Solid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MELT))
(attribute ?PART Liquid)))))
Wenn boil ist ein fall von kochend , dann es gibt ein Erhitzen heat der heat ist ein subProzess von boil.
(=>
(instance ?BOIL Boiling)
(exists
(?HEAT)
(and
(instance ?HEAT Heating)
(subProcess ?HEAT ?BOIL))))
Wenn boil ist ein fall von kochend und obj ist ein patient von boil , dann es gibt ein part der part ist ein teil von obj und "liquid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von boil"" und "gas ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von boil"" .
(=>
(and
(instance ?BOIL Boiling)
(patient ?BOIL ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?BOIL))
(attribute ?PART Liquid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?BOIL))
(attribute ?PART Gas)))))
Wenn cond ist ein fall von kondensierend , dann es gibt ein Abkühlen cool der cool ist ein subProzess von cond.
(=>
(instance ?COND Condensing)
(exists
(?COOL)
(and
(instance ?COOL Cooling)
(subProcess ?COOL ?COND))))
Wenn cond ist ein fall von kondensierend und obj ist ein patient von cond , dann es gibt ein part der part ist ein teil von obj und "gas ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von cond"" und "liquid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von cond"" .
(=>
(and
(instance ?COND Condensing)
(patient ?COND ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COND))
(attribute ?PART Gas))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COND))
(attribute ?PART Liquid)))))
Wenn freeze ist ein fall von einfrierend , dann es gibt ein Abkühlen cool der cool ist ein subProzess von freeze.
(=>
(instance ?FREEZE Freezing)
(exists
(?COOL)
(and
(instance ?COOL Cooling)
(subProcess ?COOL ?FREEZE))))
Wenn freeze ist ein fall von einfrierend und obj ist ein patient von freeze , dann es gibt ein part der part ist ein teil von obj und "liquid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von freeze"" und "solid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .
(=>
(and
(instance ?FREEZE Freezing)
(patient ?FREEZE ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?FREEZE))
(attribute ?PART Liquid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FREEZE))
(attribute ?PART Solid)))))
Wenn area ist ein fall von Wassergebiet , dann es gibt ein bed,hole,Wasser water der "der wirt von dem Loch hole" ist gleich bed und water füllt hole richtig und "die vereinigung von den teilen von bed und water" ist gleich area .
(=>
(instance ?AREA WaterArea)
(exists
(?BED ?HOLE ?WATER)
(and
(equal
(PrincipalHostFn ?HOLE)
?BED)
(instance ?WATER Water)
(properlyFills ?WATER ?HOLE)
(equal
(MereologicalSumFn ?BED ?WATER)
?AREA))))
Wenn land1 ist ein fall von Landgebiet , dann es gibt ein land2 der land1 ist ein teil von land2 und land2 ist ein fall von Kontinent oder land2 ist ein fall von Insel .
(=>
(instance ?LAND1 LandArea)
(exists
(?LAND2)
(and
(part ?LAND1 ?LAND2)
(or
(instance ?LAND2 Continent)
(instance ?LAND2 Island)))))
Wenn island ist ein fall von Insel , dann es gibt kein Landgebiet area,part1,part2 der part1 ist ein teil von island und part2 ist ein teil von area und island ist ein teil von area nicht und area ist ein teil von island nicht und part1 wird an part2 angeschlossen.
(=>
(instance ?ISLAND Island)
(not
(exists
(?AREA ?PART1 ?PART2)
(and
(instance ?AREA LandArea)
(part ?PART1 ?ISLAND)
(part ?PART2 ?AREA)
(not
(part ?ISLAND ?AREA))
(not
(part ?AREA ?ISLAND))
(connected ?PART1 ?PART2)))))
Wenn state ist ein fall von Staat or Provinz , dann es gibt ein Nation land der state ist ein korrektes teil von land .
(=>
(instance ?STATE StateOrProvince)
(exists
(?LAND)
(and
(instance ?LAND Nation)
(properPart ?STATE ?LAND))))
Wenn "die entwicklungsForm von obj ist attr1" hält während time1 und attr2 ist ein nachfolgerattribut von attr1, dann es gibt ein time2 der time2 geschieht früh als time1 und "die entwicklungsForm von obj ist attr2" hält während time2 .
(=>
(and
(holdsDuring
?TIME1
(developmentalForm ?OBJ ?ATTR1))
(successorAttributeClosure ?ATTR2 ?ATTR1))
(exists
(?TIME2)
(and
(earlier ?TIME2 ?TIME1)
(holdsDuring
?TIME2
(developmentalForm ?OBJ ?ATTR2)))))
Wenn organism ist ein fall von Organismus , dann es gibt ein Geburt birth der organism erfährt birth .
(=>
(instance ?ORGANISM Organism)
(exists
(?BIRTH)
(and
(instance ?BIRTH Birth)
(experiencer ?BIRTH ?ORGANISM))))
Wenn organism wohnt in obj, dann es gibt ein time der "organism befindet sich an " hält während time .
(=>
(inhabits ?ORGANISM ?OBJ)
(exists
(?TIME)
(holdsDuring
?TIME
(located ?ORGANISM ?OBJ))))
Wenn parent ist das elterntiel von child , dann "der anfang von "die zeit des Bestehens von parent"" geschieht vor "der anfang von "die zeit des Bestehens von child"" .
(=>
(parent ?CHILD ?PARENT)
(before
(BeginFn
(WhenFn ?PARENT))
(BeginFn
(WhenFn ?CHILD))))
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))
Wenn parent ist das elterntiel von child , dann parent ist die mutter von child oder parent ist der vater von child .
(=>
(parent ?CHILD ?PARENT)
(or
(mother ?CHILD ?PARENT)
(father ?CHILD ?PARENT)))
Wenn organism ist ein fall von Organismus , dann es gibt ein parent der parent ist das elterntiel von organism .
(=>
(instance ?ORGANISM Organism)
(exists
(?PARENT)
(parent ?ORGANISM ?PARENT)))
Wenn mother ist die mutter von child , dann female ist ein attribut von mother .
(=>
(mother ?CHILD ?MOTHER)
(attribute ?MOTHER Female))
Wenn father ist der vater von child , dann male ist ein attribut von father .
(=>
(father ?CHILD ?FATHER)
(attribute ?FATHER Male))
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 bev ist ein fall von Getränk , dann liquid ist ein attribut von bev .
(=>
(instance ?BEV Beverage)
(attribute ?BEV Liquid))
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 organ ist ein fall von Organ , dann es gibt ein purp der organ hat Zweck von purp .
(=>
(instance ?ORGAN Organ)
(exists
(?PURP)
(hasPurpose ?ORGAN ?PURP)))
Wenn stuff ist ein fall von Gewebe , dann es gibt ein Zelle part der part ist ein teil von stuff .
(=>
(instance ?STUFF Tissue)
(exists
(?PART)
(and
(instance ?PART Cell)
(part ?PART ?STUFF))))
Wenn stuff ist ein fall von Gewebe , dann es gibt ein Organismus organism der stuff ist ein teil von organism .
(=>
(instance ?STUFF Tissue)
(exists
(?ORGANISM)
(and
(instance ?ORGANISM Organism)
(part ?STUFF ?ORGANISM))))
Wenn bone ist ein fall von Knochen , dann es gibt ein Wirbeltier vert der bone ist ein teil von vert .
(=>
(instance ?BONE Bone)
(exists
(?VERT)
(and
(instance ?VERT Vertebrate)
(part ?BONE ?VERT))))
Wenn morph ist ein fall von Morphem , dann es gibt kein Morphem othermorph der othermorph ist ein teil von morph und othermorph ist gleich morph nicht.
(=>
(instance ?MORPH Morpheme)
(not
(exists
(?OTHERMORPH)
(and
(instance ?OTHERMORPH Morpheme)
(part ?OTHERMORPH ?MORPH)
(not
(equal ?OTHERMORPH ?MORPH))))))
Wenn morph ist ein fall von Morphem , dann es gibt ein Wort word der morph ist ein teil von word .
(=>
(instance ?MORPH Morpheme)
(exists
(?WORD)
(and
(instance ?WORD Word)
(part ?MORPH ?WORD))))
Wenn word ist ein fall von Wort , dann es gibt ein Morphem part der part ist ein teil von word .
(=>
(instance ?WORD Word)
(exists
(?PART)
(and
(part ?PART ?WORD)
(instance ?PART Morpheme))))
Wenn phrase ist ein fall von Phrase , dann es gibt ein Wort part1,Wort part2 der part1 ist ein teil von phrase und part2 ist ein teil von phrase und part1 ist gleich part2 nicht.
(=>
(instance ?PHRASE Phrase)
(exists
(?PART1 ?PART2)
(and
(part ?PART1 ?PHRASE)
(part ?PART2 ?PHRASE)
(instance ?PART1 Word)
(instance ?PART2 Word)
(not
(equal ?PART1 ?PART2)))))
Wenn sentence ist ein fall von Satz , dann es gibt ein Nominalphrase phrase1,Verbphrase phrase2 der phrase1 ist ein teil von sentence und phrase2 ist ein teil von sentence .
(=>
(instance ?SENTENCE Sentence)
(exists
(?PHRASE1 ?PHRASE2)
(and
(instance ?PHRASE1 NounPhrase)
(instance ?PHRASE2 VerbPhrase)
(part ?PHRASE1 ?SENTENCE)
(part ?PHRASE2 ?SENTENCE))))
Wenn text ist ein fall von Text , dann es gibt ein Proposition prop der text enthält Informationen über prop.
(=>
(instance ?TEXT Text)
(exists
(?PROP)
(and
(instance ?PROP Proposition)
(containsInformation ?TEXT ?PROP))))
Wenn text ist ein fall von Text , dann es gibt ein Satz part der part ist ein teil von text .
(=>
(instance ?TEXT Text)
(exists
(?PART)
(and
(part ?PART ?TEXT)
(instance ?PART Sentence))))
Wenn text ist ein fall von Text , dann es gibt ein Schreiben write der text ist ein resultat von write .
(=>
(instance ?TEXT Text)
(exists
(?WRITE)
(and
(instance ?WRITE Writing)
(result ?WRITE ?TEXT))))
Wenn sent ist ein fall von Satz , dann es gibt ein Nominalphrase noun,Verbphrase verb der noun ist ein teil von sent und verb ist ein teil von sent .
(=>
(instance ?SENT Sentence)
(exists
(?NOUN ?VERB)
(and
(instance ?NOUN NounPhrase)
(instance ?VERB VerbPhrase)
(part ?NOUN ?SENT)
(part ?VERB ?SENT))))
Wenn agent ist der schreiber von text, dann es gibt ein process,text instance der process ist der agent von agent und text ist ein resultat von process .
(=>
(authors ?AGENT ?TEXT)
(exists
(?PROCESS ?INSTANCE)
(and
(agent ?PROCESS ?AGENT)
(instance ?INSTANCE ?TEXT)
(result ?PROCESS ?TEXT))))
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 "ausgabe number von text1" ist gleich text2 , dann text1 fasst das Inhalt von text2 zusammen.
(=>
(equal
(EditionFn ?TEXT1 ?NUMBER)
?TEXT2)
(subsumesContentClass ?TEXT1 ?TEXT2))
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 "Band number in der reihe series" ist gleich volume , dann series fasst das Inhalt von volume zusammen.
(=>
(equal
(SeriesVolumeFn ?SERIES ?NUMBER)
?VOLUME)
(subsumesContentClass ?SERIES ?VOLUME))
Wenn "die Zahl von periodikum number von periodical" ist gleich issue , dann periodical fasst das Inhalt von issue zusammen.
(=>
(equal
(PeriodicalIssueFn ?PERIODICAL ?NUMBER)
?ISSUE)
(subsumesContentClass ?PERIODICAL ?ISSUE))
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)))))
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 artifact1 ist eine version von artifact2, dann artifact1 ist eine teilkategorie von artifact2.
(=>
(version ?ARTIFACT1 ?ARTIFACT2)
(subclass ?ARTIFACT1 ?ARTIFACT2))
- 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 instrument ist ein fall von Musikinstrument , dann instrument ist fähig , in der Rolle instrument Musik zu tun.
(=>
(instance ?INSTRUMENT MusicalInstrument)
(capability Music instrument ?INSTRUMENT))
Wenn device ist ein fall von Transportvorrichtung , dann device ist fähig , in der Rolle instrument Transport zu tun.
(=>
(instance ?DEVICE TransportationDevice)
(capability Transportation instrument ?DEVICE))
Wenn weapon ist ein fall von Waffe , dann weapon ist fähig , in der Rolle instrument Beschädigen zu tun.
(=>
(instance ?WEAPON Weapon)
(capability Damaging instrument ?WEAPON))
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 comp1 wird mit comp2 angeschlossen, dann comp1 ist ein fall von Technikanschluss nicht und comp2 ist ein fall von Technikanschluss nicht.
(=>
(connectedEngineeringComponents ?COMP1 ?COMP2)
(not
(or
(instance ?COMP1 EngineeringConnection)
(instance ?COMP2 EngineeringConnection))))
Wenn connection ist ein fall von Technikanschluss , dann es gibt ein comp1,comp2 der connection schliesst comp1 und comp2 an.
(=>
(instance ?CONNECTION EngineeringConnection)
(exists
(?COMP1 ?COMP2)
(connectsEngineeringComponents ?CONNECTION ?COMP1 ?COMP2)))
Wenn 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 org beschäftigt person , dann person ist ein Mitglied von org .
(=>
(employs ?ORG ?PERSON)
(member ?PERSON ?ORG))
Wenn pol ist ein fall von politische Organisation , dann es gibt ein politischer Prozess proc der proc ist der agent von pol .
(=>
(instance ?POL PoliticalOrganization)
(exists
(?PROC)
(and
(instance ?PROC PoliticalProcess)
(agent ?PROC ?POL))))
Wenn plan ist ein fall von Plan und obj ist ein fall von Inhaltsgegenstand und obj enthält Informationen über plan, dann es gibt ein Planen planning der obj ist ein resultat von planning .
(=>
(and
(instance ?PLAN Plan)
(instance ?OBJ ContentBearingObject)
(containsInformation ?OBJ ?PLAN))
(exists
(?PLANNING)
(and
(instance ?PLANNING Planning)
(result ?PLANNING ?OBJ))))
Wenn plan ist ein fall von Plan , dann es gibt ein purp der plan hat Zweck von purp .
(=>
(instance ?PLAN Plan)
(exists
(?PURP)
(hasPurpose ?PLAN ?PURP)))
Wenn 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 "Wesen bei proc bewegen attr1" hält während time ,
- dann für jeden attr2 gilt: wenn "Wesen bei proc bewegen attr2" hält während time , dann attr2 ist gleich attr1
.
(=>
(holdsDuring
?TIME
(direction ?PROC ?ATTR1))
(forall
(?ATTR2)
(=>
(holdsDuring
?TIME
(direction ?PROC ?ATTR2))
(equal ?ATTR2 ?ATTR1))))
- wenn "proc stellet attr1 gegenüber" hält während time ,
- dann für jeden attr2 gilt: wenn "proc stellet attr2 gegenüber" hält während time , dann attr2 ist gleich attr1
.
(=>
(holdsDuring
?TIME
(faces ?PROC ?ATTR1))
(forall
(?ATTR2)
(=>
(holdsDuring
?TIME
(faces ?PROC ?ATTR2))
(equal ?ATTR2 ?ATTR1))))
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 formula hat ein attribut likely , dann "die wahrscheinlichkeit von "formula ist true "" ist grösserAls "die wahrscheinlichkeit von "formula ist false "" .
(=>
(property ?FORMULA Likely)
(greaterThan
(ProbabilityFn
(true ?FORMULA True))
(ProbabilityFn
(true ?FORMULA False))))
Wenn formula hat ein attribut unlikely , dann "die wahrscheinlichkeit von "formula ist false "" ist grösserAls "die wahrscheinlichkeit von "formula ist true "" .
(=>
(property ?FORMULA Unlikely)
(greaterThan
(ProbabilityFn
(true ?FORMULA False))
(ProbabilityFn
(true ?FORMULA True))))
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 obj1 ist above hinsichlich obj2 , dann obj1 wird an obj2 nicht angeschlossen.
(=>
(orientation ?OBJ1 ?OBJ2 Above)
(not
(connected ?OBJ1 ?OBJ2)))
Wenn obj1 ist below hinsichlich obj2 , dann obj2 ist on hinsichlich obj1 oder obj2 ist above hinsichlich obj1 .
(=>
(orientation ?OBJ1 ?OBJ2 Below)
(or
(orientation ?OBJ2 ?OBJ1 On)
(orientation ?OBJ2 ?OBJ1 Above)))
Wenn obj1 ist adjacent hinsichlich obj2 , dann obj1 ist near hinsichlich obj2 oder obj1 wird an obj2 angeschlossen.
(=>
(orientation ?OBJ1 ?OBJ2 Adjacent)
(or
(orientation ?OBJ1 ?OBJ2 Near)
(connected ?OBJ1 ?OBJ2)))
Wenn obj1 ist near hinsichlich obj2 , dann obj1 wird an obj2 nicht angeschlossen.
(=>
(orientation ?OBJ1 ?OBJ2 Near)
(not
(connected ?OBJ1 ?OBJ2)))
Wenn obj1 ist near hinsichlich obj2 , dann obj2 ist near hinsichlich obj1 .
(=>
(orientation ?OBJ1 ?OBJ2 Near)
(orientation ?OBJ2 ?OBJ1 Near))
Wenn obj1 ist on hinsichlich obj2 , dann obj1 wird an obj2 angeschlossen.
(=>
(orientation ?OBJ1 ?OBJ2 On)
(connected ?OBJ1 ?OBJ2))
Wenn obj1 ist on hinsichlich obj2 , dann obj1 befindet sich an .
(=>
(orientation ?OBJ1 ?OBJ2 On)
(located ?OBJ1 ?OBJ2))
Wenn obj1 ist on hinsichlich obj2 , dann obj2 ist on hinsichlich obj1 nicht.
(=>
(orientation ?OBJ1 ?OBJ2 On)
(not
(orientation ?OBJ2 ?OBJ1 On)))
Wenn "" ist gleich time2 , dann time2 ist gleich "(time1+)" .
(=>
(equal
(RelativeTimeFn ?TIME1 PacificTimeZone)
?TIME2)
(equal
?TIME2
(AdditionFn ?TIME1 8)))
Wenn "" ist gleich time2 , dann time2 ist gleich "(time1+)" .
(=>
(equal
(RelativeTimeFn ?TIME1 MountainTimeZone)
?TIME2)
(equal
?TIME2
(AdditionFn ?TIME1 7)))
Wenn "" ist gleich time2 , dann time2 ist gleich "(time1+)" .
(=>
(equal
(RelativeTimeFn ?TIME1 CentralTimeZone)
?TIME2)
(equal
?TIME2
(AdditionFn ?TIME1 6)))
Wenn "" ist gleich time2 , dann time2 ist gleich "(time1+)" .
(=>
(equal
(RelativeTimeFn ?TIME1 EasternTimeZone)
?TIME2)
(equal
?TIME2
(AdditionFn ?TIME1 5)))
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))
Wenn org beschäftigt person , dann es gibt ein position der person besetzt die position von position in org.
(=>
(employs ?ORG ?PERSON)
(exists
(?POSITION)
(occupiesPosition ?PERSON ?POSITION ?ORG)))
Wenn 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)))))
Wenn die Aussage formula hat die modale Kraft von necessity, dann die Aussage formula hat die modale Kraft von possibility.
(=>
(modalAttribute ?FORMULA Necessity)
(modalAttribute ?FORMULA Possibility))
Wenn die Aussage formula hat die modale Kraft von obligation, dann die Aussage formula hat die modale Kraft von permission.
(=>
(modalAttribute ?FORMULA Obligation)
(modalAttribute ?FORMULA Permission))
Wenn entity hat ein attribut promise , dann entity hat ein attribut contract oder entity hat ein attribut naked promise .
(=>
(property ?ENTITY Promise)
(or
(property ?ENTITY Contract)
(property ?ENTITY NakedPromise)))
Wenn obj ist ein fall von Lösung , dann liquid ist ein attribut von obj .
(=>
(instance ?OBJ Solution)
(attribute ?OBJ Liquid))
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 obj ist ein fall von Gegenstand , dann monochromatic ist ein attribut von obj oder polychromatic ist ein attribut von obj .
(=>
(instance ?OBJ Object)
(or
(attribute ?OBJ Monochromatic)
(attribute ?OBJ Polychromatic)))
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 obj ist ein fall von selbstverbundener Gegenstand , dann pliable ist ein attribut von obj oder rigid ist ein attribut von obj .
(=>
(instance ?OBJ SelfConnectedObject)
(or
(attribute ?OBJ Pliable)
(attribute ?OBJ Rigid)))
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))))))
(=>
(instance ?ATTR PsychologicalAttribute)
(=>
(holdsDuring
?TIME
(attribute ?ORGANISM ?ATTR))
(holdsDuring
?TIME
(attribute ?ORGANISM Living))))
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))
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 "der durchschnitt aller Elementen von superclass" nur wenn für jeden class gilt: wenn class ist ein fall von superclass , dann entity ist ein fall von class .
(<=>
(instance
?ENTITY
(GeneralizedIntersectionFn ?SUPERCLASS))
(forall
(?CLASS)
(=>
(instance ?CLASS ?SUPERCLASS)
(instance ?ENTITY ?CLASS))))
