Select language: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi Concept: English word: Home

# when fn (WhenFn)

A UnaryFunction that maps an Object or Process to the exact TimeInterval during which it exists. Note that, for every TimePoint time outside of the TimeInterval (WhenFn thing), (time thing time) does not hold.

## Ontology

SUMO / TEMPORAL-CONCEPTS

## Class(es)

 class

inheritable relation

temporal relation
 class

inheritable relation

unary function

when fn

## Coordinate term(s)

absolute value fn  abstraction fn  arc cosine fn  arc sine fn  arc tangent fn  back fn  begin fn  begin node fn  cardinality fn  ceiling fn  complement fn  cosine fn  cut set fn  day fn  denominator fn  end fn  end node fn  extension fn  floor fn  front fn  future fn  generalized intersection fn  generalized union fn  giga fn  hour fn  imaginary part fn  immediate future fn  immediate past fn  initial node fn  integer square root fn  kilo fn  list length fn  magnitude fn  mega fn  micro fn  milli fn  minimal cut set fn  minute fn  month fn  nano fn  numerator fn  organization fn  past fn  path weight fn  pico fn  power set fn  predecessor fn  principal host fn  probability fn  property fn  rational number fn  real number fn  reciprocal fn  recurrent time interval fn  relative time fn  round fn  second fn  signum fn  sine fn  skin fn  square root fn  successor fn  tangent fn  temporal composition fn  tera fn  terminal node fn  time interval fn  wealth fn  year fn  before  before or equal  cooccur  earlier  finishes  meets temporally  overlaps temporally  temporally between  temporally between or equal  time

## Type restrictions

time interval WhenFn(physical)

## Related WordNet synsets

See more related synsets on a separate page.

## Axioms (69)

where fn is internally related to when fn.
`(relatedInternalConcept WhereFn WhenFn)`

pos is a part of "the time of existence of thing" if and only if thing exists during pos.
```(<=>
(temporalPart
?POS
(WhenFn ?THING))
(time ?THING ?POS))```

If process origins at obj, then "the place where process was at "the beginning of "the time of existence of process""" is located at "the place where obj was at "the beginning of "the time of existence of obj""".
```(=>
(origin ?PROCESS ?OBJ)
(located
(WhereFn
?PROCESS
(BeginFn
(WhenFn ?PROCESS)))
(WhereFn
?OBJ
(BeginFn
(WhenFn ?OBJ)))))```

• if obj is a result of proc,
• then for all time holds: if time happen?{s} before "the beginning of "the time of existence of proc"", then obj doesn't exist during time
• .
```(=>
(result ?PROC ?OBJ)
(forall
(?TIME)
(=>
(before
?TIME
(BeginFn
(WhenFn ?PROC)))
(not
(time ?OBJ ?TIME)))))```

phys exists during time and time is an instance of time point if and only if time is between or at "the beginning of "the time of existence of phys"" and "the end of "the time of existence of phys"".
```(<=>
(and
(time ?PHYS ?TIME)
(instance ?TIME TimePoint))
(temporallyBetweenOrEqual
(BeginFn
(WhenFn ?PHYS))
?TIME
(EndFn
(WhenFn ?PHYS))))```

If rel is an instance of spatial relation and rel(obj1,obj2) holds, then "the time of existence of obj2" overlaps "the time of existence of obj1".
```(=>
(and
(instance ?REL SpatialRelation)
(holds ?REL ?OBJ1 ?OBJ2))
(overlapsTemporally
(WhenFn ?OBJ1)
(WhenFn ?OBJ2)))```

phys1 occurs at the same time as phys2 if and only if "the time of existence of phys1" is equal to "the time of existence of phys2".
```(<=>
(cooccur ?PHYS1 ?PHYS2)
(equal
(WhenFn ?PHYS1)
(WhenFn ?PHYS2)))```

If thing is an instance of physical, then "the beginning of "the time of existence of thing"" happen?{s} before "the end of "the time of existence of thing"".
```(=>
(instance ?THING Physical)
(before
(BeginFn
(WhenFn ?THING))
(EndFn
(WhenFn ?THING))))```

If thing is an instance of physical, then "before "the time of existence of thing"" meets "the time of existence of thing".
```(=>
(instance ?THING Physical)
(meetsTemporally
(PastFn
(WhenFn ?THING))
(WhenFn ?THING)))```

If process is an instance of physical, then "before "the time of existence of process"" is equal to "interval between negative infinity and "the beginning of "the time of existence of process""".
```(=>
(instance ?PROCESS Physical)
(equal
(PastFn
(WhenFn ?PROCESS))
(TimeIntervalFn
NegativeInfinity
(BeginFn
(WhenFn ?PROCESS)))))```

If thing is an instance of physical, then "immediately before "the time of existence of thing"" finishes "before "the time of existence of thing"".
```(=>
(instance ?THING Physical)
(finishes
(ImmediatePastFn
(WhenFn ?THING))
(PastFn
(WhenFn ?THING))))```

If obj is a resource for proc and the measure of obj is quant1 immediately before "the time of existence of proc" and the measure of obj is quant2 immediately after "the time of existence of proc", then quant1 is greater than quant2.
```(=>
(and
(resource ?PROC ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT2)))
(greaterThan ?QUANT1 ?QUANT2))```

If thing is an instance of physical, then "the time of existence of thing" meets "after "the time of existence of thing"".
```(=>
(instance ?THING Physical)
(meetsTemporally
(WhenFn ?THING)
(FutureFn
(WhenFn ?THING))))```

If process is an instance of physical, then "after "the time of existence of process"" is equal to "interval between "the end of "the time of existence of process"" and positive infinity".
```(=>
(instance ?PROCESS Physical)
(equal
(FutureFn
(WhenFn ?PROCESS))
(TimeIntervalFn
(EndFn
(WhenFn ?PROCESS))
PositiveInfinity)))```

If thing is an instance of physical, then "immediately after "the time of existence of thing"" starts "after "the time of existence of thing"".
```(=>
(instance ?THING Physical)
(starts
(ImmediateFutureFn
(WhenFn ?THING))
(FutureFn
(WhenFn ?THING))))```

If subproc is a subprocess of proc, then "the time of existence of subproc" is equal to "the time of existence of proc" or "the time of existence of subproc" takes place during "the time of existence of proc".
```(=>
(subProcess ?SUBPROC ?PROC)
(or
(equal
(WhenFn ?SUBPROC)
(WhenFn ?PROC))
(during
(WhenFn ?SUBPROC)
(WhenFn ?PROC))))```

If death is an instance of death and agent experiences death, then dead is an attribute of agent after "the time of existence of death".
```(=>
(and
(instance ?DEATH Death)
(experiencer ?DEATH ?AGENT))
(holdsDuring
(FutureFn
(WhenFn ?DEATH))

If death is an instance of death and birth is an instance of birth and agent experiences death and agent experiences birth, then there exists time so that "the time of existence of birth" meets time and time meets "the time of existence of death" and living is an attribute of agent during 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)))))```

If digest is an instance of digesting and digest is an agent of organism, then there exists ingesting ingest so that ingest is an agent of organism and "the time of existence of digest" overlaps "the time of existence of ingest".
```(=>
(and
(instance ?DIGEST Digesting)
(agent ?DIGEST ?ORGANISM))
(exists
(?INGEST)
(and
(instance ?INGEST Ingesting)
(agent ?INGEST ?ORGANISM)
(overlapsTemporally
(WhenFn ?INGEST)
(WhenFn ?DIGEST)))))```

If join is an instance of joining an organization and org is an instance of organization and join is an agent of org and person is a patient of join, then person is a member of org immediately after "the time of existence of join".
```(=>
(and
(instance ?JOIN JoiningAnOrganization)
(instance ?ORG Organization)
(agent ?JOIN ?ORG)
(patient ?JOIN ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?JOIN))
(member ?PERSON ?ORG)))```

If leave is an instance of leaving an organization and org is an instance of organization and leave is an agent of org and person is a patient of leave, then person is not a member of org immediately after "the time of existence of leave".
```(=>
(and
(instance ?LEAVE LeavingAnOrganization)
(instance ?ORG Organization)
(agent ?LEAVE ?ORG)
(patient ?LEAVE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?LEAVE))
(not
(member ?PERSON ?ORG))))```

If hire is an instance of hiring and org is an instance of organization and hire is an agent of org and person is a patient of hire, then org employs person immediately after "the time of existence of hire".
```(=>
(and
(instance ?HIRE Hiring)
(instance ?ORG Organization)
(agent ?HIRE ?ORG)
(patient ?HIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HIRE))
(employs ?ORG ?PERSON)))```

If fire is an instance of terminating employment and org is an instance of organization and fire is an agent of org and person is a patient of fire, then org doesn't employ person immediately after "the time of existence of fire".
```(=>
(and
(instance ?FIRE TerminatingEmployment)
(instance ?ORG Organization)
(agent ?FIRE ?ORG)
(patient ?FIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FIRE))
(not
(employs ?ORG ?PERSON))))```

If increase is an instance of increasing and obj is a patient of increase, then there exist unit,quant1,quant2 so that "obj unit(s)" is equal to quant1 immediately before "the time of existence of increase" and "obj unit(s)" is equal to quant2 immediately after "the time of existence of increase" and quant2 is greater than 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))))```

If heat is an instance of heating and obj is a patient of heat, then there exist temperature measure unit,quant1,quant2 so that "obj unit(s)" is equal to quant1 immediately before "the time of existence of heat" and "obj unit(s)" is equal to quant2 immediately after "the time of existence of heat" and quant2 is greater than 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))))```

If decrease is an instance of decreasing and obj is a patient of decrease, then there exist unit,quant1,quant2 so that "obj unit(s)" is equal to quant1 immediately before "the time of existence of decrease" and "obj unit(s)" is equal to quant2 immediately after "the time of existence of decrease" and quant2 is less than 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))))```

If cool is an instance of cooling and obj is a patient of cool, then there exist temperature measure unit,quant1,quant2 so that "obj unit(s)" is equal to quant1 immediately before "the time of existence of cool" and "obj unit(s)" is equal to quant2 immediately after "the time of existence of cool" and quant2 is less than 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))))```

If motion is an instance of motion and obj is a patient of motion and motion origins at place, then obj is located at place immediately before "the time of existence of motion".
```(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(origin ?MOTION ?PLACE))
(holdsDuring
(ImmediatePastFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))```

If motion is an instance of motion and obj is a patient of motion and motion ends at place, then obj is located at place immediately after "the time of existence of motion".
```(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(destination ?MOTION ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))```

If proc is an instance of direction change, then there exists directional attribute attr so that
• proc is performed in the manner attr immediately before "the time of existence of proc" and proc is performed in the manner attr immediately after "the time of existence of proc"
• or
• proc is performed in the manner attr immediately after "the time of existence of proc" and proc is performed in the manner attr immediately before "the time of existence of proc"
• .
```(=>
(instance ?PROC DirectionChange)
(exists
(?ATTR)
(and
(instance ?ATTR DirectionalAttribute)
(or
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(manner ?PROC ?ATTR))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(not
(manner ?PROC ?ATTR))))
(and
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(manner ?PROC ?ATTR))
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(not
(manner ?PROC ?ATTR))))))))```

If remove is an instance of removing and remove origins at place and obj is a patient of remove, then obj is located at place immediately before "the time of existence of remove" and obj is not located at place immediately after "the time of existence of 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)))))```

If put is an instance of putting and put ends at place and obj is a patient of put, then obj is not located at place immediately before "the time of existence of put" and obj is located at place immediately after "the time of existence of 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))))```

If touch is an instance of touching and touch is an agent of obj1 and obj2 is a patient of touch, then obj1 is connected to obj2 immediately after "the time of existence of touch".
```(=>
(and
(instance ?TOUCH Touching)
(agent ?TOUCH ?OBJ1)
(patient ?TOUCH ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?TOUCH))
(connected ?OBJ1 ?OBJ2)))```

If impact is an instance of impacting and obj is a patient of impact, then there exists impelling impel so that obj is a patient of impel and "the time of existence of impel" happens earlier than "the time of existence of impact".
```(=>
(and
(instance ?IMPACT Impacting)
(patient ?IMPACT ?OBJ))
(exists
(?IMPEL)
(and
(instance ?IMPEL Impelling)
(patient ?IMPEL ?OBJ)
(earlier
(WhenFn ?IMPEL)
(WhenFn ?IMPACT)))))```

If change is an instance of change of possession and obj is a patient of change and agent1 posesses obj immediately before "the time of existence of change" and agent2 posesses obj immediately after "the time of existence of change", then agent1 is not equal to 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)))```

If change is an instance of change of possession and change origins at agent1 and change ends at agent2 and agent2 is an instance of agent and obj is a patient of change, then agent1 posesses obj immediately before "the time of existence of change" and agent2 posesses obj immediately after "the time of existence of 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))))```

If meas is an instance of measuring and meas is an agent of agent and obj is a patient of meas, then there exist quant,unit so that agent knows "the measure of obj is "quant unit(s)"" immediately after "the time of existence of 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))))))```

If predict is an instance of predicting and formula is a patient of predict, then there exists time so that formula holds during time and time happen?{s} before "the time of existence of predict" or time happens earlier than "the time of existence of predict".
```(=>
(and
(instance ?PREDICT Predicting)
(patient ?PREDICT ?FORMULA))
(exists
(?TIME)
(and
(holdsDuring ?TIME ?FORMULA)
(or
(before
?TIME
(WhenFn ?PREDICT))
(earlier
?TIME
(WhenFn ?PREDICT))))))```

If remember is an instance of remembering and formula is a patient of remember, then there exists time so that formula holds during time and time happen?{s} before "the time of existence of remember" or time happens earlier than "the time of existence of remember".
```(=>
(and
(instance ?REMEMBER Remembering)
(patient ?REMEMBER ?FORMULA))
(exists
(?TIME)
(and
(holdsDuring ?TIME ?FORMULA)
(or
(before
?TIME
(WhenFn ?REMEMBER))
(earlier
?TIME
(WhenFn ?REMEMBER))))))```

If keep is an instance of keeping and keep is an agent of agent and obj is a patient of keep, then there exists putting put so that put is an agent of agent and obj is a patient of put and "the time of existence of put" happens earlier than "the time of existence of keep".
```(=>
(and
(instance ?KEEP Keeping)
(agent ?KEEP ?AGENT)
(patient ?KEEP ?OBJ))
(exists
(?PUT)
(and
(instance ?PUT Putting)
(agent ?PUT ?AGENT)
(patient ?PUT ?OBJ)
(earlier
(WhenFn ?PUT)
(WhenFn ?KEEP)))))```

```(=>
(and
(instance ?KEEP Keeping)
(patient ?KEEP ?OBJ))
(exists
(?PLACE)
(forall
(?TIME)
(=>
(temporalPart
?TIME
(WhenFn ?KEEP))
(holdsDuring
?TIME
(located ?OBJ ?PLACE))))))```

If repair is an instance of repairing and obj is a patient of repair, then there exists damaging damage so that obj is a patient of damage and "the time of existence of damage" happens earlier than "the time of existence of repair".
```(=>
(and
(instance ?REPAIR Repairing)
(patient ?REPAIR ?OBJ))
(exists
(?DAMAGE)
(and
(instance ?DAMAGE Damaging)
(patient ?DAMAGE ?OBJ)
(earlier
(WhenFn ?DAMAGE)
(WhenFn ?REPAIR)))))```

process is an instance of destruction if and only if there exists patient so that patient is a patient of process and patient exists during "immediately before "the time of existence of process"" and patient doesn't exist during "immediately after "the time of existence of process"".
```(<=>
(instance ?PROCESS Destruction)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))))))```

If kill is an instance of killing and patient is a patient of kill, then living is an attribute of patient immediately before "the time of existence of kill" and dead is an attribute of patient after "the time of existence of kill".
```(=>
(and
(instance ?KILL Killing)
(patient ?KILL ?PATIENT))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?KILL))
(attribute ?PATIENT Living))
(holdsDuring
(FutureFn
(WhenFn ?KILL))

If poke is an instance of poking and poke is an agent of agent and obj is a patient of poke and inst is an instrument for poke, then inst connects agent and obj the time of existence of poke.
```(=>
(and
(instance ?POKE Poking)
(agent ?POKE ?AGENT)
(patient ?POKE ?OBJ)
(instrument ?POKE ?INST))
(holdsDuring
(WhenFn ?POKE)
(connects ?INST ?AGENT ?OBJ)))```

If attach is an instance of attaching and obj1 is a patient of attach and obj2 is a patient of attach, then obj1 is not connected to obj2 immediately before "the time of existence of attach" and obj1 is connected to obj2 immediately after "the time of existence of 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))))```

If detach is an instance of detaching and obj1 is a patient of detach and obj2 is a patient of detach, then obj1 is connected to obj2 immediately before "the time of existence of detach" and obj1 is not connected to obj2 immediately after "the time of existence of 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 is an instance of combining and obj1 is a resource for combine and obj2 is a result of combine if and only if obj1 is not a part of obj2 immediately before "the time of existence of combine" and obj1 is a part of obj2 immediately after "the time of existence of 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))))```

If change is an instance of internal change and obj is a patient of change, then there exists property so that
```(=>
(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))))))```

If alt is an instance of surface change and obj is a patient of alt, then there exist part,property so that part is a superficial part of obj and property is an attribute of part immediately before "the time of existence of alt" and property is not an attribute of part immediately after "the time of existence of 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))))))```

If alt is an instance of shape change and obj is a patient of alt, then there exists shape attribute property so that
```(=>
(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)))))))```

If coloring is an instance of coloring and obj is a patient of coloring, then there exists color attribute property so that property is an attribute of obj immediately before "the time of existence of coloring" and property is not an attribute of obj immediately after "the time of existence of 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))))))```

If decode is an instance of decoding and doc1 is a patient of decode, then there exist encode,doc2,time so that doc2 contains information prop and doc1 contains information prop and time is a part of "before "the time of existence of decode"" and encode is an instance of encoding and doc2 is a patient of encode during 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))))))```

If wet is an instance of wetting and obj is a patient of wet, then wet is an attribute of obj or damp is an attribute of obj immediately after "the time of existence of wet".
```(=>
(and
(instance ?WET Wetting)
(patient ?WET ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?WET))
(or
(attribute ?OBJ Wet)
(attribute ?OBJ Damp))))```

If dry is an instance of drying and obj is a patient of dry, then dry is an attribute of obj immediately after "the time of existence of dry".
```(=>
(and
(instance ?DRY Drying)
(patient ?DRY ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DRY))
(attribute ?OBJ Dry)))```

process is an instance of creation if and only if there exists patient so that patient is a patient of process and patient exists during "immediately after "the time of existence of process"" and patient doesn't exist during "immediately before "the time of existence of process"".
```(<=>
(instance ?PROCESS Creation)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))))))```

If investigate is an instance of investigating and investigate is an agent of agent and prop is a patient of investigate, then agent doesn't know prop the time of existence of investigate.
```(=>
(and
(instance ?INVESTIGATE Investigating)
(agent ?INVESTIGATE ?AGENT)
(patient ?INVESTIGATE ?PROP))
(holdsDuring
(WhenFn ?INVESTIGATE)
(not
(knows ?AGENT ?PROP))))```

If state is an instance of stating and state is an agent of agent and formula is a patient of state and formula is an instance of formula, then agent believes formula the time of existence of state.
```(=>
(and
(instance ?STATE Stating)
(agent ?STATE ?AGENT)
(patient ?STATE ?FORMULA)
(instance ?FORMULA Formula))
(holdsDuring
(WhenFn ?STATE)
(believes ?AGENT ?FORMULA)))```

If question is an instance of questioning and question is an agent of agent and formula is a patient of question and formula is an instance of formula, then agent doesn't know formula the time of existence of question.
```(=>
(and
(instance ?QUESTION Questioning)
(agent ?QUESTION ?AGENT)
(patient ?QUESTION ?FORMULA)
(instance ?FORMULA Formula))
(holdsDuring
(WhenFn ?QUESTION)
(not
(knows ?AGENT ?FORMULA))))```

If meet is an instance of meeting and meet is an agent of agent1 and meet is an agent of agent2, then agent1 is near to agent2 the time of existence of meet.
```(=>
(and
(instance ?MEET Meeting)
(agent ?MEET ?AGENT1)
(agent ?MEET ?AGENT2))
(holdsDuring
(WhenFn ?MEET)
(orientation ?AGENT1 ?AGENT2 Near)))```

If process is an instance of state change and obj is a patient of process, then there exist part,physical state state1,physical state state2 so that part is a part of obj and state1 is not equal to state2 and state1 is an attribute of part immediately before "the time of existence of process" and state2 is an attribute of part immediately after "the time of existence of 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)))))```

If melt is an instance of melting and obj is a patient of melt, then there exists part so that part is a part of obj and solid is an attribute of part immediately before "the time of existence of melt" and liquid is an attribute of part immediately after "the time of existence of 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)))))```

If boil is an instance of boiling and obj is a patient of boil, then there exists part so that part is a part of obj and liquid is an attribute of part immediately before "the time of existence of boil" and gas is an attribute of part immediately after "the time of existence of 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)))))```

If cond is an instance of condensing and obj is a patient of cond, then there exists part so that part is a part of obj and gas is an attribute of part immediately before "the time of existence of cond" and liquid is an attribute of part immediately after "the time of existence of 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)))))```

If freeze is an instance of freezing and obj is a patient of freeze, then there exists part so that part is a part of obj and liquid is an attribute of part immediately before "the time of existence of freeze" and solid is an attribute of part immediately after "the time of existence of 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)))))```

If parent is a parent of child, then "the beginning of "the time of existence of parent"" happen?{s} before "the beginning of "the time of existence of child"".
```(=>
(parent ?CHILD ?PARENT)
(before
(BeginFn
(WhenFn ?PARENT))
(BeginFn
(WhenFn ?CHILD))))```

```(=>
(instance ?ARTIFACT StationaryArtifact)
(exists
(?PLACE)
(forall
(?TIME)
(=>
(and
(beforeOrEqual
?TIME
(EndFn
(WhenFn ?ARTIFACT)))
(beforeOrEqual
(BeginFn
(WhenFn ?ARTIFACT))
?TIME))
(equal
(WhereFn ?ARTIFACT ?TIME)
?PLACE)))))```

If organism is an instance of organism and process is an agent of organism, then living is an attribute of organism the time of existence of process.
```(=>
(and
(instance ?ORGANISM Organism)
(agent ?PROCESS ?ORGANISM))
(holdsDuring
(WhenFn ?PROCESS)
(attribute ?ORGANISM Living)))```

If fully formed is an attribute of obj, then there exists growth growth so that obj experiences growth and non fully formed is an attribute of obj the beginning of "the time of existence of obj".
```(=>
(attribute ?OBJ FullyFormed)
(exists
(?GROWTH)
(and
(instance ?GROWTH Growth)
(experiencer ?GROWTH ?OBJ)
(holdsDuring
(BeginFn
(WhenFn ?OBJ))
(attribute ?OBJ NonFullyFormed)))))```