holds during (holdsDuring)
(holdsDuring time formula) means that the
proposition denoted by formula is true in the time frame time. Note
that this implies that formula is true at every TimePoint which is a
temporalPart of time.
Ontologie
SUMO / BASE-ONTOLOGYClass(es)
Související termín(y)
back fn
cardinality fn
front fn
principal host fn
probability fn
skin fn
arc weight
attribute
authors
before or equal
causes
causes subclass
citizen
closed on
completely fills
connected
contains information
cooccur
copy
crosses
date
decreases likelihood
developmental form
disjoint
distributes
documentation
duration
earlier
editor
element
employs
equal
equivalence relation on
exploits
expressed in language
faces
family relation
fills
finishes
frequency
graph part
greater than
greater than or equal to
has purpose
has skill
holds obligation
holds right
hole
identity element
immediate instance
immediate subclass
in list
in scope of interest
increases likelihood
independent probability
inhabits
inhibits
initial list
instance
inverse
irreflexive on
larger
less than
less than or equal to
manner
material
measure
meets temporally
member
modal attribute
overlaps temporally
parent
partial ordering on
partially fills
partly located
path length
penetrates
possesses
precondition
prevents
proper part
properly fills
property
publishes
range
range subclass
realization
refers
reflexive on
related internal concept
sibling
smaller
starts
sub attribute
sub collection
sub graph
sub list
sub process
sub proposition
subclass
subrelation
subsumes content class
subsumes content instance
successor attribute
successor attribute closure
surface
temporal part
time
total ordering on
trichotomizing on
uses
valence
version
Typy argumentů
holdsDuring(časová pozice, formule)
Axiomy (70)
Jestliže attr1 je an immediate successor attribute of attr2 a entity má atribut attr2 během time1, potom existuje time2 tak, že time2 je a part of před time1 a entity má atribut attr1 během time2.
(=>
(and
(successorAttribute ?ATTR1 ?ATTR2)
(holdsDuring
?TIME1
(property ?ENTITY ?ATTR2)))
(exists
(?TIME2)
(and
(temporalPart
?TIME2
(PastFn ?TIME1))
(holdsDuring
?TIME2
(property ?ENTITY ?ATTR1)))))
Jestliže agent believes formula, potom existuje time tak, že agent considers formula během time.
(=>
(believes ?AGENT ?FORMULA)
(exists
(?TIME)
(holdsDuring
?TIME
(considers ?AGENT ?FORMULA))))
Jestliže situation1 platí během time a situation1 entails situation2, potom situation2 platí během time.
(=>
(and
(holdsDuring ?TIME ?SITUATION1)
(entails ?SITUATION1 ?SITUATION2))
(holdsDuring ?TIME ?SITUATION2))
Jestliže situation během time, potom situation platí během time.
(=>
(holdsDuring
?TIME
(not ?SITUATION))
(not
(holdsDuring ?TIME ?SITUATION)))
"místo kde thing byl v čase time" se rovná region tehdy a jen tehdy pokud thing je přesně umístěn v region během time.
(<=>
(equal
(WhereFn ?THING ?TIME)
?REGION)
(holdsDuring
?TIME
(exactlyLocated ?THING ?REGION)))
Jestliže time je instancí třídy časová pozice a agent1 posesses obj během time a agent2 posesses obj během time, potom agent1 se rovná agent2.
(=>
(and
(instance ?TIME TimePosition)
(holdsDuring
?TIME
(possesses ?AGENT1 ?OBJ))
(holdsDuring
?TIME
(possesses ?AGENT2 ?OBJ)))
(equal ?AGENT1 ?AGENT2))
Jestliže inhibits(proc1,proc2) platí, potom pro všechny time,place platí: "existuje proc1 inst1 tak, že inst1 je located at place během time" decreases likelihood of "existuje proc2 inst2 tak, že inst2 je located at place během time".
(=>
(inhibits ?PROC1 ?PROC2)
(forall
(?TIME ?PLACE)
(decreasesLikelihood
(holdsDuring
?TIME
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(located ?INST1 ?PLACE))))
(holdsDuring
?TIME
(exists
(?INST2)
(and
(instance ?INST2 ?PROC2)
(located ?INST2 ?PLACE)))))))
- jestliže prevents(proc1,proc2) platí,
- potom pro všechny time,place platí: jestliže existuje proc1 inst1 tak, že inst1 je located at place během time, potom existuje proc2 inst2 tak, že inst2 je located at place během time
.
(=>
(prevents ?PROC1 ?PROC2)
(forall
(?TIME ?PLACE)
(=>
(holdsDuring
?TIME
(exists
(?INST1)
(and
(instance ?INST1 ?PROC1)
(located ?INST1 ?PLACE))))
(not
(holdsDuring
?TIME
(exists
(?INST2)
(and
(instance ?INST2 ?PROC2)
(located ?INST2 ?PLACE))))))))
- jestliže frequency(proc,time1) platí,
- potom pro všechny time2 platí: jestliže duration of time2 je time1, potom existuje position tak, že position je a part of time2 a existuje inst tak, že inst je instancí třídy proc během position
.
(=>
(frequency ?PROC ?TIME1)
(forall
(?TIME2)
(=>
(duration ?TIME2 ?TIME1)
(exists
(?POSITION)
(and
(temporalPart ?POSITION ?TIME2)
(holdsDuring
?POSITION
(exists
(?INST)
(instance ?INST ?PROC))))))))
Jestliže situation platí během time1 a time2 je a part of time1, potom situation platí během time2.
(=>
(and
(holdsDuring ?TIME1 ?SITUATION)
(temporalPart ?TIME2 ?TIME1))
(holdsDuring ?TIME2 ?SITUATION))
Jestliže rel(inst1,inst2) holds během interval a inst1 je instancí třídy fyzický objekt a inst2 je instancí třídy fyzický objekt, potom inst1 exists during interval a inst2 exists during interval.
(=>
(and
(holdsDuring
?INTERVAL
(holds ?REL ?INST1 ?INST2))
(instance ?INST1 Physical)
(instance ?INST2 Physical))
(and
(time ?INST1 ?INTERVAL)
(time ?INST2 ?INTERVAL)))
Jestliže obj je nástrojem pro proc a the measure of obj je quant1 právě před doba existence proc a the measure of obj je quant2 právě po doba existence proc, potom quant1 je větší než quant2.
(=>
(and
(resource ?PROC ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT2)))
(greaterThan ?QUANT1 ?QUANT2))
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))
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 join je instancí třídy nastoupení do organizace a org je instancí třídy organizace a org je původcem join a person je účastníkem join, potom person je a členem org právě po doba existence join.
(=>
(and
(instance ?JOIN JoiningAnOrganization)
(instance ?ORG Organization)
(agent ?JOIN ?ORG)
(patient ?JOIN ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?JOIN))
(member ?PERSON ?ORG)))
Jestliže leave je instancí třídy opuštění organizace a org je instancí třídy organizace a org je původcem leave a person je účastníkem leave, potom person není a členem org právě po doba existence leave.
(=>
(and
(instance ?LEAVE LeavingAnOrganization)
(instance ?ORG Organization)
(agent ?LEAVE ?ORG)
(patient ?LEAVE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?LEAVE))
(not
(member ?PERSON ?ORG))))
Jestliže hire je instancí třídy najímání a org je instancí třídy organizace a org je původcem hire a person je účastníkem hire, potom org employs person právě po doba existence hire.
(=>
(and
(instance ?HIRE Hiring)
(instance ?ORG Organization)
(agent ?HIRE ?ORG)
(patient ?HIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HIRE))
(employs ?ORG ?PERSON)))
Jestliže fire je instancí třídy ukončení pracovního poměru a org je instancí třídy organizace a org je původcem fire a person je účastníkem fire, potom org doesn't employ person právě po doba existence fire.
(=>
(and
(instance ?FIRE TerminatingEmployment)
(instance ?ORG Organization)
(agent ?FIRE ?ORG)
(patient ?FIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FIRE))
(not
(employs ?ORG ?PERSON))))
Jestliže increase je instancí třídy zvyšování parametru a obj je účastníkem increase, potom existují unit,quant1,quant2 tak, že "obj unit(s)" se rovná quant1 právě před doba existence increase a "obj unit(s)" se rovná quant2 právě po doba existence increase a quant2 je větší než quant1.
(=>
(and
(instance ?INCREASE Increasing)
(patient ?INCREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?INCREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))
Jestliže heat je instancí třídy zahřívání a obj je účastníkem heat, potom existují jednotka teploty unit,quant1,quant2 tak, že "obj unit(s)" se rovná quant1 právě před doba existence heat a "obj unit(s)" se rovná quant2 právě po doba existence heat a quant2 je větší než quant1.
(=>
(and
(instance ?HEAT Heating)
(patient ?HEAT ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HEAT))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(greaterThan ?QUANT2 ?QUANT1))))
Jestliže decrease je instancí třídy snižování parametru a obj je účastníkem decrease, potom existují unit,quant1,quant2 tak, že "obj unit(s)" se rovná quant1 právě před doba existence decrease a "obj unit(s)" se rovná quant2 právě po doba existence decrease a quant2 je menší než quant1.
(=>
(and
(instance ?DECREASE Decreasing)
(patient ?DECREASE ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?DECREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DECREASE))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(lessThan ?QUANT2 ?QUANT1))))
Jestliže cool je instancí třídy ochlazování a obj je účastníkem cool, potom existují jednotka teploty unit,quant1,quant2 tak, že "obj unit(s)" se rovná quant1 právě před doba existence cool a "obj unit(s)" se rovná quant2 právě po doba existence cool a quant2 je menší než quant1.
(=>
(and
(instance ?COOL Cooling)
(patient ?COOL ?OBJ))
(exists
(?UNIT ?QUANT1 ?QUANT2)
(and
(instance ?UNIT TemperatureMeasure)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COOL))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COOL))
(equal
(MeasureFn ?OBJ ?UNIT)
?QUANT2))
(lessThan ?QUANT2 ?QUANT1))))
Jestliže motion je instancí třídy pohyb a obj je účastníkem motion a motion začíná v place, potom obj je located at place právě před doba existence motion.
(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(origin ?MOTION ?PLACE))
(holdsDuring
(ImmediatePastFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))
Jestliže motion je instancí třídy pohyb a obj je účastníkem motion a motion končí v place, potom obj je located at place právě po doba existence motion.
(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(destination ?MOTION ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))
Jestliže proc je instancí třídy změna směru, potom existuje směrový atribut attr tak, že
(=>
(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))))))))
Jestliže remove je instancí třídy odstranění a remove začíná v place a obj je účastníkem remove, potom obj je located at place právě před doba existence remove a obj není located at place právě po doba existence remove.
(=>
(and
(instance ?REMOVE Removing)
(origin ?REMOVE ?PLACE)
(patient ?REMOVE ?OBJ))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?REMOVE))
(located ?OBJ ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?REMOVE))
(not
(located ?OBJ ?PLACE)))))
Jestliže put je instancí třídy uložení a put končí v place a obj je účastníkem put, potom obj není located at place právě před doba existence put a obj je located at place právě po doba existence put.
(=>
(and
(instance ?PUT Putting)
(destination ?PUT ?PLACE)
(patient ?PUT ?OBJ))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?PUT))
(not
(located ?OBJ ?PLACE)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PUT))
(located ?OBJ ?PLACE))))
Jestliže touch je instancí třídy dotyk a obj1 je původcem touch a obj2 je účastníkem touch, potom obj1 je spojen s obj2 právě po doba existence touch.
(=>
(and
(instance ?TOUCH Touching)
(agent ?TOUCH ?OBJ1)
(patient ?TOUCH ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?TOUCH))
(connected ?OBJ1 ?OBJ2)))
Jestliže change je instancí třídy změna vlastnictví a obj je účastníkem change a agent1 posesses obj právě před doba existence change a agent2 posesses obj právě po doba existence change, potom agent1 se nerovná agent2.
(=>
(and
(instance ?CHANGE ChangeOfPossession)
(patient ?CHANGE ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(possesses ?AGENT1 ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(possesses ?AGENT2 ?OBJ)))
(not
(equal ?AGENT1 ?AGENT2)))
Jestliže change je instancí třídy změna vlastnictví a change začíná v agent1 a change končí v agent2 a agent2 je instancí třídy původce a obj je účastníkem change, potom agent1 posesses obj právě před doba existence change a agent2 posesses obj právě po doba existence change.
(=>
(and
(instance ?CHANGE ChangeOfPossession)
(origin ?CHANGE ?AGENT1)
(destination ?CHANGE ?AGENT2)
(instance ?AGENT2 Agent)
(patient ?CHANGE ?OBJ))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(possesses ?AGENT1 ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(possesses ?AGENT2 ?OBJ))))
Jestliže existuje učení se learn tak, že agent je původcem learn a prop je účastníkem learn během time, potom agent believes prop právě po time.
(=>
(holdsDuring
?TIME
(exists
(?LEARN)
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT)
(patient ?LEARN ?PROP))))
(holdsDuring
(ImmediateFutureFn ?TIME)
(believes ?AGENT ?PROP)))
Jestliže meas je instancí třídy měření a agent je původcem meas a obj je účastníkem meas, potom existují quant,unit tak, že agent knows "the measure of obj je "quant unit(s)"" právě po doba existence meas.
(=>
(and
(instance ?MEAS Measuring)
(agent ?MEAS ?AGENT)
(patient ?MEAS ?OBJ))
(exists
(?QUANT ?UNIT)
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MEAS))
(knows
?AGENT
(measure
?OBJ
(MeasureFn ?QUANT ?UNIT))))))
Jestliže predict je instancí třídy předpovídání a formula je účastníkem predict, potom existuje time tak, že formula platí během time a time happens before doba existence predict nebo time happens earlier than "doba existence predict".
(=>
(and
(instance ?PREDICT Predicting)
(patient ?PREDICT ?FORMULA))
(exists
(?TIME)
(and
(holdsDuring ?TIME ?FORMULA)
(or
(before
?TIME
(WhenFn ?PREDICT))
(earlier
?TIME
(WhenFn ?PREDICT))))))
Jestliže remember je instancí třídy zapamatování a formula je účastníkem remember, potom existuje time tak, že formula platí během time a time happens before doba existence remember nebo time happens earlier than "doba existence remember".
(=>
(and
(instance ?REMEMBER Remembering)
(patient ?REMEMBER ?FORMULA))
(exists
(?TIME)
(and
(holdsDuring ?TIME ?FORMULA)
(or
(before
?TIME
(WhenFn ?REMEMBER))
(earlier
?TIME
(WhenFn ?REMEMBER))))))
(=>
(and
(instance ?KEEP Keeping)
(patient ?KEEP ?OBJ))
(exists
(?PLACE)
(forall
(?TIME)
(=>
(temporalPart
?TIME
(WhenFn ?KEEP))
(holdsDuring
?TIME
(located ?OBJ ?PLACE))))))
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 poke je instancí třídy propíchnutí a agent je původcem poke a obj je účastníkem poke a inst je nástrojem for poke, potom inst spojuje agent a obj doba existence poke.
(=>
(and
(instance ?POKE Poking)
(agent ?POKE ?AGENT)
(patient ?POKE ?OBJ)
(instrument ?POKE ?INST))
(holdsDuring
(WhenFn ?POKE)
(connects ?INST ?AGENT ?OBJ)))
Jestliže attach je instancí třídy připojení a obj1 je účastníkem attach a obj2 je účastníkem attach, potom obj1 není spojen s obj2 právě před doba existence attach a obj1 je spojen s obj2 právě po doba existence attach.
(=>
(and
(instance ?ATTACH Attaching)
(patient ?ATTACH ?OBJ1)
(patient ?ATTACH ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ATTACH))
(not
(connected ?OBJ1 ?OBJ2)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ATTACH))
(connected ?OBJ1 ?OBJ2))))
Jestliže detach je instancí třídy odpojení a obj1 je účastníkem detach a obj2 je účastníkem detach, potom obj1 je spojen s obj2 právě před doba existence detach a obj1 není spojen s obj2 právě po doba existence detach.
(=>
(and
(instance ?DETACH Detaching)
(patient ?DETACH ?OBJ1)
(patient ?DETACH ?OBJ2))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?DETACH))
(connected ?OBJ1 ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DETACH))
(not
(connected ?OBJ1 ?OBJ2)))))
combine je instancí třídy spojení a obj1 je nástrojem pro combine a obj2 je výsledkem combine tehdy a jen tehdy pokud obj1 není částí obj2 právě před doba existence combine a obj1 je částí obj2 právě po doba existence 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))))
Jestliže change je instancí třídy interní změna a obj je účastníkem change, potom existuje property tak, že
(=>
(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
(=>
(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 decode je instancí třídy dekódování a doc1 je účastníkem decode, potom existují encode,doc2,time tak, že doc2 contains information prop a doc1 contains information prop a time je a part of před doba existence decode a encode je instancí třídy kódování a doc2 je účastníkem encode během time.
(=>
(and
(instance ?DECODE Decoding)
(patient ?DECODE ?DOC1))
(exists
(?ENCODE ?DOC2 ?TIME)
(and
(containsInformation ?DOC2 ?PROP)
(containsInformation ?DOC1 ?PROP)
(temporalPart
?TIME
(PastFn
(WhenFn ?DECODE)))
(holdsDuring
?TIME
(and
(instance ?ENCODE Encoding)
(patient ?ENCODE ?DOC2))))))
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 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 pursue je instancí třídy sledování a agent je původcem pursue a obj je účastníkem pursue, potom agent wants obj během pursue.
(=>
(and
(instance ?PURSUE Pursuing)
(agent ?PURSUE ?AGENT)
(patient ?PURSUE ?OBJ))
(holdsDuring
?PURSUE
(wants ?AGENT ?OBJ)))
Jestliže pursue je instancí třídy sledování a agent je původcem pursue a obj je účastníkem pursue, potom agent doesn't posess obj během pursue.
(=>
(and
(instance ?PURSUE Pursuing)
(agent ?PURSUE ?AGENT)
(patient ?PURSUE ?OBJ))
(holdsDuring
?PURSUE
(not
(possesses ?AGENT ?OBJ))))
Jestliže investigate je instancí třídy vyšetřování a agent je původcem investigate a prop je účastníkem investigate, potom agent doesn't know prop doba existence investigate.
(=>
(and
(instance ?INVESTIGATE Investigating)
(agent ?INVESTIGATE ?AGENT)
(patient ?INVESTIGATE ?PROP))
(holdsDuring
(WhenFn ?INVESTIGATE)
(not
(knows ?AGENT ?PROP))))
Jestliže state je instancí třídy tvrzení a agent je původcem state a formula je účastníkem state a formula je instancí třídy formule, potom agent believes formula doba existence state.
(=>
(and
(instance ?STATE Stating)
(agent ?STATE ?AGENT)
(patient ?STATE ?FORMULA)
(instance ?FORMULA Formula))
(holdsDuring
(WhenFn ?STATE)
(believes ?AGENT ?FORMULA)))
Jestliže question je instancí třídy dotaz a agent je původcem question a formula je účastníkem question a formula je instancí třídy formule, potom agent doesn't know formula doba existence question.
(=>
(and
(instance ?QUESTION Questioning)
(agent ?QUESTION ?AGENT)
(patient ?QUESTION ?FORMULA)
(instance ?FORMULA Formula))
(holdsDuring
(WhenFn ?QUESTION)
(not
(knows ?AGENT ?FORMULA))))
Jestliže meet je instancí třídy setkání a agent1 je původcem meet a agent2 je původcem meet, potom agent1 je near vzhledem k agent2 doba existence meet.
(=>
(and
(instance ?MEET Meeting)
(agent ?MEET ?AGENT1)
(agent ?MEET ?AGENT2))
(holdsDuring
(WhenFn ?MEET)
(orientation ?AGENT1 ?AGENT2 Near)))
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 developmental form(obj,attr1) platí během time1 a attr2 je a successor attribute of attr1, potom existuje time2 tak, že time2 happens earlier than time1 a developmental form(obj,attr2) platí během time2.
(=>
(and
(holdsDuring
?TIME1
(developmentalForm ?OBJ ?ATTR1))
(successorAttributeClosure ?ATTR2 ?ATTR1))
(exists
(?TIME2)
(and
(earlier ?TIME2 ?TIME1)
(holdsDuring
?TIME2
(developmentalForm ?OBJ ?ATTR2)))))
Jestliže organism lives in obj, potom existuje time tak, že organism je located at obj během time.
(=>
(inhabits ?ORGANISM ?OBJ)
(exists
(?TIME)
(holdsDuring
?TIME
(located ?ORGANISM ?OBJ))))
- jestliže meat je instancí třídy maso,
- potom pro všechny part platí: jestliže part je částí meat, potom existují subpart,time,animal tak, že subpart je částí part a animal je instancí třídy zvíře a subpart je částí animal během 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))))))))
(=>
(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))))))))
(=>
(holdsDuring
?TIME
(direction ?PROC ?ATTR1))
(forall
(?ATTR2)
(=>
(holdsDuring
?TIME
(direction ?PROC ?ATTR2))
(equal ?ATTR2 ?ATTR1))))
- jestliže faces(proc,attr1) platí během time,
- potom pro všechny attr2 platí: jestliže faces(proc,attr2) platí během time, potom attr2 se rovná attr1
.
(=>
(holdsDuring
?TIME
(faces ?PROC ?ATTR1))
(forall
(?ATTR2)
(=>
(holdsDuring
?TIME
(faces ?PROC ?ATTR2))
(equal ?ATTR2 ?ATTR1))))
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 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 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 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))))))
(=>
(instance ?ATTR PsychologicalAttribute)
(=>
(holdsDuring
?TIME
(attribute ?ORGANISM ?ATTR))
(holdsDuring
?TIME
(attribute ?ORGANISM Living))))
