attribute (attribute)

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

Ontologie

SUMO / BASE-ONTOLOGY

Class(es)

nesymetrická relace
is instance of

ireflexivní relace
is instance of

attribute

Superrelation(s)

property

attribute

Subrelation(s)

developmental form

Související termín(y)

back fn cardinality fn front fn principal host fn probability fn skin fn authors before causes causes subclass citizen closed on completely fills connected engineering components contains information crosses date decreases likelihood developmental form disjoint documentation duration during earlier editor element equivalence relation on exploits expressed in language fills finishes frequency graph part greater than has purpose has skill holds during holds obligation holds right hole identity element immediate instance immediate subclass in list in scope of interest increases likelihood inhabits inhibits interior part irreflexive on larger less than manner measure meets spatially meets temporally member modal attribute overlaps partially parent partial ordering on partially fills path length penetrates possesses precondition prevents proper part properly fills publishes range range subclass realization reflexive on sibling smaller starts sub collection sub organizations sub plan sub proposition successor attribute successor attribute closure superficial part surface temporal part time total ordering on trichotomizing on uses valence version

Typy argumentů

attribute(objekt)

Related WordNet synsets

See more related synsets on a separate page.

Axiomy (63)

Jestliže obj je instancí třídy látka a attr je atributem obj a part je částí obj, potom attr je atributem part.

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

manner and attribute are disjoint.

(disjointRelation manner attribute)

jestliže obj1 je an exact copy of obj2,
potom pro všechny attr platí: jestliže attr je atributem obj1, potom attr je atributem obj2

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

Jestliže existuje time tak, že obj zaplňuje hole během time, potom fillable je atributem hole.

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

fillable je atributem hole1 tehdy a jen tehdy pokud existuje díra hole2 tak, že hole1 je částí hole2.

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

Jestliže obj1 zaplňuje hole a fillable je atributem obj2, potom obj1 se nepřekrývá s obj2.

(=>
      (and
            (fills ?OBJ1 ?HOLE)
            (attribute ?OBJ2 Fillable))
      (not
            (overlapsSpatially ?OBJ1 ?OBJ2)))

Jestliže death je instancí třídy smrt a agent prodělává death, potom dead je atributem agent po doba existence death.

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

Jestliže death je instancí třídy smrt a birth je instancí třídy narození a agent prodělává death a agent prodělává birth, potom existuje time tak, že "doba existence birth" meets time a time meets "doba existence death" a living je atributem agent během 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)))))

Jestliže act je instancí třídy jedení a food je účastníkem act, potom solid je atributem food.

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

Jestliže path je instancí třídy patologický proces a org prodělává path, potom existují part,nemoc disease tak, že part je částí org a disease je atributem part.

(=>
      (and
            (instance ?PATH PathologicProcess)
            (experiencer ?PATH ?ORG))
      (exists
            (?PART ?DISEASE)
            (and
                  (part ?PART ?ORG)
                  (instance ?DISEASE DiseaseOrSyndrome)
                  (attribute ?PART ?DISEASE))))

Jestliže kill je instancí třídy zabití a patient je účastníkem kill, potom living je atributem patient právě před doba existence kill a dead je atributem patient po doba existence kill.

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

Jestliže change je instancí třídy interní změna a obj je účastníkem change, potom existuje property tak, že

property je atributem obj právě před doba existence change a property není atributem obj právě po doba existence change
property není atributem obj právě před doba existence change a property je atributem obj právě po doba existence 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))))))

Jestliže alt je instancí třídy změna povrchu a obj je účastníkem alt, potom existují part,property tak, že part je a minimální částí obj a property je atributem part právě před doba existence alt a property není atributem part právě po doba existence 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))))))

Jestliže alt je instancí třídy změna tvaru a obj je účastníkem alt, potom existuje tvar property tak, že

property je atributem obj právě před doba existence alt a property není atributem obj právě po doba existence alt
property není atributem obj právě před doba existence alt a property je atributem obj právě po doba existence 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)))))))

Jestliže coloring je instancí třídy barvení a obj je účastníkem coloring, potom existuje atribut barvy property tak, že property je atributem obj právě před doba existence coloring a property není atributem obj právě po doba existence 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))))))

Jestliže wet je instancí třídy zvlhčování a obj je účastníkem wet, potom wet je atributem obj nebo damp je atributem obj právě po doba existence wet.

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

Jestliže wet je instancí třídy zvlhčování, potom existuje obj tak, že liquid je atributem obj a obj je účastníkem wet.

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

Jestliže dry je instancí třídy sušení a obj je účastníkem dry, potom dry je atributem obj právě po doba existence dry.

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

Jestliže express je instancí třídy vyjádření a agent je původcem express, potom existuje stav mysli state tak, že state je atributem agent a represents(express,state) platí.

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

Jestliže see je instancí třídy vidění a agent je původcem see a obj je účastníkem see, potom

illuminated je atributem obj
existuje atribut barvy prop tak, že agent knows "prop je atributem 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))))))

Jestliže smell je instancí třídy cítění a obj je účastníkem smell, potom existuje pach attr tak, že attr je atributem obj.

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

Jestliže taste je instancí třídy ochutnání a obj je účastníkem taste, potom existuje chuť attr tak, že attr je atributem obj.

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

Jestliže hear je instancí třídy slyšení a obj je účastníkem hear, potom existuje zvuk attr tak, že attr je atributem obj.

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

Existuje vyzařování světla emit tak, že region je účastníkem emit a region je instancí třídy oblast tehdy a jen tehdy pokud illuminated je atributem region.

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

Jestliže emit je instancí třídy vyzařování zvuku a sound je původcem emit, potom existuje zvuk attr tak, že attr je atributem sound.

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

Jestliže process je instancí třídy změna skupenství a obj je účastníkem process, potom existují part,skupenství state1,skupenství state2 tak, že part je částí obj a state1 se nerovná state2 a state1 je atributem part právě před doba existence process a state2 je atributem part právě po doba existence 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)))))

Jestliže melt je instancí třídy tání a obj je účastníkem melt, potom existuje part tak, že part je částí obj a solid je atributem part právě před doba existence melt a liquid je atributem part právě po doba existence 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)))))

Jestliže boil je instancí třídy var a obj je účastníkem boil, potom existuje part tak, že part je částí obj a liquid je atributem part právě před doba existence boil a gas je atributem part právě po doba existence 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)))))

Jestliže cond je instancí třídy kondenzace a obj je účastníkem cond, potom existuje part tak, že part je částí obj a gas je atributem part právě před doba existence cond a liquid je atributem part právě po doba existence 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)))))

Jestliže freeze je instancí třídy tuhnutí a obj je účastníkem freeze, potom existuje part tak, že part je částí obj a liquid je atributem part právě před doba existence freeze a solid je atributem part právě po doba existence 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)))))

Jestliže mother je a mother of child, potom female je atributem mother.

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

Jestliže father je a father of child, potom male je atributem father.

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

Jestliže bev je instancí třídy nápoj, potom liquid je atributem bev.

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

Jestliže "organization fn(unit)" se rovná org a attr je instancí třídy objektivní atribut, potom attr je atributem unit tehdy a jen tehdy pokud attr je atributem org.

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

Jestliže attribute je atributem person a attribute je instancí třídy sociální role, potom person je instancí třídy člověk.

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

Pro všechny org platí: org doesn't employ person a person je instancí třídy člověk tehdy a jen tehdy pokud unemployed je atributem person.

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

Jestliže attr je atributem obj a attr je instancí třídy soutěžní atribut, potom existuje soutěž contest tak, že obj je původcem contest nebo obj je účastníkem contest.

(=>
      (and
            (attribute ?OBJ ?ATTR)
            (instance ?ATTR ContestAttribute))
      (exists
            (?CONTEST)
            (and
                  (instance ?CONTEST Contest)
                  (or
                        (agent ?CONTEST ?OBJ)
                        (patient ?CONTEST ?OBJ)))))

Jestliže obj je instancí třídy roztok, potom liquid je atributem obj.

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

obj je instancí třídy látka tehdy a jen tehdy pokud existuje skupenství attr tak, že attr je atributem obj.

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

Jestliže perception je instancí třídy vnímání a obj je účastníkem perception, potom existuje vnímatelný attribut prop tak, že prop je atributem obj.

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

Jestliže obj je instancí třídy jídlo, potom existuje chuť attr tak, že attr je atributem obj.

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

jestliže monochromatic je atributem obj a part je a minimální částí obj a color je atributem part a color je instancí třídy základní barva,
potom pro všechny element platí: jestliže element je a minimální částí obj, potom color je atributem element

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

Jestliže obj je instancí třídy objekt, potom monochromatic je atributem obj nebo polychromatic je atributem obj.

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

Jestliže polychromatic je atributem obj, potom existují part1,part2,atribut barvy color1,atribut barvy color2 tak, že part1 je a minimální částí obj a part2 je a minimální částí obj a color1 je atributem part1 a color2 je atributem part2 a color1 se nerovná color2.

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

Jestliže existuje změna tvaru change tak, že obj je účastníkem change, potom pliable je atributem obj.

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

Jestliže obj je instancí třídy spojitý objekt, potom pliable je atributem obj nebo rigid je atributem obj.

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

Jestliže attribute je instancí třídy textura a attribute je atributem obj a surface je povrchem obj, potom attribute je atributem surface.

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

Jestliže dry je atributem obj, potom neexistuje subobj tak, že subobj je částí obj a liquid je atributem subobj.

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

jestliže wet je atributem obj,
potom pro všechny part platí: jestliže part je částí obj, potom existuje subpart tak, že subpart je částí part a liquid je atributem subpart

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

Jestliže unbreakable je atributem obj, potom neexistuje poškození damage tak, že obj je účastníkem damage.

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

Jestliže att je atributem org a att je instancí třídy biologický attribut, potom org je instancí třídy organismus.

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

Jestliže organism je instancí třídy organismus a organism je původcem process, potom living je atributem organism doba existence process.

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

Jestliže org je instancí třídy organismus, potom existuje attribut života attr tak, že attr je atributem org.

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

Jestliže body je instancí třídy reprodukční struktura a body je částí org a org je instancí třídy organismus, potom female je atributem org.

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

Jestliže animal je instancí třídy zvíře, potom existuje pohlaví attr tak, že attr je atributem animal.

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

Jestliže fully formed je atributem obj, potom existuje růst growth tak, že obj prodělává growth a non fully formed je atributem obj the beginning of doba existence obj.

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

Jestliže org je instancí třídy organismus, potom existuje attribut stupně vývoje attr tak, že attr je atributem org.

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

Jestliže larval je atributem org během time, potom existuje narození birth tak, že org prodělává birth před time.

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

Jestliže embryonic je atributem org, potom existuje reprodukční struktura body tak, že org je located at body.

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

Jestliže embryonic je atributem org během time, potom neexistuje narození birth tak, že org prodělává birth během time.

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

jestliže attr je instancí třídy fyziologický atribut,
potom jestliže attr je atributem organism během time, potom living je atributem organism během time

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

Jestliže attr je instancí třídy fyziologický atribut a attr je atributem agent, potom agent je instancí třídy vnímavý agent.

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

agent je instancí třídy vnímavý agent a living je atributem agent tehdy a jen tehdy pokud existuje stav vědomí attr tak, že attr je atributem agent.

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