teil (part)

The basic mereological relation. All other mereological relations are defined in terms of this one. (part part whole) simply means that the Object part is part of the Object whole. Note that, since part is a ReflexiveRelation, every Object is a part of itself.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

Kategorie

inheritable relation

räumliche Relation
is instance of

Halbordnungsrelation
is instance of

teil

Superrelation(s)

befindetSichTeils

befindetSich

teil

Subrelation(s)

korrektesTeil stück bestandteil mitglied oberflächichesTeil innenteil

Coordinate term(s)

RückseiteFn FrontseiteFn MereologischeDifferenzFn MereologischesProduktFn MereologischeSummeFn HauptwirtFn OberflächeFn WoFn vorOderGleichzeitig zwischen angeschlossen schliesstAn abstand grösserAlsOderGleich loch grösser kleinerAlsOderGleich befindetSich lagebestimmung fülltTeilweise befindetSichTeils kleiner teilAttribut teilliste subProzess teilkategorie teilrelation fasstInhaltsKategorieZusammen fasstInhaltsFallZusammen überqürt

Type restrictions

part(Gegenstand, Gegenstand)

Related WordNet synsets

comprehension, comprising: the act of comprising something
part, piece: a portion of a natural object; "they analyzed the river into three parts"; "he needed a piece of granite"
part, portion, component part, component: something determined in relation to something that includes it; "he wanted to feel a part of something bigger than himself"; "I read a portion of the manuscript"; "the smaller component is hard to reach"

See more related synsets on a separate page.

Axioms (57)

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))

obj1 ist ein korrektes teil von obj2 nur wenn obj1 ist ein teil von obj2 und obj2 ist ein teil von obj1 nicht.

(<=>
      (properPart ?OBJ1 ?OBJ2)
      (and
            (part ?OBJ1 ?OBJ2)
            (not
                  (part ?OBJ2 ?OBJ1))))

Wenn objecttype ist eine teilkategorie von Substanz und object ist ein fall von objecttype und part ist ein teil von object , dann part ist ein fall von objecttype .

(=>
      (and
            (subclass ?OBJECTTYPE Substance)
            (instance ?OBJECT ?OBJECTTYPE)
            (part ?PART ?OBJECT))
      (instance ?PART ?OBJECTTYPE))

Wenn obj ist ein fall von Substanz und attr ist ein attribut von obj und part ist ein teil von obj , dann attr ist ein attribut von part .

(=>
      (and
            (instance ?OBJ Substance)
            (attribute ?OBJ ?ATTR)
            (part ?PART ?OBJ))
      (attribute ?PART ?ATTR))

Wenn 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 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 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))))

obj1 deckt sich mit obj2 räumlich nur wenn es gibt ein obj3 der obj3 ist ein teil von obj1 und obj3 ist ein teil von obj2 .

(<=>
      (overlapsSpatially ?OBJ1 ?OBJ2)
      (exists
            (?OBJ3)
            (and
                  (part ?OBJ3 ?OBJ1)
                  (part ?OBJ3 ?OBJ2))))

obj1 deckt sich mit obj2 teilweise nur wenn

obj1 ist ein teil von obj2 nicht
obj2 ist ein teil von obj1 nicht
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 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 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 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 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)))

fillable ist ein attribut von hole1 nur wenn es gibt ein Loch hole2 der hole1 ist ein teil von hole2 .

(<=>
      (attribute ?HOLE1 Fillable)
      (exists
            (?HOLE2)
            (and
                  (instance ?HOLE2 Hole)
                  (part ?HOLE1 ?HOLE2))))

Wenn obj füllt hole1 teilweise, dann es gibt ein hole2 der hole2 ist ein teil von hole1 und obj füllt hole2 vollständig.

(=>
      (partiallyFills ?OBJ ?HOLE1)
      (exists
            (?HOLE2)
            (and
                  (part ?HOLE2 ?HOLE1)
                  (completelyFills ?OBJ ?HOLE2))))

Wenn obj füllt hole1 richtig, dann es gibt ein hole2 der hole2 ist ein teil von hole1 und obj füllt hole2 .

(=>
      (properlyFills ?OBJ ?HOLE1)
      (exists
            (?HOLE2)
            (and
                  (part ?HOLE2 ?HOLE1)
                  (fills ?OBJ ?HOLE2))))

Wenn obj1 füllt hole vollständig, dann es gibt ein obj2 der obj2 ist ein teil von obj1 und obj2 füllt hole .

(=>
      (completelyFills ?OBJ1 ?HOLE)
      (exists
            (?OBJ2)
            (and
                  (part ?OBJ2 ?OBJ1)
                  (fills ?OBJ2 ?HOLE))))

Wenn 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
- path1 ist der pfad entlang dem process geschieht
- process beginnet an source
- process endet an dest
- die länge von path1 ist measure1
- 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 therapeutischer Prozess und bio ist ein patient von proc , dann

bio ist ein fall von Organismus
es gibt ein Organismus org der bio ist ein teil von org

(=>
      (and
            (instance ?PROC TherapeuticProcess)
            (patient ?PROC ?BIO))
      (or
            (instance ?BIO Organism)
            (exists
                  (?ORG)
                  (and
                        (instance ?ORG Organism)
                        (part ?BIO ?ORG)))))

combine ist ein fall von Kombinieren und obj1 ist ein hilfmittel für combine und obj2 ist ein resultat von combine nur wenn "obj1 ist ein teil von obj2 nicht" hält während "direkt vor "die zeit des Bestehens von combine"" und "obj1 ist ein teil von obj2 " hält während "sofort nach "die zeit des Bestehens von combine"" .

(<=>
      (and
            (instance ?COMBINE Combining)
            (resource ?COMBINE ?OBJ1)
            (result ?COMBINE ?OBJ2))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?COMBINE))
                  (not
                        (part ?OBJ1 ?OBJ2)))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?COMBINE))
                  (part ?OBJ1 ?OBJ2))))

Wenn 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 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 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 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 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 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 organism ist ein fall von giftiger Organismus , dann es gibt ein biologisch Wirkstoff substance der substance ist ein teil von organism .

(=>
      (instance ?ORGANISM ToxicOrganism)
      (exists
            (?SUBSTANCE)
            (and
                  (instance ?SUBSTANCE BiologicallyActiveSubstance)
                  (part ?SUBSTANCE ?ORGANISM))))

Wenn food ist ein fall von Nahrung , dann es gibt ein Nährstoff nutrient der nutrient ist ein teil von food .

(=>
      (instance ?FOOD Food)
      (exists
            (?NUTRIENT)
            (and
                  (instance ?NUTRIENT Nutrient)
                  (part ?NUTRIENT ?FOOD))))

wenn food ist ein fall von Nahrung ,
dann für jeden part1 gilt: wenn part1 ist ein teil von food , dann es gibt ein part2,Tier animal der part1 ist ein teil von part2 und part2 ist ein teil von animal

(=>
      (instance ?FOOD Food)
      (forall
            (?PART1)
            (=>
                  (part ?PART1 ?FOOD)
                  (exists
                        (?PART2 ?ANIMAL)
                        (and
                              (part ?PART1 ?PART2)
                              (part ?PART2 ?ANIMAL)
                              (instance ?ANIMAL Animal))))))

wenn meat ist ein fall von Fleisch ,
dann für jeden part gilt: wenn part ist ein teil von meat , dann es gibt ein subpart,time,animal der subpart ist ein teil von part und "animal ist ein fall von Tier und subpart ist ein teil von animal " hält während time

(=>
      (instance ?MEAT Meat)
      (forall
            (?PART)
            (=>
                  (part ?PART ?MEAT)
                  (exists
                        (?SUBPART ?TIME ?ANIMAL)
                        (and
                              (part ?SUBPART ?PART)
                              (holdsDuring
                                    ?TIME
                                    (and
                                          (instance ?ANIMAL Animal)
                                          (part ?SUBPART ?ANIMAL))))))))

wenn veg ist ein fall von Frucht oder Gemüse ,
dann für jeden part gilt: wenn part ist ein teil von veg , dann es gibt ein subpart,time,plant der subpart ist ein teil von part und "plant ist ein fall von Pflanze und subpart ist ein teil von plant " hält während time

(=>
      (instance ?VEG FruitOrVegetable)
      (forall
            (?PART)
            (=>
                  (part ?PART ?VEG)
                  (exists
                        (?SUBPART ?TIME ?PLANT)
                        (and
                              (part ?SUBPART ?PART)
                              (holdsDuring
                                    ?TIME
                                    (and
                                          (instance ?PLANT Plant)
                                          (part ?SUBPART ?PLANT))))))))

Wenn anat ist ein fall von anatomische Struktur , dann es gibt ein Organismus organism der anat ist ein teil von organism .

(=>
      (instance ?ANAT AnatomicalStructure)
      (exists
            (?ORGANISM)
            (and
                  (instance ?ORGANISM Organism)
                  (part ?ANAT ?ORGANISM))))

Wenn part ist ein fall von anatomische Struktur , dann es gibt ein Zelle cell der cell ist ein teil von part .

(=>
      (instance ?PART AnatomicalStructure)
      (exists
            (?CELL)
            (and
                  (instance ?CELL Cell)
                  (part ?CELL ?PART))))

Wenn 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 Satz part der part ist ein teil von text .

(=>
      (instance ?TEXT Text)
      (exists
            (?PART)
            (and
                  (part ?PART ?TEXT)
                  (instance ?PART Sentence))))

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 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 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 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 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))