SofortigeZukunftFn (ImmediateFutureFn)
A UnaryFunction that maps a
TimePosition to a short, indeterminate TimeInterval that
immediately follows the TimePosition.
Ontology
SUMO / TEMPORAL-CONCEPTSClass(es)
Coordinate term(s)
AbsolutbetragFn
AbstraktionFn
ArcuskosinusFn
ArcussinusFn
ArcustangensFn
RückseiteFn
AnfangFn
BeginNullPunktFn
KardinalitätFn
ObersteGrenzeFn
ErgänzungFn
KosinusFn
SchnittMengeFn
TagFn
NennerFn
EndeFn
EndeNullPunktFn
ExtensionFn
UntersteGrenzeFn
FrontseiteFn
ZukunftFn
GeneralisierteDurchschnittFn
GeneralisierteVereinigungFn
GigaFn
StundeFn
ImaginäresTeilFn
DirektVergangenheitFn
AusgangsNullPunktFn
GanzzahlQuadratwurzelFn
KiloFn
ListeLängeFn
GrösseFn
MegaFn
MicroFn
MilliFn
MinimaleSchnittMengeFn
MinuteFn
MonatFn
NanoFn
ZählerFn
OrganisationFn
VergangenheitFn
PfadGewichtfn
PicoFn
PotenzMengeFn
VorgängerFn
HauptwirtFn
Wahrscheinlichkeit
EigentumFn
RationaleZahlFn
ReelleZahlfn
ReziprokerWert
RückläufigeZeitAbstandFn
RelativeZeitFn
RundFn
SekundFn
SignumFn
SinusFn
OberflächeFn
QuadratwurzelFn
NachfolgerFn
TangensFn
ZeitlicheAufbauFn
TeraFn
TerminalNullPunktFn
ZeitabstandFn
Füllefn
WennFn
JahrFn
vor
vorOderGleichzeitig
zusammenGeschiecht
früh
beendet
schliesstZeitlichAn
decktSichZeitlich
zeitlichZwischen
zeitlichZwischenOderGleichzeitig
zeit
Type restrictions
Zeitabstand ImmediateFutureFn(Zeitposition)
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)
Wenn obj ist ein hilfmittel für proc und "das mass von obj ist quant1 " hält während "direkt vor "die zeit des Bestehens von proc"" und "das mass von obj ist quant2 " hält während "sofort nach "die zeit des Bestehens von proc"" , dann quant1 ist grösserAls quant2 .
(=>
(and
(resource ?PROC ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?PROC))
(measure ?OBJ ?QUANT2)))
(greaterThan ?QUANT1 ?QUANT2))
Wenn thing ist ein fall von körperlicher Gegenstand , dann "sofort nach "die zeit des Bestehens von thing"" beginnt "nach "die zeit des Bestehens von thing"" .
(=>
(instance ?THING Physical)
(starts
(ImmediateFutureFn
(WhenFn ?THING))
(FutureFn
(WhenFn ?THING))))
Wenn join ist ein fall von gehen zu einer Organisation und org ist ein fall von Organisation und join ist der agent von org und person ist ein patient von join , dann "person ist ein Mitglied von org " hält während "sofort nach "die zeit des Bestehens von join"" .
(=>
(and
(instance ?JOIN JoiningAnOrganization)
(instance ?ORG Organization)
(agent ?JOIN ?ORG)
(patient ?JOIN ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?JOIN))
(member ?PERSON ?ORG)))
Wenn leave ist ein fall von verlassen eine Organisation und org ist ein fall von Organisation und leave ist der agent von org und person ist ein patient von leave , dann "person ist ein Mitglied von org nicht" hält während "sofort nach "die zeit des Bestehens von leave"" .
(=>
(and
(instance ?LEAVE LeavingAnOrganization)
(instance ?ORG Organization)
(agent ?LEAVE ?ORG)
(patient ?LEAVE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?LEAVE))
(not
(member ?PERSON ?ORG))))
Wenn hire ist ein fall von Einstellen und org ist ein fall von Organisation und hire ist der agent von org und person ist ein patient von hire , dann "org beschäftigt person " hält während "sofort nach "die zeit des Bestehens von hire"" .
(=>
(and
(instance ?HIRE Hiring)
(instance ?ORG Organization)
(agent ?HIRE ?ORG)
(patient ?HIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?HIRE))
(employs ?ORG ?PERSON)))
Wenn fire ist ein fall von Beenden Beschäftigung und org ist ein fall von Organisation und fire ist der agent von org und person ist ein patient von fire , dann "org beschäftigt person nicht" hält während "sofort nach "die zeit des Bestehens von fire"" .
(=>
(and
(instance ?FIRE TerminatingEmployment)
(instance ?ORG Organization)
(agent ?FIRE ?ORG)
(patient ?FIRE ?PERSON))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FIRE))
(not
(employs ?ORG ?PERSON))))
Wenn increase ist ein fall von Zunehmen und obj ist ein patient von increase , dann es gibt ein unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von increase"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von increase"" und quant2 ist grösserAls 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))))
Wenn heat ist ein fall von Erhitzen und obj ist ein patient von heat , dann es gibt ein Temperaturmass unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von heat"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von heat"" und quant2 ist grösserAls 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))))
Wenn decrease ist ein fall von Abnehmen und obj ist ein patient von decrease , dann es gibt ein unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von decrease"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von decrease"" und quant2 ist kleinerAls 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))))
Wenn cool ist ein fall von Abkühlen und obj ist ein patient von cool , dann es gibt ein Temperaturmass unit,quant1,quant2 der ""obj unit(s)" ist gleich quant1 " hält während "direkt vor "die zeit des Bestehens von cool"" und ""obj unit(s)" ist gleich quant2 " hält während "sofort nach "die zeit des Bestehens von cool"" und quant2 ist kleinerAls 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))))
Wenn motion ist ein fall von Bewegung und obj ist ein patient von motion und motion endet an place , dann "obj befindet sich an " hält während "sofort nach "die zeit des Bestehens von motion"" .
(=>
(and
(instance ?MOTION Motion)
(patient ?MOTION ?OBJ)
(destination ?MOTION ?PLACE))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MOTION))
(located ?OBJ ?PLACE)))
Wenn proc ist ein fall von Umlenkung , dann es gibt ein Richtungsattribut attr der - "proc wird in der Weise von attr durchgeführt" hält während "direkt vor "die zeit des Bestehens von proc"" und "proc wird in der Weise von attr durchgeführt" hält während "sofort nach "die zeit des Bestehens von proc""
oder - "proc wird in der Weise von attr durchgeführt" hält während "sofort nach "die zeit des Bestehens von proc"" und "proc wird in der Weise von attr durchgeführt" hält während "direkt vor "die zeit des Bestehens von 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))))))))
Wenn remove ist ein fall von Entfernen und remove beginnet an place und obj ist ein patient von remove , dann "obj befindet sich an " hält während "direkt vor "die zeit des Bestehens von remove"" und "obj befindet sich an nicht" hält während "sofort nach "die zeit des Bestehens von 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)))))
Wenn put ist ein fall von Setzen und put endet an place und obj ist ein patient von put , dann "obj befindet sich an nicht" hält während "direkt vor "die zeit des Bestehens von put"" und "obj befindet sich an " hält während "sofort nach "die zeit des Bestehens von 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))))
Wenn touch ist ein fall von Berühren und touch ist der agent von obj1 und obj2 ist ein patient von touch , dann "obj1 wird an obj2 angeschlossen" hält während "sofort nach "die zeit des Bestehens von touch"" .
(=>
(and
(instance ?TOUCH Touching)
(agent ?TOUCH ?OBJ1)
(patient ?TOUCH ?OBJ2))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?TOUCH))
(connected ?OBJ1 ?OBJ2)))
Wenn change ist ein fall von Änderung des Besitzes und obj ist ein patient von change und "agent1 besitzt obj " hält während "direkt vor "die zeit des Bestehens von change"" und "agent2 besitzt obj " hält während "sofort nach "die zeit des Bestehens von change"" , dann agent1 ist gleich agent2 nicht.
(=>
(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)))
Wenn change ist ein fall von Änderung des Besitzes und change beginnet an agent1 und change endet an agent2 und agent2 ist ein fall von Agent und obj ist ein patient von change , dann "agent1 besitzt obj " hält während "direkt vor "die zeit des Bestehens von change"" und "agent2 besitzt obj " hält während "sofort nach "die zeit des Bestehens von 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))))
Wenn "es gibt ein Lernen learn der learn ist der agent von agent und prop ist ein patient von learn " hält während time , dann "agent glaubt , dass prop" hält während "sofort nach time" .
(=>
(holdsDuring
?TIME
(exists
(?LEARN)
(and
(instance ?LEARN Learning)
(agent ?LEARN ?AGENT)
(patient ?LEARN ?PROP))))
(holdsDuring
(ImmediateFutureFn ?TIME)
(believes ?AGENT ?PROP)))
Wenn meas ist ein fall von Messen und meas ist der agent von agent und obj ist ein patient von meas , dann es gibt ein quant,unit der "agent kennt "das mass von obj ist "quant unit(s)" " " hält während "sofort nach "die zeit des Bestehens von 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 ist ein fall von Zerstörung nur wenn es gibt ein patient der patient ist ein patient von process und patient besteht während "direkt vor "die zeit des Bestehens von process"" und patient besteht während "sofort nach "die zeit des Bestehens von process"" nicht.
(<=>
(instance ?PROCESS Destruction)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))))))
Wenn attach ist ein fall von Befestigung und obj1 ist ein patient von attach und obj2 ist ein patient von attach , dann "obj1 wird an obj2 nicht angeschlossen" hält während "direkt vor "die zeit des Bestehens von attach"" und "obj1 wird an obj2 angeschlossen" hält während "sofort nach "die zeit des Bestehens von 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))))
Wenn detach ist ein fall von Abtrennen und obj1 ist ein patient von detach und obj2 ist ein patient von detach , dann "obj1 wird an obj2 angeschlossen" hält während "direkt vor "die zeit des Bestehens von detach"" und "obj1 wird an obj2 nicht angeschlossen" hält während "sofort nach "die zeit des Bestehens von 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 ist ein fall von Kombinieren und obj1 ist ein hilfmittel für combine und obj2 ist ein resultat von combine nur wenn "obj1 ist ein teil von obj2 nicht" hält während "direkt vor "die zeit des Bestehens von combine"" und "obj1 ist ein teil von obj2 " hält während "sofort nach "die zeit des Bestehens von 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))))
Wenn change ist ein fall von innere Änderung und obj ist ein patient von change , dann es gibt ein property der
(=>
(and
(instance ?CHANGE InternalChange)
(patient ?CHANGE ?OBJ))
(exists
(?PROPERTY)
(or
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(attribute ?OBJ ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(not
(attribute ?OBJ ?PROPERTY))))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?CHANGE))
(not
(attribute ?OBJ ?PROPERTY)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?CHANGE))
(attribute ?OBJ ?PROPERTY))))))
Wenn alt ist ein fall von Oberflächenänderung und obj ist ein patient von alt , dann es gibt ein part,property der part ist ein oberflächliches teil von obj und "property ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von alt"" und "property ist ein attribut von part nicht" hält während "sofort nach "die zeit des Bestehens von alt"" .
(=>
(and
(instance ?ALT SurfaceChange)
(patient ?ALT ?OBJ))
(exists
(?PART ?PROPERTY)
(and
(superficialPart ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?ALT))
(attribute ?PART ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ALT))
(not
(attribute ?PART ?PROPERTY))))))
Wenn alt ist ein fall von Formänderung und obj ist ein patient von alt , dann es gibt ein Formattribut property der
(=>
(and
(instance ?ALT ShapeChange)
(patient ?ALT ?OBJ))
(exists
(?PROPERTY)
(and
(instance ?PROPERTY ShapeAttribute)
(or
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ALT))
(attribute ?OBJ ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ALT))
(not
(attribute ?OBJ ?PROPERTY))))
(and
(holdsDuring
(ImmediatePastFn
(WhenFn ?ALT))
(not
(attribute ?OBJ ?PROPERTY)))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?ALT))
(attribute ?OBJ ?PROPERTY)))))))
Wenn coloring ist ein fall von Farbe und obj ist ein patient von coloring , dann es gibt ein Farbeattribut property der "property ist ein attribut von obj " hält während "direkt vor "die zeit des Bestehens von coloring"" und "property ist ein attribut von obj nicht" hält während "sofort nach "die zeit des Bestehens von coloring"" .
(=>
(and
(instance ?COLORING Coloring)
(patient ?COLORING ?OBJ))
(exists
(?PROPERTY)
(and
(instance ?PROPERTY ColorAttribute)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COLORING))
(attribute ?OBJ ?PROPERTY))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COLORING))
(not
(attribute ?OBJ ?PROPERTY))))))
Wenn wet ist ein fall von Befeuchten und obj ist ein patient von wet , dann "wet ist ein attribut von obj oder damp ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von wet"" .
(=>
(and
(instance ?WET Wetting)
(patient ?WET ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?WET))
(or
(attribute ?OBJ Wet)
(attribute ?OBJ Damp))))
Wenn dry ist ein fall von Trocknen und obj ist ein patient von dry , dann "dry ist ein attribut von obj " hält während "sofort nach "die zeit des Bestehens von dry"" .
(=>
(and
(instance ?DRY Drying)
(patient ?DRY ?OBJ))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?DRY))
(attribute ?OBJ Dry)))
process ist ein fall von Kreation nur wenn es gibt ein patient der patient ist ein patient von process und patient besteht während "sofort nach "die zeit des Bestehens von process"" und patient besteht während "direkt vor "die zeit des Bestehens von process"" nicht.
(<=>
(instance ?PROCESS Creation)
(exists
(?PATIENT)
(and
(patient ?PROCESS ?PATIENT)
(time
?PATIENT
(ImmediateFutureFn
(WhenFn ?PROCESS)))
(not
(time
?PATIENT
(ImmediatePastFn
(WhenFn ?PROCESS)))))))
Wenn process ist ein fall von Zustandänderung und obj ist ein patient von process , dann es gibt ein part,körperliche Zustand state1,körperliche Zustand state2 der part ist ein teil von obj und state1 ist gleich state2 nicht und "state1 ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von process"" und "state2 ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .
(=>
(and
(instance ?PROCESS StateChange)
(patient ?PROCESS ?OBJ))
(exists
(?PART ?STATE1 ?STATE2)
(and
(part ?PART ?OBJ)
(instance ?STATE1 PhysicalState)
(instance ?STATE2 PhysicalState)
(not
(equal ?STATE1 ?STATE2))
(holdsDuring
(ImmediatePastFn
(WhenFn ?PROCESS))
(attribute ?PART ?STATE1))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FREEZE))
(attribute ?PART ?STATE2)))))
Wenn melt ist ein fall von schmelzend und obj ist ein patient von melt , dann es gibt ein part der part ist ein teil von obj und "solid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von melt"" und "liquid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von melt"" .
(=>
(and
(instance ?MELT Melting)
(patient ?MELT ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?MELT))
(attribute ?PART Solid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?MELT))
(attribute ?PART Liquid)))))
Wenn boil ist ein fall von kochend und obj ist ein patient von boil , dann es gibt ein part der part ist ein teil von obj und "liquid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von boil"" und "gas ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von boil"" .
(=>
(and
(instance ?BOIL Boiling)
(patient ?BOIL ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?BOIL))
(attribute ?PART Liquid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?BOIL))
(attribute ?PART Gas)))))
Wenn cond ist ein fall von kondensierend und obj ist ein patient von cond , dann es gibt ein part der part ist ein teil von obj und "gas ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von cond"" und "liquid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von cond"" .
(=>
(and
(instance ?COND Condensing)
(patient ?COND ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?COND))
(attribute ?PART Gas))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?COND))
(attribute ?PART Liquid)))))
Wenn freeze ist ein fall von einfrierend und obj ist ein patient von freeze , dann es gibt ein part der part ist ein teil von obj und "liquid ist ein attribut von part " hält während "direkt vor "die zeit des Bestehens von freeze"" und "solid ist ein attribut von part " hält während "sofort nach "die zeit des Bestehens von freeze"" .
(=>
(and
(instance ?FREEZE Freezing)
(patient ?FREEZE ?OBJ))
(exists
(?PART)
(and
(part ?PART ?OBJ)
(holdsDuring
(ImmediatePastFn
(WhenFn ?FREEZE))
(attribute ?PART Liquid))
(holdsDuring
(ImmediateFutureFn
(WhenFn ?FREEZE))
(attribute ?PART Solid)))))
