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

immediate future fn (ImmediateFutureFn)

A UnaryFunction that maps a TimePosition to a short, indeterminate TimeInterval that immediately follows the TimePosition.

Ontology

SUMO / TEMPORAL-CONCEPTS

Class(es)

 Classe

inheritable relation

RelazioneTemporale
 Classe

inheritable relation

FunzioneUnaria

immediate future 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 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  when fn  year fn  before  before or equal  cooccur  earlier  finishes  meets temporally  overlaps temporally  temporally between  temporally between or equal  time

Type restrictions

IntervalloTemporale ImmediateFutureFn(PosizioneTemporale)

Related WordNet synsets

offing
the near or foreseeable future; "there was a wedding in the offing"

impend
be imminent or about to happen; "Changes are impending"

at hand(p), close at hand(p), imminent, impending
close in time; about to occur; "retribution is at hand"; "some people believe the day of judgment is close at hand"; "in imminent danger"; "his impending retirement"

hereupon
immediately after this; "hereupon, the passengers stumbled aboard"
straightway
at once; "straightway the clouds began to scatter"
thereupon, therewith, with that
immediately after that; "thereupon the entire class applauded"; "with that, she left the room"; "I therewith withdraw my complaints"
See more related synsets on a separate page.

Axioms (35)

Se obj é una risorsa per proc e "lamisura obj é quant1" vales durante "immediatamente prima di "il tempo di esistenza di proc"" e "lamisura obj é quant2" vales durante "immediatamente dopo "il tempo di esistenza di proc"", allora quant1 é più grande di quant2.
```(=>
(and
(resource ?PROC ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT2)))
(greaterThan ?QUANT1 ?QUANT2))```

Se thing é un' istanza di EntitáConcreta, allora "immediatamente dopo "il tempo di esistenza di thing"" inizias "dopo "il tempo di esistenza di thing"".
```(=>
(instance ?THING Physical)
(starts
(ImmediateFutureFn
(WhenFn ?THING))
(FutureFn
(WhenFn ?THING))))```

Se join é un' istanza di AdesioneAdUn'Organizzazione e org é un' istanza di Organizzazione e join é un agente di org e person é un paziente di join, allora "person é un membro di org" vales durante "immediatamente dopo "il tempo di esistenza di join"".
```(=>
(and
(instance ?JOIN JoiningAnOrganization)
(instance ?ORG Organization)
(agent ?JOIN ?ORG)
(patient ?JOIN ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?JOIN))
(member ?PERSON ?ORG)))```

Se leave é un' istanza di AbbandonoDiUn'Organizzazione e org é un' istanza di Organizzazione e leave é un agente di org e person é un paziente di leave, allora "person é not un membro di org" vales durante "immediatamente dopo "il tempo di esistenza di leave"".
```(=>
(and
(instance ?LEAVE LeavingAnOrganization)
(instance ?ORG Organization)
(agent ?LEAVE ?ORG)
(patient ?LEAVE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?LEAVE))
(not
(member ?PERSON ?ORG))))```

Se hire é un' istanza di Assunzione e org é un' istanza di Organizzazione e hire é un agente di org e person é un paziente di hire, allora "org impiegas person" vales durante "immediatamente dopo "il tempo di esistenza di hire"".
```(=>
(and
(instance ?HIRE Hiring)
(instance ?ORG Organization)
(agent ?HIRE ?ORG)
(patient ?HIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HIRE))
(employs ?ORG ?PERSON)))```

Se fire é un' istanza di CessazioneDiRapportoLavorativo e org é un' istanza di Organizzazione e fire é un agente di org e person é un paziente di fire, allora "org non impiega person" vales durante "immediatamente dopo "il tempo di esistenza di fire"".
```(=>
(and
(instance ?FIRE TerminatingEmployment)
(instance ?ORG Organization)
(agent ?FIRE ?ORG)
(patient ?FIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FIRE))
(not
(employs ?ORG ?PERSON))))```

Se increase é un' istanza di Aumento e obj é un paziente di increase, allora esiste unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di increase"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di increase"" e quant2 é più grande di 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))))```

Se heat é un' istanza di Riscaldamento e obj é un paziente di heat, allora esiste MisuraDiTemperatura unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di heat"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di heat"" e quant2 é più grande di 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))))```

Se decrease é un' istanza di Diminuzione e obj é un paziente di decrease, allora esiste unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di decrease"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di decrease"" e quant2 é meno diquant1.
```(=>
(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))))```

Se cool é un' istanza di Raffreddamento e obj é un paziente di cool, allora esiste MisuraDiTemperatura unit,quant1,quant2 tale che ""obj unit(s" is uguale a quant1" vales durante "immediatamente prima di "il tempo di esistenza di cool"" e ""obj unit(s" is uguale a quant2" vales durante "immediatamente dopo "il tempo di esistenza di cool"" e quant2 é meno diquant1.
```(=>
(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))))```

Se motion é un' istanza di Movimento e obj é un paziente di motion e motion fines in place, allora "obj é localizzato in place" vales durante "immediatamente dopo "il tempo di esistenza di motion"".
```(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(destination ?MOTION ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))```

Se proc é un' istanza di CambioDiDirezione, allora esiste AttributoDirezionale attr tale che
• "proc é eseguito nel modo attr" vales durante "immediatamente prima di "il tempo di esistenza di proc"" e "proc é eseguito nel modo attr" vales durante "immediatamente dopo "il tempo di esistenza di proc""
• o
• "proc é eseguito nel modo attr" vales durante "immediatamente dopo "il tempo di esistenza di proc"" e "proc é eseguito nel modo attr" vales durante "immediatamente prima di "il tempo di esistenza di 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))))))))```

Se remove é un' istanza di Spostamento e remove si originas in place e obj é un paziente di remove, allora "obj é localizzato in place" vales durante "immediatamente prima di "il tempo di esistenza di remove"" e "obj é not localizzato in place" vales durante "immediatamente dopo "il tempo di esistenza di 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)))))```

Se put é un' istanza di Porre e put fines in place e obj é un paziente di put, allora "obj é not localizzato in place" vales durante "immediatamente prima di "il tempo di esistenza di put"" e "obj é localizzato in place" vales durante "immediatamente dopo "il tempo di esistenza di 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))))```

Se touch é un' istanza di Toccare e touch é un agente di obj1 e obj2 é un paziente di touch, allora "obj1 é connesso a obj2" vales durante "immediatamente dopo "il tempo di esistenza di touch"".
```(=>
(and
(instance ?TOUCH Touching)
(agent ?TOUCH ?OBJ1)
(patient ?TOUCH ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?TOUCH))
(connected ?OBJ1 ?OBJ2)))```

Se change é un' istanza di CambiamentodiPossesso e obj é un paziente di change e "agent1 possiedees obj" vales durante "immediatamente prima di "il tempo di esistenza di change"" e "agent2 possiedees obj" vales durante "immediatamente dopo "il tempo di esistenza di change"", allora agent1 is not uguale a 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)))```

Se change é un' istanza di CambiamentodiPossesso e change si originas in agent1 e change fines in agent2 e agent2 é un' istanza di Agente e obj é un paziente di change, allora "agent1 possiedees obj" vales durante "immediatamente prima di "il tempo di esistenza di change"" e "agent2 possiedees obj" vales durante "immediatamente dopo "il tempo di esistenza di 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))))```

Se "esiste Apprendere learn tale che learn é un agente di agent e prop é un paziente di learn" vales durante time, allora "agent believes prop" vales durante "immediatamente dopo time".
```(=>
(holdsDuring
?TIME
(exists
(?LEARN)
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT)
(patient ?LEARN ?PROP))))
(holdsDuring
(ImmediateFutureFn ?TIME)
(believes ?AGENT ?PROP)))```

Se meas é un' istanza di Misurare e meas é un agente di agent e obj é un paziente di meas, allora esiste quant,unit tale che "agent conosces "lamisura obj é "quant unit(s""" vales durante "immediatamente dopo "il tempo di esistenza di 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))))))```

process é un' istanza di Distruggere se e solo se esiste patient tale che patient é un paziente di process e patient esistes durante "immediatamente prima di "il tempo di esistenza di process"" e patient non esiste durante "immediatamente dopo "il tempo di esistenza di process"".
```(<=>
(instance ?PROCESS Destruction)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))))))```

Se attach é un' istanza di Attaccare e obj1 é un paziente di attach e obj2 é un paziente di attach, allora "obj1 é not connesso a obj2" vales durante "immediatamente prima di "il tempo di esistenza di attach"" e "obj1 é connesso a obj2" vales durante "immediatamente dopo "il tempo di esistenza di 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))))```

Se detach é un' istanza di Staccare e obj1 é un paziente di detach e obj2 é un paziente di detach, allora "obj1 é connesso a obj2" vales durante "immediatamente prima di "il tempo di esistenza di detach"" e "obj1 é not connesso a obj2" vales durante "immediatamente dopo "il tempo di esistenza di 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 é un' istanza di Combinare e obj1 é una risorsa per combine e obj2 é un risultato di combine se e solo se "obj1 é not una parte di obj2" vales durante "immediatamente prima di "il tempo di esistenza di combine"" e "obj1 é una parte di obj2" vales durante "immediatamente dopo "il tempo di esistenza di 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))))```

Se change é un' istanza di CambiamentoInterno e obj é un paziente di change, allora esiste property tale che
```(=>
(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))))))```

Se alt é un' istanza di CambiamentoDiSuperficie e obj é un paziente di alt, allora esiste part,property tale che part é una parte superficiale di obj e "property is an attribute of part" vales durante "immediatamente prima di "il tempo di esistenza di alt"" e "property is not an attribute of part" vales durante "immediatamente dopo "il tempo di esistenza di 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))))))```

Se alt é un' istanza di CambiamentoDiForma e obj é un paziente di alt, allora esiste AttributoDiForma property tale che
```(=>
(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)))))))```

Se coloring é un' istanza di Colorare e obj é un paziente di coloring, allora esiste AttributoDiColore property tale che "property is an attribute of obj" vales durante "immediatamente prima di "il tempo di esistenza di coloring"" e "property is not an attribute of obj" vales durante "immediatamente dopo "il tempo di esistenza di 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))))))```

Se wet é un' istanza di Bagnare e obj é un paziente di wet, allora "wet is an attribute of obj o damp is an attribute of obj" vales durante "immediatamente dopo "il tempo di esistenza di wet"".
```(=>
(and
(instance ?WET Wetting)
(patient ?WET ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?WET))
(or
(attribute ?OBJ Wet)
(attribute ?OBJ Damp))))```

Se dry é un' istanza di Asciugare e obj é un paziente di dry, allora "dry is an attribute of obj" vales durante "immediatamente dopo "il tempo di esistenza di dry"".
```(=>
(and
(instance ?DRY Drying)
(patient ?DRY ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DRY))
(attribute ?OBJ Dry)))```

process é un' istanza di Creazione se e solo se esiste patient tale che patient é un paziente di process e patient esistes durante "immediatamente dopo "il tempo di esistenza di process"" e patient non esiste durante "immediatamente prima di "il tempo di esistenza di process"".
```(<=>
(instance ?PROCESS Creation)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))))))```

Se process é un' istanza di CambiamentoDiStato e obj é un paziente di process, allora esiste part,StatoFisico state1,StatoFisico state2 tale che part é una parte di obj e state1 is not uguale a state2 e "state1 is an attribute of part" vales durante "immediatamente prima di "il tempo di esistenza di process"" e "state2 is an attribute of part" vales durante "immediatamente dopo "il tempo di esistenza di 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)))))```

Se melt é un' istanza di Sciogliere e obj é un paziente di melt, allora esiste part tale che part é una parte di obj e "solid is an attribute of part" vales durante "immediatamente prima di "il tempo di esistenza di melt"" e "liquid is an attribute of part" vales durante "immediatamente dopo "il tempo di esistenza di 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)))))```

Se boil é un' istanza di Bollire e obj é un paziente di boil, allora esiste part tale che part é una parte di obj e "liquid is an attribute of part" vales durante "immediatamente prima di "il tempo di esistenza di boil"" e "gas is an attribute of part" vales durante "immediatamente dopo "il tempo di esistenza di 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)))))```

Se cond é un' istanza di Condensare e obj é un paziente di cond, allora esiste part tale che part é una parte di obj e "gas is an attribute of part" vales durante "immediatamente prima di "il tempo di esistenza di cond"" e "liquid is an attribute of part" vales durante "immediatamente dopo "il tempo di esistenza di 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)))))```

Se freeze é un' istanza di Congelare e obj é un paziente di freeze, allora esiste part tale che part é una parte di obj e "liquid is an attribute of part" vales durante "immediatamente prima di "il tempo di esistenza di freeze"" e "solid is an attribute of part" vales durante "immediatamente dopo "il tempo di esistenza di 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)))))```