or (or)
The truth-functional connective of disjunction.
Ontology
SUMO / STRUCTURAL-ONTOLOGYClass(es)
Coordinate term(s)
<=>
=>
and
hatZurFolge
exists
forall
not
Type restrictions
or(Formel, Formel)
Related WordNet synsets
See more related synsets on a separate page.
Axioms (61)
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 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 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 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)))
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)))))
number1 ist kleinerAlsOderGleich number2 nur wenn number1 ist gleich number2 oder number1 ist kleinerAls number2 .
(<=>
(lessThanOrEqualTo ?NUMBER1 ?NUMBER2)
(or
(equal ?NUMBER1 ?NUMBER2)
(lessThan ?NUMBER1 ?NUMBER2)))
number1 ist grösserAlsOderGleich number2 nur wenn number1 ist gleich number2 oder number1 ist grösserAls number2 .
(<=>
(greaterThanOrEqualTo ?NUMBER1 ?NUMBER2)
(or
(equal ?NUMBER1 ?NUMBER2)
(greaterThan ?NUMBER1 ?NUMBER2)))
- 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 , 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 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 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 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 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 obj1 überquert obj2, dann obj1 kreuzt obj2 oder obj1 dringt obj2 ein.
(=>
(traverses ?OBJ1 ?OBJ2)
(or
(crosses ?OBJ1 ?OBJ2)
(penetrates ?OBJ1 ?OBJ2)))
"der absolutebetrag von number1" ist gleich number2 und number1 ist ein fall von reelle Zahl und number2 ist ein fall von reelle Zahl nur wenn
(<=>
(and
(equal
(AbsoluteValueFn ?NUMBER1)
?NUMBER2)
(instance ?NUMBER1 RealNumber)
(instance ?NUMBER2 RealNumber))
(or
(and
(instance ?NUMBER1 NonnegativeRealNumber)
(equal ?NUMBER1 ?NUMBER2))
(and
(instance ?NUMBER1 NegativeRealNumber)
(equal
?NUMBER2
(SubtractionFn 0 ?NUMBER1)))))
Wenn "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 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 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)))))
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
- "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 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 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 "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 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)))
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 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 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 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 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 act ist ein fall von organisatorisher Prozess und act ist der agent von agent , dann
(=>
(and
(instance ?ACT OrganizationalProcess)
(agent ?ACT ?AGENT))
(or
(instance ?AGENT Organization)
(exists
(?ORG)
(and
(instance ?ORG Organization)
(member ?AGENT ?ORG)))))
Wenn act ist ein fall von religiöser Prozess und act ist der agent von agent , dann
(=>
(and
(instance ?ACT ReligiousProcess)
(agent ?ACT ?AGENT))
(or
(instance ?AGENT ReligiousOrganization)
(exists
(?ORG)
(and
(member ?AGENT ?ORG)
(instance ?ORG ReligiousOrganization)))))
Wenn proc ist ein fall von politischer Prozess , dann es gibt ein Regierung gov der proc ist der agent von gov oder gov ist ein patient von proc .
(=>
(instance ?PROC PoliticalProcess)
(exists
(?GOV)
(and
(instance ?GOV Government)
(or
(agent ?PROC ?GOV)
(patient ?PROC ?GOV)))))
Wenn 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 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 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 , dann stuff ist ein fall von reine Substanz .
(=>
(and
(instance ?PROC ChemicalProcess)
(or
(resource ?PROC ?STUFF)
(result ?PROC ?STUFF)))
(instance ?STUFF PureSubstance))
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 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 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 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 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 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 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 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 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 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 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 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 item hat ein attribut value und value ist ein fall von Wahrheitswert , dann item ist ein fall von Satz oder item ist ein fall von Proposition .
(=>
(and
(property ?ITEM ?VALUE)
(instance ?VALUE TruthValue))
(or
(instance ?ITEM Sentence)
(instance ?ITEM Proposition)))
Wenn obj1 ist 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 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 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 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 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)))
entity ist ein fall von "die vereinigung von class1 und class2" nur wenn entity ist ein fall von class1 oder entity ist ein fall von class2 .
(<=>
(instance
?ENTITY
(UnionFn ?CLASS1 ?CLASS2))
(or
(instance ?ENTITY ?CLASS1)
(instance ?ENTITY ?CLASS2)))
