not (not)
The truth-functional connective of negation.
Ontology
SUMO / STRUCTURAL-ONTOLOGYClass(es)
Coordinate term(s)
<=>
=>
and
hatZurFolge
exists
forall
or
Type restrictions
not(Formel)
Related WordNet synsets
- negation
- the negative of the opposition
- not
- negation of a word or group of words; "he does not speak French"; "she is not going"; "they are not friends"; "not many"; "not much"; "not at all"
- no
- not in any degree or manner; not at all; "he is no better today"
See more related synsets on a separate page.
Axioms (121)
Wenn entity ist ein direkter fall von class, dann es gibt kein class subclass der entity ist ein fall von subclass .
(=>
(immediateInstance ?ENTITY ?CLASS)
(not
(exists
(?SUBCLASS)
(and
(subclass ?SUBCLASS ?CLASS)
(instance ?ENTITY ?SUBCLASS)))))
Wenn class1 ist eine direkte teilkategorie von class2, dann es gibt kein class2 class3 der class1 ist eine teilkategorie von class3 und class2 ist gleich class3 nicht und class1 ist gleich class3 nicht.
(=>
(immediateSubclass ?CLASS1 ?CLASS2)
(not
(exists
(?CLASS3)
(and
(subclass ?CLASS3 ?CLASS2)
(subclass ?CLASS1 ?CLASS3)
(not
(equal ?CLASS2 ?CLASS3))
(not
(equal ?CLASS1 ?CLASS3))))))
class1 ist dijunkt von class2 nur wenn
(<=>
(disjoint ?CLASS1 ?CLASS2)
(and
(instance ?CLASS1 SetOrClass)
(instance ?CLASS2 SetOrClass)
(forall
(?INST)
(not
(and
(instance ?INST ?CLASS1)
(instance ?INST ?CLASS2))))))
Wenn und ? werden disjunkt und rel1 ist ein Mitglied von "()" und rel2 ist ein Mitglied von "()" und rel1 ist gleich rel2 nicht und rel1() gilt , dann rel2() gilt nicht.
(=>
(and
(disjointRelation @ROW1)
(inList
?REL1
(ListFn @ROW1))
(inList
?REL2
(ListFn @ROW1))
(not
(equal ?REL1 ?REL2))
(holds ?REL1 @ROW2))
(not
(holds ?REL2 @ROW2)))
- wenn wird ? entgegengesetzet ,
- dann für jeden attr1,attr2 gilt:
- wenn attr1 ist gleich "number1te mitglied von "()"" und attr2 ist gleich "number2te mitglied von "()"" und number1 ist gleich number2 nicht,
- dann wenn obj hat ein attribut attr1 , dann obj hat ein attribut attr2 nicht
.
(=>
(contraryAttribute @ROW)
(forall
(?ATTR1 ?ATTR2)
(=>
(and
(equal
?ATTR1
(ListOrderFn
(ListFn @ROW)
?NUMBER1))
(equal
?ATTR2
(ListOrderFn
(ListFn @ROW)
?NUMBER2))
(not
(equal ?NUMBER1 ?NUMBER2)))
(=>
(property ?OBJ ?ATTR1)
(not
(property ?OBJ ?ATTR2))))))
obj1 ist ein korrektes teil von obj2 nur wenn obj1 ist ein teil von obj2 und obj2 ist ein teil von obj1 nicht.
(<=>
(properPart ?OBJ1 ?OBJ2)
(and
(part ?OBJ1 ?OBJ2)
(not
(part ?OBJ2 ?OBJ1))))
Wenn 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 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 process ist ein fall von Doppelgegenstandprozess , dann es gibt ein obj1,obj2 der obj1 ist ein patient von process und obj2 ist ein patient von process und obj1 ist gleich obj2 nicht.
(=>
(instance ?PROCESS DualObjectProcess)
(exists
(?OBJ1 ?OBJ2)
(and
(patient ?PROCESS ?OBJ1)
(patient ?PROCESS ?OBJ2)
(not
(equal ?OBJ1 ?OBJ2)))))
abs ist ein fall von abstrakter Gegenstand nur wenn es gibt kein point der abs befindet sich an oder abs besteht während point .
(<=>
(instance ?ABS Abstract)
(not
(exists
(?POINT)
(or
(located ?ABS ?POINT)
(time ?ABS ?POINT)))))
Wenn 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 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 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 dreiwertige Relation , dann es gibt kein item1,item2,item3,item4, der rel(item1,item2,item3,item4,) gilt .
(=>
(instance ?REL TernaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))
Wenn rel ist ein fall von viewwertige Relation , dann es gibt kein item1,item2,item3,item4,item5, der rel(item1,item2,item3,item4,item5,) gilt .
(=>
(instance ?REL QuaternaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW))))
Wenn rel ist ein fall von fünfwertige Relation , dann es gibt kein item1,item2,item3,item4,item5,item6, der rel(item1,item2,item3,item4,item5,item6,) gilt .
(=>
(instance ?REL QuintaryRelation)
(not
(exists
(?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW)
(holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW))))
- wenn list ist ein fall von Liste ,
- dann es gibt ein number1 der es gibt ein item1 der "number1te mitglied von list" ist gleich item1 nicht und für jeden number2 gilt: wenn number2 ist ein fall von positive Ganzzahl und number2 ist kleinerAls number1 , dann es gibt ein item2 der "number2te mitglied von list" ist gleich item2
.
(=>
(instance ?LIST List)
(exists
(?NUMBER1)
(exists
(?ITEM1)
(and
(not
(equal
(ListOrderFn ?LIST ?NUMBER1)
?ITEM1))
(forall
(?NUMBER2)
(=>
(and
(instance ?NUMBER2 PositiveInteger)
(lessThan ?NUMBER2 ?NUMBER1))
(exists
(?ITEM2)
(equal
(ListOrderFn ?LIST ?NUMBER2)
?ITEM2))))))))
list ist gleich null list nur wenn es gibt kein item der item ist ein Mitglied von list.
(<=>
(equal ?LIST NullList)
(not
(exists
(?ITEM)
(inList ?ITEM ?LIST))))
- wenn class wird 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 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 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 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 "situation" hält während time , dann situation hält während time nicht.
(=>
(holdsDuring
?TIME
(not ?SITUATION))
(not
(holdsDuring ?TIME ?SITUATION)))
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 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 "die oberstegrenze von number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist grösserAlsOderGleich number und otherint ist kleinerAls int .
(=>
(equal
(CeilingFn ?NUMBER)
?INT)
(not
(exists
(?OTHERINT)
(and
(instance ?OTHERINT Integer)
(greaterThanOrEqualTo ?OTHERINT ?NUMBER)
(lessThan ?OTHERINT ?INT)))))
Wenn "die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist kleinerAlsOderGleich number und otherint ist grösserAls int .
(=>
(equal
(FloorFn ?NUMBER)
?INT)
(not
(exists
(?OTHERINT)
(and
(instance ?OTHERINT Integer)
(lessThanOrEqualTo ?OTHERINT ?NUMBER)
(greaterThan ?OTHERINT ?INT)))))
- wenn "die größte gemeinsamer teiler von " ist gleich number ,
- dann es gibt kein greater der greater ist grösserAls number und für jeden element gilt: wenn element ist ein Mitglied von "()", dann "element betrag greater" ist gleich
.
(=>
(equal
(GreatestCommonDivisorFn @ROW)
?NUMBER)
(not
(exists
(?GREATER)
(and
(greaterThan ?GREATER ?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?ELEMENT ?GREATER)
0)))))))
- wenn "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 int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int1 ist kleinerAls int2 nicht oder int2 ist kleinerAls "(int1+1)" nicht.
(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT1 ?INT2)
(lessThan
?INT2
(SuccessorFn ?INT1)))))
Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int2 ist kleinerAls int1 nicht oder "(int1+2)" ist kleinerAls int2 nicht.
(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT2 ?INT1)
(lessThan
(PredecessorFn ?INT1)
?INT2))))
Es gibt kein element der element ist ein element von null set .
(not
(exists
(?ELEMENT)
(element ?ELEMENT NullSet)))
(=>
(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 Baumstruktur , dann es gibt kein Graphschleife loop der loop ist ein teil von graph .
(=>
(instance ?GRAPH Tree)
(not
(exists
(?LOOP)
(and
(instance ?LOOP GraphLoop)
(graphPart ?LOOP ?GRAPH)))))
(=>
(and
(instance ?GRAPH GraphPath)
(instance ?ARC GraphArc)
(graphPart ?ARC ?GRAPH))
(=>
(equal
(InitialNodeFn ?ARC)
?NODE)
(not
(exists
(?OTHER)
(and
(equal
(InitialNodeFn ?OTHER)
?NODE)
(not
(equal ?OTHER ?ARC)))))))
(=>
(and
(instance ?GRAPH GraphPath)
(instance ?ARC GraphArc)
(graphPart ?ARC ?GRAPH))
(=>
(equal
(TerminalNodeFn ?ARC)
?NODE)
(not
(exists
(?OTHER)
(and
(equal
(TerminalNodeFn ?OTHER)
?NODE)
(not
(equal ?OTHER ?ARC)))))))
graph ist ein fall von Multigraph nur wenn es gibt ein arc1,arc2,node1,node2 der arc1 ist ein teil von graph und arc2 ist ein teil von graph und node1 ist ein teil von graph und node2 ist ein teil von graph und arc1 verbindet node1 und node2 und arc2 verbindet node1 und node2 und arc1 ist gleich arc2 nicht.
(<=>
(instance ?GRAPH MultiGraph)
(exists
(?ARC1 ?ARC2 ?NODE1 ?NODE2)
(and
(graphPart ?ARC1 ?GRAPH)
(graphPart ?ARC2 ?GRAPH)
(graphPart ?NODE1 ?GRAPH)
(graphPart ?NODE2 ?GRAPH)
(links ?NODE1 ?NODE2 ?ARC1)
(links ?NODE1 ?NODE2 ?ARC2)
(not
(equal ?ARC1 ?ARC2)))))
Wenn path ist ein teil von graph und graph ist ein fall von gerichtetes Graph nicht, dann "die menge von Pfaden zwischen node1 und node2" ist gleich path nur wenn "die menge von Pfaden zwischen node2 und node1" ist gleich path .
(=>
(and
(graphPart ?PATH ?GRAPH)
(not
(instance ?GRAPH DirectedGraph)))
(<=>
(equal
(GraphPathFn ?NODE1 ?NODE2)
?PATH)
(equal
(GraphPathFn ?NODE2 ?NODE1)
?PATH)))
Es gibt kein die menge von Pfaden die graph in zwei verschiedene Graphen schnitten path1,die menge von minimalen Pfaden die graph in zwei verschiedene Graphen schnitten path2 der die länge von path1 ist number1 und die länge von path2 ist number2 und number1 ist kleinerAls number2 .
(not
(exists
(?PATH1 ?PATH2)
(and
(instance
?PATH1
(CutSetFn ?GRAPH))
(instance
?PATH2
(MinimalCutSetFn ?GRAPH))
(pathLength ?PATH1 ?NUMBER1)
(pathLength ?PATH2 ?NUMBER2)
(lessThan ?NUMBER1 ?NUMBER2))))
Wenn 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 "der anfang von interval" ist gleich point ,
- dann für jeden otherpoint gilt: wenn otherpoint ist ein teil von interval und otherpoint ist gleich point nicht, dann point geschieht vor otherpoint
.
(=>
(equal
(BeginFn ?INTERVAL)
?POINT)
(forall
(?OTHERPOINT)
(=>
(and
(temporalPart ?OTHERPOINT ?INTERVAL)
(not
(equal ?OTHERPOINT ?POINT)))
(before ?POINT ?OTHERPOINT))))
- wenn "das ende von interval" ist gleich point ,
- dann für jeden otherpoint gilt: wenn otherpoint ist ein teil von interval und otherpoint ist gleich point nicht, dann otherpoint geschieht vor point
.
(=>
(equal
(EndFn ?INTERVAL)
?POINT)
(forall
(?OTHERPOINT)
(=>
(and
(temporalPart ?OTHERPOINT ?INTERVAL)
(not
(equal ?OTHERPOINT ?POINT)))
(before ?OTHERPOINT ?POINT))))
- 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 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 "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 "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 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))))))
obj1 schleisst obj2 und obj3 an nur wenn obj1 wird an obj2 angeschlossen und obj1 wird an obj3 angeschlossen und obj2 wird an obj3 nicht angeschlossen.
(<=>
(connects ?OBJ1 ?OBJ2 ?OBJ3)
(and
(connected ?OBJ1 ?OBJ2)
(connected ?OBJ1 ?OBJ3)
(not
(connected ?OBJ2 ?OBJ3))))
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)))
obj1 deckt sich mit obj2 teilweise nur wenn - obj1 ist ein teil von obj2 nicht
und - obj2 ist ein teil von obj1 nicht
und - es gibt ein obj3 der obj3 ist ein teil von obj1 und obj3 ist ein teil von obj2
.
(<=>
(overlapsPartially ?OBJ1 ?OBJ2)
(and
(not
(part ?OBJ1 ?OBJ2))
(not
(part ?OBJ2 ?OBJ1))
(exists
(?OBJ3)
(and
(part ?OBJ3 ?OBJ1)
(part ?OBJ3 ?OBJ2)))))
Wenn obj1 ist ein oberflächliches teil von obj2 , dann obj1 ist ein innenteil von obj2 nicht und es gibt kein obj3 der obj3 ist ein innenteil von obj1 .
(=>
(superficialPart ?OBJ1 ?OBJ2)
(and
(not
(interiorPart ?OBJ1 ?OBJ2))
(not
(exists
(?OBJ3)
(interiorPart ?OBJ3 ?OBJ1)))))
- wenn 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 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 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 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 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 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 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
- 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 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 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 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 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 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))))
process ist ein fall von Zerstörung nur wenn es gibt ein patient der patient ist ein patient von process und patient besteht während "direkt vor "die zeit des Bestehens von process"" und patient besteht während "sofort nach "die zeit des Bestehens von process"" nicht.
(<=>
(instance ?PROCESS Destruction)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))))))
Wenn attach ist ein fall von Befestigung und obj1 ist ein patient von attach und obj2 ist ein patient von attach , dann "obj1 wird an obj2 nicht angeschlossen" hält während "direkt vor "die zeit des Bestehens von attach"" und "obj1 wird an obj2 angeschlossen" hält während "sofort nach "die zeit des Bestehens von attach"" .
(=>
(and
(instance ?ATTACH Attaching)
(patient ?ATTACH ?OBJ1)
(patient ?ATTACH ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ATTACH))
(not
(connected ?OBJ1 ?OBJ2)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ATTACH))
(connected ?OBJ1 ?OBJ2))))
Wenn detach ist ein fall von Abtrennen und obj1 ist ein patient von detach und obj2 ist ein patient von detach , dann "obj1 wird an obj2 angeschlossen" hält während "direkt vor "die zeit des Bestehens von detach"" und "obj1 wird an obj2 nicht angeschlossen" hält während "sofort nach "die zeit des Bestehens von detach"" .
(=>
(and
(instance ?DETACH Detaching)
(patient ?DETACH ?OBJ1)
(patient ?DETACH ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?DETACH))
(connected ?OBJ1 ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DETACH))
(not
(connected ?OBJ1 ?OBJ2)))))
combine ist ein fall von Kombinieren und obj1 ist ein hilfmittel für combine und obj2 ist ein resultat von combine nur wenn "obj1 ist ein teil von obj2 nicht" hält während "direkt vor "die zeit des Bestehens von combine"" und "obj1 ist ein teil von obj2 " hält während "sofort nach "die zeit des Bestehens von combine"" .
(<=>
(and
(instance ?COMBINE Combining)
(resource ?COMBINE ?OBJ1)
(result ?COMBINE ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?COMBINE))
(not
(part ?OBJ1 ?OBJ2)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COMBINE))
(part ?OBJ1 ?OBJ2))))
compound ist ein fall von Verbindung nur wenn es gibt ein elementare Substanz element1,elementare Substanz element2,chemische Synthese process der element1 ist gleich element2 nicht und element1 ist ein hilfmittel für process und element2 ist ein hilfmittel für process und compound ist ein resultat von process .
(<=>
(instance ?COMPOUND CompoundSubstance)
(exists
(?ELEMENT1 ?ELEMENT2 ?PROCESS)
(and
(instance ?ELEMENT1 ElementalSubstance)
(instance ?ELEMENT2 ElementalSubstance)
(not
(equal ?ELEMENT1 ?ELEMENT2))
(instance ?PROCESS ChemicalSynthesis)
(resource ?PROCESS ?ELEMENT1)
(resource ?PROCESS ?ELEMENT2)
(result ?PROCESS ?COMPOUND))))
Wenn 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))))))
process ist ein fall von Kreation nur wenn es gibt ein patient der patient ist ein patient von process und patient besteht während "sofort nach "die zeit des Bestehens von process"" und patient besteht während "direkt vor "die zeit des Bestehens von process"" nicht.
(<=>
(instance ?PROCESS Creation)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))))))
Wenn pursue ist ein fall von Verfolgen und pursue ist der agent von agent und obj ist ein patient von pursue , dann "agent besitzt obj nicht" hält während pursue .
(=>
(and
(instance ?PURSUE Pursuing)
(agent ?PURSUE ?AGENT)
(patient ?PURSUE ?OBJ))
(holdsDuring
?PURSUE
(not
(possesses ?AGENT ?OBJ))))
Wenn investigate ist ein fall von Untersuchen und investigate ist der agent von agent und prop ist ein patient von investigate , dann "agent kennt prop nicht" hält während "die zeit des Bestehens von investigate" .
(=>
(and
(instance ?INVESTIGATE Investigating)
(agent ?INVESTIGATE ?AGENT)
(patient ?INVESTIGATE ?PROP))
(holdsDuring
(WhenFn ?INVESTIGATE)
(not
(knows ?AGENT ?PROP))))
Wenn 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 obj1 ist above hinsichlich obj2 , dann obj1 wird an obj2 nicht angeschlossen.
(=>
(orientation ?OBJ1 ?OBJ2 Above)
(not
(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 on hinsichlich obj2 , dann obj2 ist on hinsichlich obj1 nicht.
(=>
(orientation ?OBJ1 ?OBJ2 On)
(not
(orientation ?OBJ2 ?OBJ1 On)))
Für jeden org gilt: org beschäftigt person nicht und person ist ein fall von Mensch nur wenn unemployed ist ein attribut von person .
(<=>
(forall
(?ORG)
(and
(not
(employs ?ORG ?PERSON))
(instance ?PERSON Human)))
(attribute ?PERSON Unemployed))
Die Aussage formula hat die modale Kraft von necessity nur wenn die Aussage "formula" hat die modale Kraft von possibility.
(<=>
(modalAttribute ?FORMULA Necessity)
(not
(modalAttribute
(not ?FORMULA)
Possibility)))
Die Aussage formula hat die modale Kraft von obligation nur wenn die Aussage "formula" hat die modale Kraft von permission.
(<=>
(modalAttribute ?FORMULA Obligation)
(not
(modalAttribute
(not ?FORMULA)
Permission)))
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 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 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 "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))))))
entity ist ein fall von "die ergänzung von class" nur wenn entity ist ein fall von class nicht.
(<=>
(instance
?ENTITY
(ComplementFn ?CLASS))
(not
(instance ?ENTITY ?CLASS)))
