attribut (attribute)

(attribute object property) means that property is a Attribute of object. For example, (attribute MyLittleRedWagon Red).

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

asymmetrische Relation
is instance of

irreflexive Relation
is instance of

attribut

Superrelation(s)

eigenschaft

attribut

Subrelation(s)

entwicklungsForm

Coordinate term(s)

RückseiteFn KardinalitätFn FrontseiteFn HauptwirtFn Wahrscheinlichkeit OberflächeFn schreibt vor verursacht causes subclass bürger aufgeschlossen fülltVollständig angeschlosseneTechnikKomponenten enthältInformationen kreuzt datum verringertWahrscheinlichkeit entwicklungsForm disjunkt dokumentation &%dauer von %1 ist %2 %n{nicht} während früh herausgeber element äquivalenzrelationMit nutztAus inSpracheAusgedrückt füllt beendet frequenz graphenTeil grösserAls hatZweck hatFähigkeit hältWährend hatVerpflichtung hatRecht loch identitätsElement direkterFall direckteTeilkategorie inListe imBereichInteresses vergrössertWahrscheinlichkeit wohnt hemmt innenteil irreflexivAur grösser kleinerAls weise mass schliesstRäumlichAn schliesstZeitlichAn mitglied modalesAttribute decktSichTeilweise elternteil teilweiseEinrichtung fülltTeilweise pfadLänge dringtEin besitzt vorbedingung verhindert korrektesTeil fülltRichtig veröffentlicht &%bildbereich von %1 ist ein fall von %2 {nicht} bildbereichTeilkategorie realizierung reflexivAuf geschwister kleiner beginnt teilsammlung unterOrganisation teilplan %1 ist eine &%teilangelegenheit von %2 %n{nicht} nachfolgerAttribut nachfolgerAttributSchliessung oberflächichesTeil fläche zeitlichesTeil zeit gesamteinrichtung trichotomizierungAuf verwendet valenz version

Type restrictions

attribute(Gegenstand)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (63)

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

weise und attribut werden disjunkt.

(disjointRelation manner attribute)

wenn obj1 ist eine genaue kopie von obj2,
dann für jeden attr gilt: wenn attr ist ein attribut von obj1 , dann attr ist ein attribut von obj2

(=>
      (copy ?OBJ1 ?OBJ2)
      (forall
            (?ATTR)
            (=>
                  (attribute ?OBJ1 ?ATTR)
                  (attribute ?OBJ2 ?ATTR))))

Wenn es gibt ein time der "obj füllt hole " hält während time , dann fillable ist ein attribut von hole .

(=>
      (exists
            (?TIME)
            (holdsDuring
                  ?TIME
                  (fills ?OBJ ?HOLE)))
      (attribute ?HOLE Fillable))

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 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 death ist ein fall von Tod und agent erfährt death , dann "dead ist ein attribut von agent " hält während "nach "die zeit des Bestehens von death"" .

(=>
      (and
            (instance ?DEATH Death)
            (experiencer ?DEATH ?AGENT))
      (holdsDuring
            (FutureFn
                  (WhenFn ?DEATH))
            (attribute ?AGENT Dead)))

Wenn death ist ein fall von Tod und birth ist ein fall von Geburt und agent erfährt death und agent erfährt birth , dann es gibt ein time der "die zeit des Bestehens von birth" schliesst time zeitlich an und time schliesst "die zeit des Bestehens von death" zeitlich an und "living ist ein attribut von agent " hält während time .

(=>
      (and
            (instance ?DEATH Death)
            (instance ?BIRTH Birth)
            (experiencer ?DEATH ?AGENT)
            (experiencer ?BIRTH ?AGENT))
      (exists
            (?TIME)
            (and
                  (meetsTemporally
                        (WhenFn ?BIRTH)
                        ?TIME)
                  (meetsTemporally
                        ?TIME
                        (WhenFn ?DEATH))
                  (holdsDuring
                        ?TIME
                        (attribute ?AGENT Living)))))

Wenn act ist ein fall von Essen und food ist ein patient von act , dann solid ist ein attribut von food .

(=>
      (and
            (instance ?ACT Eating)
            (patient ?ACT ?FOOD))
      (attribute ?FOOD Solid))

Wenn 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 kill ist ein fall von Tötung und patient ist ein patient von kill , dann "living ist ein attribut von patient " hält während "direkt vor "die zeit des Bestehens von kill"" und "dead ist ein attribut von patient " hält während "nach "die zeit des Bestehens von kill"" .

(=>
      (and
            (instance ?KILL Killing)
            (patient ?KILL ?PATIENT))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?KILL))
                  (attribute ?PATIENT Living))
            (holdsDuring
                  (FutureFn
                        (WhenFn ?KILL))
                  (attribute ?PATIENT Dead))))

Wenn change ist ein fall von innere Änderung und obj ist ein patient von change , dann es gibt ein property der

"property ist ein attribut von obj " hält während "direkt vor "die zeit des Bestehens von change"" und "property ist ein attribut von obj nicht" hält während "sofort nach "die zeit des Bestehens von change""
"property ist ein attribut von obj nicht" hält während "direkt vor "die zeit des Bestehens von change"" und "property ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von change""

(=>
      (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

"property ist ein attribut von obj " hält während "direkt vor "die zeit des Bestehens von alt"" und "property ist ein attribut von obj nicht" hält während "sofort nach "die zeit des Bestehens von alt""
"property ist ein attribut von obj nicht" hält während "direkt vor "die zeit des Bestehens von alt"" und "property ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von alt""

(=>
      (and
            (instance ?ALT ShapeChange)
            (patient ?ALT ?OBJ))
      (exists
            (?PROPERTY)
            (and
                  (instance ?PROPERTY ShapeAttribute)
                  (or
                        (and
                              (holdsDuring
                                    (ImmediatePastFn
                                          (WhenFn ?ALT))
                                    (attribute ?OBJ ?PROPERTY))
                              (holdsDuring
                                    (ImmediateFutureFn
                                          (WhenFn ?ALT))
                                    (not
                                          (attribute ?OBJ ?PROPERTY))))
                        (and
                              (holdsDuring
                                    (ImmediatePastFn
                                          (WhenFn ?ALT))
                                    (not
                                          (attribute ?OBJ ?PROPERTY)))
                              (holdsDuring
                                    (ImmediateFutureFn
                                          (WhenFn ?ALT))
                                    (attribute ?OBJ ?PROPERTY)))))))

Wenn coloring ist ein fall von Farbe und obj ist ein patient von coloring , dann es gibt ein Farbeattribut property der "property ist ein attribut von obj " hält während "direkt vor "die zeit des Bestehens von coloring"" und "property ist ein attribut von obj nicht" hält während "sofort nach "die zeit des Bestehens von coloring"" .

(=>
      (and
            (instance ?COLORING Coloring)
            (patient ?COLORING ?OBJ))
      (exists
            (?PROPERTY)
            (and
                  (instance ?PROPERTY ColorAttribute)
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?COLORING))
                        (attribute ?OBJ ?PROPERTY))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?COLORING))
                        (not
                              (attribute ?OBJ ?PROPERTY))))))

Wenn wet ist ein fall von Befeuchten und obj ist ein patient von wet , dann "wet ist ein attribut von obj oder damp ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von wet"" .

(=>
      (and
            (instance ?WET Wetting)
            (patient ?WET ?OBJ))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?WET))
            (or
                  (attribute ?OBJ Wet)
                  (attribute ?OBJ Damp))))

Wenn wet ist ein fall von Befeuchten , dann es gibt ein obj der liquid ist ein attribut von obj und obj ist ein patient von wet .

(=>
      (instance ?WET Wetting)
      (exists
            (?OBJ)
            (and
                  (attribute ?OBJ Liquid)
                  (patient ?WET ?OBJ))))

Wenn dry ist ein fall von Trocknen und obj ist ein patient von dry , dann "dry ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von dry"" .

(=>
      (and
            (instance ?DRY Drying)
            (patient ?DRY ?OBJ))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?DRY))
            (attribute ?OBJ Dry)))

Wenn express ist ein fall von Ausdrücken und express ist der agent von agent , dann es gibt ein Geisteszustand state der state ist ein attribut von agent und express drückt state aus.

(=>
      (and
            (instance ?EXPRESS Expressing)
            (agent ?EXPRESS ?AGENT))
      (exists
            (?STATE)
            (and
                  (instance ?STATE StateOfMind)
                  (attribute ?AGENT ?STATE)
                  (represents ?EXPRESS ?STATE))))

Wenn see ist ein fall von Sehen und see ist der agent von agent und obj ist ein patient von see , dann

illuminated ist ein attribut von obj
es gibt ein Farbeattribut prop der agent kennt "prop ist ein attribut von obj "

(=>
      (and
            (instance ?SEE Seeing)
            (agent ?SEE ?AGENT)
            (patient ?SEE ?OBJ))
      (and
            (attribute ?OBJ Illuminated)
            (exists
                  (?PROP)
                  (and
                        (instance ?PROP ColorAttribute)
                        (knows
                              ?AGENT
                              (attribute ?OBJ ?PROP))))))

Wenn smell ist ein fall von Geruch und obj ist ein patient von smell , dann es gibt ein Geruchattribut attr der attr ist ein attribut von obj .

(=>
      (and
            (instance ?SMELL Smelling)
            (patient ?SMELL ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR OlfactoryAttribute)
                  (attribute ?OBJ ?ATTR))))

Wenn taste ist ein fall von Geschmack und obj ist ein patient von taste , dann es gibt ein Geschmackattribut attr der attr ist ein attribut von obj .

(=>
      (and
            (instance ?TASTE Tasting)
            (patient ?TASTE ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR TasteAttribute)
                  (attribute ?OBJ ?ATTR))))

Wenn hear ist ein fall von Gehör und obj ist ein patient von hear , dann es gibt ein Tonsattribut attr der attr ist ein attribut von obj .

(=>
      (and
            (instance ?HEAR Hearing)
            (patient ?HEAR ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?OBJ ?ATTR))))

Es gibt ein ausstrahlendes Licht emit der region ist ein patient von emit und region ist ein fall von Gebiet nur wenn illuminated ist ein attribut von region .

(<=>
      (exists
            (?EMIT)
            (and
                  (instance ?EMIT RadiatingLight)
                  (patient ?EMIT ?REGION)
                  (instance ?REGION Region)))
      (attribute ?REGION Illuminated))

Wenn emit ist ein fall von ausstrahlender Ton und emit ist der agent von sound , dann es gibt ein Tonsattribut attr der attr ist ein attribut von sound .

(=>
      (and
            (instance ?EMIT RadiatingSound)
            (agent ?EMIT ?SOUND))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?SOUND ?ATTR))))

Wenn process ist ein fall von Zustandänderung und obj ist ein patient von process , dann es gibt ein part,körperliche Zustand state1,körperliche Zustand state2 der part ist ein teil von obj und state1 ist gleich state2 nicht und "state1 ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von process"" und "state2 ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .

(=>
      (and
            (instance ?PROCESS StateChange)
            (patient ?PROCESS ?OBJ))
      (exists
            (?PART ?STATE1 ?STATE2)
            (and
                  (part ?PART ?OBJ)
                  (instance ?STATE1 PhysicalState)
                  (instance ?STATE2 PhysicalState)
                  (not
                        (equal ?STATE1 ?STATE2))
                  (holdsDuring
                        (ImmediatePastFn
                              (WhenFn ?PROCESS))
                        (attribute ?PART ?STATE1))
                  (holdsDuring
                        (ImmediateFutureFn
                              (WhenFn ?FREEZE))
                        (attribute ?PART ?STATE2)))))

Wenn melt ist ein fall von schmelzend 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 mother ist die mutter von child , dann female ist ein attribut von mother .

(=>
      (mother ?CHILD ?MOTHER)
      (attribute ?MOTHER Female))

Wenn father ist der vater von child , dann male ist ein attribut von father .

(=>
      (father ?CHILD ?FATHER)
      (attribute ?FATHER Male))

Wenn bev ist ein fall von Getränk , dann liquid ist ein attribut von bev .

(=>
      (instance ?BEV Beverage)
      (attribute ?BEV Liquid))

Wenn "die zugelassene organisatorishe Gruppe von unit" ist gleich org und attr ist ein fall von normatives Attribut , dann attr ist ein attribut von unit nur wenn attr ist ein attribut von org .

(=>
      (and
            (equal
                  (OrganizationFn ?UNIT)
                  ?ORG)
            (instance ?ATTR NormativeAttribute))
      (<=>
            (attribute ?UNIT ?ATTR)
            (attribute ?ORG ?ATTR)))

Wenn attribute ist ein attribut von person und attribute ist ein fall von Sozialrolle , dann person ist ein fall von Mensch .

(=>
      (and
            (attribute ?PERSON ?ATTRIBUTE)
            (instance ?ATTRIBUTE SocialRole))
      (instance ?PERSON Human))

Für jeden org gilt: org beschäftigt person nicht und person ist ein fall von Mensch nur wenn unemployed ist ein attribut von person .

(<=>
      (forall
            (?ORG)
            (and
                  (not
                        (employs ?ORG ?PERSON))
                  (instance ?PERSON Human)))
      (attribute ?PERSON Unemployed))

Wenn 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 obj ist ein fall von Lösung , dann liquid ist ein attribut von obj .

(=>
      (instance ?OBJ Solution)
      (attribute ?OBJ Liquid))

obj ist ein fall von Substanz nur wenn es gibt ein körperliche Zustand attr der attr ist ein attribut von obj .

(<=>
      (instance ?OBJ Substance)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR PhysicalState)
                  (attribute ?OBJ ?ATTR))))

Wenn perception ist ein fall von Wahrnehmung und obj ist ein patient von perception , dann es gibt ein Wahrnehmungsattribut prop der prop ist ein attribut von obj .

(=>
      (and
            (instance ?PERCEPTION Perception)
            (patient ?PERCEPTION ?OBJ))
      (exists
            (?PROP)
            (and
                  (instance ?PROP PerceptualAttribute)
                  (attribute ?OBJ ?PROP))))

Wenn obj ist ein fall von Nahrung , dann es gibt ein Geschmackattribut attr der attr ist ein attribut von obj .

(=>
      (instance ?OBJ Food)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR TasteAttribute)
                  (attribute ?OBJ ?ATTR))))

wenn monochromatic ist ein attribut von obj und part ist ein oberflächliches teil von obj und color ist ein attribut von part und color ist ein fall von Primärfarbe ,
dann für jeden element gilt: wenn element ist ein oberflächliches teil von obj , dann color ist ein attribut von element

(=>
      (and
            (attribute ?OBJ Monochromatic)
            (superficialPart ?PART ?OBJ)
            (attribute ?PART ?COLOR)
            (instance ?COLOR PrimaryColor))
      (forall
            (?ELEMENT)
            (=>
                  (superficialPart ?ELEMENT ?OBJ)
                  (attribute ?ELEMENT ?COLOR))))

Wenn obj ist ein fall von Gegenstand , dann monochromatic ist ein attribut von obj oder polychromatic ist ein attribut von obj .

(=>
      (instance ?OBJ Object)
      (or
            (attribute ?OBJ Monochromatic)
            (attribute ?OBJ Polychromatic)))

Wenn polychromatic ist ein attribut von obj , dann es gibt ein part1,part2,Farbeattribut color1,Farbeattribut color2 der part1 ist ein oberflächliches teil von obj und part2 ist ein oberflächliches teil von obj und color1 ist ein attribut von part1 und color2 ist ein attribut von part2 und color1 ist gleich color2 nicht.

(=>
      (attribute ?OBJ Polychromatic)
      (exists
            (?PART1 ?PART2 ?COLOR1 ?COLOR2)
            (and
                  (superficialPart ?PART1 ?OBJ)
                  (superficialPart ?PART2 ?OBJ)
                  (attribute ?PART1 ?COLOR1)
                  (attribute ?PART2 ?COLOR2)
                  (instance ?COLOR1 ColorAttribute)
                  (instance ?COLOR2 ColorAttribute)
                  (not
                        (equal ?COLOR1 ?COLOR2)))))

Wenn es gibt ein Formänderung change der obj ist ein patient von change , dann pliable ist ein attribut von obj .

(=>
      (exists
            (?CHANGE)
            (and
                  (instance ?CHANGE ShapeChange)
                  (patient ?CHANGE ?OBJ)))
      (attribute ?OBJ Pliable))

Wenn obj ist ein fall von selbstverbundener Gegenstand , dann pliable ist ein attribut von obj oder rigid ist ein attribut von obj .

(=>
      (instance ?OBJ SelfConnectedObject)
      (or
            (attribute ?OBJ Pliable)
            (attribute ?OBJ Rigid)))

Wenn attribute ist ein fall von Beschaffenheitsattribut und attribute ist ein attribut von obj und surface ist eine fläche von obj , dann attribute ist ein attribut von surface .

(=>
      (and
            (instance ?ATTRIBUTE TextureAttribute)
            (attribute ?OBJ ?ATTRIBUTE)
            (surface ?SURFACE ?OBJ))
      (attribute ?SURFACE ?ATTRIBUTE))

Wenn dry ist ein attribut von obj , dann es gibt kein subobj der subobj ist ein teil von obj und liquid ist ein attribut von subobj .

(=>
      (attribute ?OBJ Dry)
      (not
            (exists
                  (?SUBOBJ)
                  (and
                        (part ?SUBOBJ ?OBJ)
                        (attribute ?SUBOBJ Liquid)))))

wenn wet ist ein attribut von obj ,
dann für jeden part gilt: wenn part ist ein teil von obj , dann es gibt ein subpart der subpart ist ein teil von part und liquid ist ein attribut von subpart

(=>
      (attribute ?OBJ Wet)
      (forall
            (?PART)
            (=>
                  (part ?PART ?OBJ)
                  (exists
                        (?SUBPART)
                        (and
                              (part ?SUBPART ?PART)
                              (attribute ?SUBPART Liquid))))))

Wenn unbreakable ist ein attribut von obj , dann es gibt kein Beschädigen damage der obj ist ein patient von damage .

(=>
      (attribute ?OBJ Unbreakable)
      (not
            (exists
                  (?DAMAGE)
                  (and
                        (instance ?DAMAGE Damaging)
                        (patient ?DAMAGE ?OBJ)))))

Wenn att ist ein attribut von org und att ist ein fall von biologisches Attribut , dann org ist ein fall von Organismus .

(=>
      (and
            (attribute ?ORG ?ATT)
            (instance ?ATT BiologicalAttribute))
      (instance ?ORG Organism))

Wenn organism ist ein fall von Organismus und process ist der agent von organism , dann "living ist ein attribut von organism " hält während "die zeit des Bestehens von process" .

(=>
      (and
            (instance ?ORGANISM Organism)
            (agent ?PROCESS ?ORGANISM))
      (holdsDuring
            (WhenFn ?PROCESS)
            (attribute ?ORGANISM Living)))

Wenn org ist ein fall von Organismus , dann es gibt ein Belebtheitsattribut attr der attr ist ein attribut von org .

(=>
      (instance ?ORG Organism)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR AnimacyAttribute)
                  (attribute ?ORG ?ATTR))))

Wenn body ist ein fall von reproduktive Körper und body ist ein teil von org und org ist ein fall von Organismus , dann female ist ein attribut von org .

(=>
      (and
            (instance ?BODY ReproductiveBody)
            (part ?BODY ?ORG)
            (instance ?ORG Organism))
      (attribute ?ORG Female))

Wenn animal ist ein fall von Tier , dann es gibt ein Geschlechtattribut attr der attr ist ein attribut von animal .

(=>
      (instance ?ANIMAL Animal)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SexAttribute)
                  (attribute ?ANIMAL ?ATTR))))

Wenn fully formed ist ein attribut von obj , dann es gibt ein Wachstum growth der obj erfährt growth und "non fully formed ist ein attribut von obj " hält während "der anfang von "die zeit des Bestehens von obj"" .

(=>
      (attribute ?OBJ FullyFormed)
      (exists
            (?GROWTH)
            (and
                  (instance ?GROWTH Growth)
                  (experiencer ?GROWTH ?OBJ)
                  (holdsDuring
                        (BeginFn
                              (WhenFn ?OBJ))
                        (attribute ?OBJ NonFullyFormed)))))

Wenn org ist ein fall von Organismus , dann es gibt ein Entwicklungsattribut attr der attr ist ein attribut von org .

(=>
      (instance ?ORG Organism)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR DevelopmentalAttribute)
                  (attribute ?ORG ?ATTR))))

Wenn "larval ist ein attribut von org " hält während time , dann "es gibt ein Geburt birth der org erfährt birth " hält während "vor time" .

(=>
      (holdsDuring
            ?TIME
            (attribute ?ORG Larval))
      (holdsDuring
            (PastFn ?TIME)
            (exists
                  (?BIRTH)
                  (and
                        (instance ?BIRTH Birth)
                        (experiencer ?BIRTH ?ORG)))))

Wenn embryonic ist ein attribut von org , dann es gibt ein reproduktive Körper body der org befindet sich an .

(=>
      (attribute ?ORG Embryonic)
      (exists
            (?BODY)
            (and
                  (instance ?BODY ReproductiveBody)
                  (located ?ORG ?BODY))))

Wenn "embryonic ist ein attribut von org " hält während time , dann "es gibt kein Geburt birth der org erfährt birth " hält während time .

(=>
      (holdsDuring
            ?TIME
            (attribute ?ORG Embryonic))
      (holdsDuring
            ?TIME
            (not
                  (exists
                        (?BIRTH)
                        (and
                              (instance ?BIRTH Birth)
                              (experiencer ?BIRTH ?ORG))))))

wenn attr ist ein fall von psychologisches Attribut ,
dann wenn "attr ist ein attribut von organism " hält während time , dann "living ist ein attribut von organism " hält während time

(=>
      (instance ?ATTR PsychologicalAttribute)
      (=>
            (holdsDuring
                  ?TIME
                  (attribute ?ORGANISM ?ATTR))
            (holdsDuring
                  ?TIME
                  (attribute ?ORGANISM Living))))

Wenn attr ist ein fall von psychologisches Attribut und attr ist ein attribut von agent , dann agent ist ein fall von empfindungsfähiger Agent .

(=>
      (and
            (instance ?ATTR PsychologicalAttribute)
            (attribute ?AGENT ?ATTR))
      (instance ?AGENT SentientAgent))

agent ist ein fall von empfindungsfähiger Agent und living ist ein attribut von agent nur wenn es gibt ein Bewusstseinsattribut attr der attr ist ein attribut von agent .

(<=>
      (and
            (instance ?AGENT SentientAgent)
            (attribute ?AGENT Living))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR ConsciousnessAttribute)
                  (attribute ?AGENT ?ATTR))))