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

¦s¦b®É¶¡¨ç¼Æ (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)

ºØÃþ
is instance of
  ¥iÄ~©ÓÃö«Y  
is instance of
  ®É¶¡Ãö«Y  
is instance of
ºØÃþ
is instance of
  ¥iÄ~©ÓÃö«Y  
is instance of
  ¤@¤¸¨ç¼Æ  
is instance of

is instance of
  ¦s¦b®É¶¡¨ç¼Æ  

Coordinate term(s)

µ´¹ï­È¨ç¼Æ  ´y­z¨ç¼Æ  ©·¾l©¶  ©·¥¿©¶  ©·¥¿¤Á  ¤Ï­±¨ç¼Æ  ¡]®É¶¡¡^¶}©l¨ç¼Æ  ³Ìªì¸`ÂI¨ç¼Æ  ­p¼Æ¨ç¼Æ  ¤W­­¨ç¼Æ  ¤¬¸É¨ç¼Æ  ¾l©¶¨ç¼Æ  ¬Û¥æ¸ô®|¨ç¼Æ  ¤é¨ç¼Æ  ³æ¦ì¨ç¼Æ  ¡]®É¶¡¡^µ²§ô¨ç¦¡  ³Ì«á¸`ÂI¨ç¼Æ  ½d³ò¨ç¼Æ  ¤U­­¨ç¼Æ  ¥¿­±¨ç¼Æ  ¡]®É¶¡¡^¥¼¨Ó¨ç¦¡  ·§¤Æ¨ç¼Æ  ·§¤ÆÁp¶°¨ç¼Æ  ¤Q»õ­p¨ç¼Æ  ¤p®É¨ç¼Æ  µê¼Æ¨ç¼Æ  ³Ìªñ¥¼¨Ó®É¶¡¨ç¼Æ  ³Ìªñ¹L¥h®É¶¡¨ç¼Æ  °_©l¸`ÂI¨ç¼Æ  ¾ã¼Æ¥­¤è®Ú¨ç¼Æ  ¤d­p¨ç¼Æ  ¦Cªø¨ç¼Æ  ¯Å¼Æ¨ç¼Æ  ¦Ê¸U­p¨ç¼Æ  ¦Ê¸U¤À¤§¤@­p¨ç¼Æ  ¤d¤À¤§¤@­p¨ç¼Æ  ³Ì¤p¬Û¥æ¸ô®|¨ç¼Æ  ¤ÀÄÁ¨ç¼Æ  ¤ë¥÷¨ç¼Æ  ©`¦Ì¨ç¼Æ  ¤À¤l¨ç¼Æ  ²Õ´¨ç¼Æ  ¹L¥h®É¶¡¨ç¦¡  ¸ô®|¶q¨ç¼Æ  ¥ü¤À¤§¤@­p¨ç¼Æ  ¾­¶°¦X¨ç¼Æ  «e¼Æ¨ç¼Æ  ¥DÅé¨ç¼Æ  ©ÎµM²v¨ç¼Æ  ¯S©Ê¨ç¼Æ  ¦³²z¼Æ¨ç¼Æ  ¹ê¼Æ¨ç¼Æ  ­Ë¼Æ¨ç¼Æ  ¶g´Á©Ê®É¶Z¨ç¼Æ  ¬Û¹ï®É¶¡¨ç¼Æ  ¾ã¼Æ¨ç¼Æ  ¬íÄÁ¨ç¼Æ  ¥¿­t¸¹¨ç¼Æ  ¥¿©¶¨ç¼Æ  ªí¥Ö¨ç¼Æ  ¥­¤è®Ú¨ç¼Æ  «á¼Æ¨ç¼Æ  ¥¿¤Á¨ç¼Æ  ®É¶¡³æ¦ì¨ç¼Æ  ¥ü­p¨ç¼Æ  ²×¸`ÂI¨ç¼Æ  ®É¶¡¾úµ{¨ç¼Æ  °]²£¨ç¼Æ  ¦~¥÷¨ç¼Æ  ¥ý©ó  ¥ý©ó©Î¦P®É  ¦@¥Í  ¸û¦­  §¹¦¨  ®É¬q¬Û±µ  ®É¬q­«Å|  ®É¶¡¤¶©ó  ®É¶¡¤¶©ó©Î¦P®É  ®É¶¡ 

Type restrictions

®É¬q WhenFn(ª«½èªº)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (69)

¦ì¸m¨ç¼Æ ¤º³¡¬ÛÃö©ó ¦s¦b®É¶¡¨ç¼Æ.
(relatedInternalConcept WhereFn WhenFn)

pos ¬O "thing ¦s¦b ªº ®É¶¡" ªº ³¡¤À if and only if thing (¤£) ¦s¦bs pos ´Á¶¡.
(<=>
      (temporalPart
            ?POS
            (WhenFn ?THING))
      (time ?THING ?POS))

If process (¤£) °_·½s ©ó obj, then "process ¦b ""process ¦s¦b ªº ®É¶¡" ªº }©l" ªº ""process ¦s¦b ªº ®É¶¡" ªº }©l"¦ì¸m" ¦ì©ó "obj ¦b ""obj ¦s¦b ªº ®É¶¡" ªº }©l" ªº ""obj ¦s¦b ªº ®É¶¡" ªº }©l"¦ì¸m".
(=>
      (origin ?PROCESS ?OBJ)
      (located
            (WhereFn
                  ?PROCESS
                  (BeginFn
                        (WhenFn ?PROCESS)))
            (WhereFn
                  ?OBJ
                  (BeginFn
                        (WhenFn ?OBJ)))))

(=>
      (result ?PROC ?OBJ)
      (forall
            (?TIME)
            (=>
                  (before
                        ?TIME
                        (BeginFn
                              (WhenFn ?PROC)))
                  (not
                        (time ?OBJ ?TIME)))))

phys (¤£) ¦s¦bs time ´Á¶¡ and time ¬O ®ÉÂI ªº ¹ê¨Ò if and only if time ¦b ""phys ¦s¦b ªº ®É¶¡" ªº }©l" ©M ""phys ¦s¦b ªº ®É¶¡" ªº µ²§ô" ©Î ¤§¶¡ .
(<=>
      (and
            (time ?PHYS ?TIME)
            (instance ?TIME TimePoint))
      (temporallyBetweenOrEqual
            (BeginFn
                  (WhenFn ?PHYS))
            ?TIME
            (EndFn
                  (WhenFn ?PHYS))))

If rel ¬O ªÅ¶¡Ãö«Y ªº ¹ê¨Ò and rel(obj1,obj2) (¤£) ¦¨¥ßs, then "obj2 ¦s¦b ªº ®É¶¡" (¨S) »P 1 ?­«Å|s.
(=>
      (and
            (instance ?REL SpatialRelation)
            (holds ?REL ?OBJ1 ?OBJ2))
      (overlapsTemporally
            (WhenFn ?OBJ1)
            (WhenFn ?OBJ2)))

phys1 (¨S) »P phys2 ¦P®É µo¥Ínot(s) if and only if "phys1 ¦s¦b ªº ®É¶¡" µ¥©ó "phys2 ¦s¦b ªº ®É¶¡".
(<=>
      (cooccur ?PHYS1 ?PHYS2)
      (equal
            (WhenFn ?PHYS1)
            (WhenFn ?PHYS2)))

If thing ¬O ª«½èªº ªº ¹ê¨Ò, then ""thing ¦s¦b ªº ®É¶¡" ªº }©l" (¨S) µo¥Í?{s} ¦b ""thing ¦s¦b ªº ®É¶¡" ªº µ²§ô" ¤§«e.
(=>
      (instance ?THING Physical)
      (before
            (BeginFn
                  (WhenFn ?THING))
            (EndFn
                  (WhenFn ?THING))))

If thing ¬O ª«½èªº ªº ¹ê¨Ò, then ""thing ¦s¦b ªº ®É¶¡" ¤§«e" (¨S) ¬Û±µs "thing ¦s¦b ªº ®É¶¡".
(=>
      (instance ?THING Physical)
      (meetsTemporally
            (PastFn
                  (WhenFn ?THING))
            (WhenFn ?THING)))

If process ¬O ª«½èªº ªº ¹ê¨Ò, then ""process ¦s¦b ªº ®É¶¡" ¤§«e" µ¥©ó "®É¶¡°_ÂI/¥å¥j ©M ""process ¦s¦b ªº ®É¶¡" ªº }©l" ªº ¶¡¶Z".
(=>
      (instance ?PROCESS Physical)
      (equal
            (PastFn
                  (WhenFn ?PROCESS))
            (TimeIntervalFn
                  NegativeInfinity
                  (BeginFn
                        (WhenFn ?PROCESS)))))

If thing ¬O ª«½èªº ªº ¹ê¨Ò, then ""thing ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e" (¨S) §¹¦¨s ""thing ¦s¦b ªº ®É¶¡" ¤§«e".
(=>
      (instance ?THING Physical)
      (finishes
            (ImmediatePastFn
                  (WhenFn ?THING))
            (PastFn
                  (WhenFn ?THING))))

If obj ¹ï proc ¬O ¸ê·½ and obj ªº ´ú¶q ¬O quant1 ""proc ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "proc ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj ªº ´ú¶q ¬O quant2 ""proc ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "proc ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á, then quant1 (¤£) ¤j©ó quant2.
(=>
      (and
            (resource ?PROC ?OBJ)
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?PROC))
                  (measure ?OBJ ?QUANT1))
            (holdsDuring
                  (ImmediateFutureFn
                        (WhenFn ?PROC))
                  (measure ?OBJ ?QUANT2)))
      (greaterThan ?QUANT1 ?QUANT2))

If thing ¬O ª«½èªº ªº ¹ê¨Ò, then "thing ¦s¦b ªº ®É¶¡" (¨S) ¬Û±µs ""thing ¦s¦b ªº ®É¶¡" ¤§«á".
(=>
      (instance ?THING Physical)
      (meetsTemporally
            (WhenFn ?THING)
            (FutureFn
                  (WhenFn ?THING))))

If process ¬O ª«½èªº ªº ¹ê¨Ò, then ""process ¦s¦b ªº ®É¶¡" ¤§«á" µ¥©ó """process ¦s¦b ªº ®É¶¡" ªº µ²§ô" ©M ®É¶¡²×ÂI/¥Ã»· ªº ¶¡¶Z".
(=>
      (instance ?PROCESS Physical)
      (equal
            (FutureFn
                  (WhenFn ?PROCESS))
            (TimeIntervalFn
                  (EndFn
                        (WhenFn ?PROCESS))
                  PositiveInfinity)))

If thing ¬O ª«½èªº ªº ¹ê¨Ò, then ""thing ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á" (¨S) }©ls ""thing ¦s¦b ªº ®É¶¡" ¤§«á".
(=>
      (instance ?THING Physical)
      (starts
            (ImmediateFutureFn
                  (WhenFn ?THING))
            (FutureFn
                  (WhenFn ?THING))))

If subproc ¬O proc ªº ¦¸¾úµ{, then "subproc ¦s¦b ªº ®É¶¡" µ¥©ó "proc ¦s¦b ªº ®É¶¡" or "subproc ¦s¦b ªº ®É¶¡" (¨S) µo¥Ínot(s) ¦b "proc ¦s¦b ªº ®É¶¡" ´Á¶¡.
(=>
      (subProcess ?SUBPROC ?PROC)
      (or
            (equal
                  (WhenFn ?SUBPROC)
                  (WhenFn ?PROC))
            (during
                  (WhenFn ?SUBPROC)
                  (WhenFn ?PROC))))

If death ¬O ¦º¤` ªº ¹ê¨Ò and agent (¨S) ÅéÅçnot(s) death, then ¦º ¬O agent ªº ÄÝ©Ê ""death ¦s¦b ªº ®É¶¡" ¤§«á"a(¤§¤¤) "death ¦s¦b ªº ®É¶¡" ¤§«á.
(=>
      (and
            (instance ?DEATH Death)
            (experiencer ?DEATH ?AGENT))
      (holdsDuring
            (FutureFn
                  (WhenFn ?DEATH))
            (attribute ?AGENT Dead)))

If death ¬O ¦º¤` ªº ¹ê¨Ò and birth ¬O ½Ï¥Í ªº ¹ê¨Ò and agent (¨S) ÅéÅçnot(s) death and agent (¨S) ÅéÅçnot(s) birth, then there exists time so that "birth ¦s¦b ªº ®É¶¡" (¨S) ¬Û±µs time and time (¨S) ¬Û±µs "death ¦s¦b ªº ®É¶¡" and ¬¡ªº ¬O agent ªº ÄÝ©Ê timea(¤§¤¤) 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 ¬O ®ø¤Æ ªº ¹ê¨Ò and digest ¬O organism ªº ¬I¨ÆªÌ, then there exists Äá­¹ ingest so that ingest ¬O organism ªº ¬I¨ÆªÌ and "digest ¦s¦b ªº ®É¶¡" (¨S) »P 1 ?­«Å|s.
(=>
      (and
            (instance ?DIGEST Digesting)
            (agent ?DIGEST ?ORGANISM))
      (exists
            (?INGEST)
            (and
                  (instance ?INGEST Ingesting)
                  (agent ?INGEST ?ORGANISM)
                  (overlapsTemporally
                        (WhenFn ?INGEST)
                        (WhenFn ?DIGEST)))))

If join ¬O ¥[¤J²Õ´ ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and join ¬O org ªº ¬I¨ÆªÌ and person ¬O join ªº ¨ü¨ÆªÌ, then person ¬O orgªº ¦¨­û ""join ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "join ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?JOIN JoiningAnOrganization)
            (instance ?ORG Organization)
            (agent ?JOIN ?ORG)
            (patient ?JOIN ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?JOIN))
            (member ?PERSON ?ORG)))

If leave ¬O ²æÂ÷²Õ´ ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and leave ¬O org ªº ¬I¨ÆªÌ and person ¬O leave ªº ¨ü¨ÆªÌ, then person ¬O orgªº ¦¨­û ""leave ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "leave ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?LEAVE LeavingAnOrganization)
            (instance ?ORG Organization)
            (agent ?LEAVE ?ORG)
            (patient ?LEAVE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?LEAVE))
            (not
                  (member ?PERSON ?ORG))))

If hire ¬O ¹µ¥Î ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and hire ¬O org ªº ¬I¨ÆªÌ and person ¬O hire ªº ¨ü¨ÆªÌ, then org (¨S) ¶±¥Înot(s) person ""hire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "hire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?HIRE Hiring)
            (instance ?ORG Organization)
            (agent ?HIRE ?ORG)
            (patient ?HIRE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?HIRE))
            (employs ?ORG ?PERSON)))

If fire ¬O ¸Ñ¹µ ªº ¹ê¨Ò and org ¬O ²Õ´ ªº ¹ê¨Ò and fire ¬O org ªº ¬I¨ÆªÌ and person ¬O fire ªº ¨ü¨ÆªÌ, then org not(¨S) ¶±¥Î(s) person ""fire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "fire ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?FIRE TerminatingEmployment)
            (instance ?ORG Organization)
            (agent ?FIRE ?ORG)
            (patient ?FIRE ?PERSON))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?FIRE))
            (not
                  (employs ?ORG ?PERSON))))

If increase ¬O ¼W¥[ ªº ¹ê¨Ò and obj ¬O increase ªº ¨ü¨ÆªÌ, then there exist unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "increase ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 (¤£) ¤j©ó 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 ¬O ¥[·Å ªº ¹ê¨Ò and obj ¬O heat ªº ¨ü¨ÆªÌ, then there exist ·Å«×³æ¦ì unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "heat ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 (¤£) ¤j©ó 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 ¬O ´î¤Ö ªº ¹ê¨Ò and obj ¬O decrease ªº ¨ü¨ÆªÌ, then there exist unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "decrease ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 ¤p©ó 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 ¬O ­°·Å ªº ¹ê¨Ò and obj ¬O cool ªº ¨ü¨ÆªÌ, then there exist ·Å«×³æ¦ì unit,quant1,quant2 so that "obj unit(s)" µ¥©ó quant1 ""cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and "obj unit(s)" µ¥©ó quant2 ""cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "cool ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á and quant2 ¤p©ó 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 ¬O ²¾°Ê ªº ¹ê¨Ò and obj ¬O motion ªº ¨ü¨ÆªÌ and motion (¤£) °_·½s ©ó place, then obj ¦ì©ó place ""motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e.
(=>
      (and
            (instance ?MOTION Motion)
            (patient ?MOTION ?OBJ)
            (origin ?MOTION ?PLACE))
      (holdsDuring
            (ImmediatePastFn
                  (WhenFn ?MOTION))
            (located ?OBJ ?PLACE)))

If motion ¬O ²¾°Ê ªº ¹ê¨Ò and obj ¬O motion ªº ¨ü¨ÆªÌ and motion (¤£) ²×µ²not(s) place, then obj ¦ì©ó place ""motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "motion ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?MOTION Motion)
            (patient ?MOTION ?OBJ)
            (destination ?MOTION ?PLACE))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?MOTION))
            (located ?OBJ ?PLACE)))

If proc ¬O ¤è¦Vªº§ïÅÜ ªº ¹ê¨Ò, then there exists ¤è¦VÄÝ©Ê attr so that
(=>
      (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 ¬O ²¾°£ ªº ¹ê¨Ò and remove (¤£) °_·½s ©ó place and obj ¬O remove ªº ¨ü¨ÆªÌ, then obj ¦ì©ó place ""remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj ¦ì©ó place ""remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "remove ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ©ñ¸m ªº ¹ê¨Ò and put (¤£) ²×µ²not(s) place and obj ¬O put ªº ¨ü¨ÆªÌ, then obj ¦ì©ó place ""put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj ¦ì©ó place ""put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "put ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O IJ°Ê ªº ¹ê¨Ò and touch ¬O obj1 ªº ¬I¨ÆªÌ and obj2 ¬O touch ªº ¨ü¨ÆªÌ, then obj1 »P obj2 ¬Û³s ""touch ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "touch ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?TOUCH Touching)
            (agent ?TOUCH ?OBJ1)
            (patient ?TOUCH ?OBJ2))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?TOUCH))
            (connected ?OBJ1 ?OBJ2)))

If impact ¬O ¼vÅT ªº ¹ê¨Ò and obj ¬O impact ªº ¨ü¨ÆªÌ, then there exists ¬ï³z impel so that obj ¬O impel ªº ¨ü¨ÆªÌ and "impel ¦s¦b ªº ®É¶¡" (¨S) ¤ñ "impact ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?IMPACT Impacting)
            (patient ?IMPACT ?OBJ))
      (exists
            (?IMPEL)
            (and
                  (instance ?IMPEL Impelling)
                  (patient ?IMPEL ?OBJ)
                  (earlier
                        (WhenFn ?IMPEL)
                        (WhenFn ?IMPACT)))))

If change ¬O ¾Ö¦³ÅvªºÂಾ ªº ¹ê¨Ò and obj ¬O change ªº ¨ü¨ÆªÌ and agent1 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and agent2 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á, then agent1 µ¥©ó 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 ¬O ¾Ö¦³ÅvªºÂಾ ªº ¹ê¨Ò and change (¤£) °_·½s ©ó agent1 and change (¤£) ²×µ²not(s) agent2 and agent2 ¬O ¬I¨ÆªÌ ªº ¹ê¨Ò and obj ¬O change ªº ¨ü¨ÆªÌ, then agent1 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and agent2 (¨S) ¾Ö¦³not(s) obj ""change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "change ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ´ú¶q ªº ¹ê¨Ò and meas ¬O agent ªº ¬I¨ÆªÌ and obj ¬O meas ªº ¨ü¨ÆªÌ, then there exist quant,unit so that agent (¤£¡^ª¾¹Ds) %2 ""meas ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "meas ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ¹w´ú ªº ¹ê¨Ò and formula ¬O predict ªº ¨ü¨ÆªÌ, then there exists time so that formula (¨S) ¬°¯u timea(¤§¤¤) time and time (¨S) µo¥Í?{s} ¦b "predict ¦s¦b ªº ®É¶¡" ¤§«e or time (¨S) ¤ñ "predict ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?PREDICT Predicting)
            (patient ?PREDICT ?FORMULA))
      (exists
            (?TIME)
            (and
                  (holdsDuring ?TIME ?FORMULA)
                  (or
                        (before
                              ?TIME
                              (WhenFn ?PREDICT))
                        (earlier
                              ?TIME
                              (WhenFn ?PREDICT))))))

If remember ¬O °O¾Ð ªº ¹ê¨Ò and formula ¬O remember ªº ¨ü¨ÆªÌ, then there exists time so that formula (¨S) ¬°¯u timea(¤§¤¤) time and time (¨S) µo¥Í?{s} ¦b "remember ¦s¦b ªº ®É¶¡" ¤§«e or time (¨S) ¤ñ "remember ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?REMEMBER Remembering)
            (patient ?REMEMBER ?FORMULA))
      (exists
            (?TIME)
            (and
                  (holdsDuring ?TIME ?FORMULA)
                  (or
                        (before
                              ?TIME
                              (WhenFn ?REMEMBER))
                        (earlier
                              ?TIME
                              (WhenFn ?REMEMBER))))))

If keep ¬O «O¦³ ªº ¹ê¨Ò and keep ¬O agent ªº ¬I¨ÆªÌ and obj ¬O keep ªº ¨ü¨ÆªÌ, then there exists ©ñ¸m put so that put ¬O agent ªº ¬I¨ÆªÌ and obj ¬O put ªº ¨ü¨ÆªÌ and "put ¦s¦b ªº ®É¶¡" (¨S) ¤ñ "keep ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (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 ¬O ­×Å@ ªº ¹ê¨Ò and obj ¬O repair ªº ¨ü¨ÆªÌ, then there exists ·l®` damage so that obj ¬O damage ªº ¨ü¨ÆªÌ and "damage ¦s¦b ªº ®É¶¡" (¨S) ¤ñ "repair ¦s¦b ªº ®É¶¡" ¸û¦­ µo¥Ínot(s).
(=>
      (and
            (instance ?REPAIR Repairing)
            (patient ?REPAIR ?OBJ))
      (exists
            (?DAMAGE)
            (and
                  (instance ?DAMAGE Damaging)
                  (patient ?DAMAGE ?OBJ)
                  (earlier
                        (WhenFn ?DAMAGE)
                        (WhenFn ?REPAIR)))))

process ¬O ·´·À ªº ¹ê¨Ò if and only if there exists patient so that patient ¬O process ªº ¨ü¨ÆªÌ and patient (¤£) ¦s¦bs ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e" ´Á¶¡ and patient not(¤£) ¦s¦b ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á" ´Á¶¡.
(<=>
      (instance ?PROCESS Destruction)
      (exists
            (?PATIENT)
            (and
                  (patient ?PROCESS ?PATIENT)
                  (time
                        ?PATIENT
                        (ImmediatePastFn
                              (WhenFn ?PROCESS)))
                  (not
                        (time
                              ?PATIENT
                              (ImmediateFutureFn
                                    (WhenFn ?PROCESS)))))))

If kill ¬O ±þ®` ªº ¹ê¨Ò and patient ¬O kill ªº ¨ü¨ÆªÌ, then ¬¡ªº ¬O patient ªº ÄÝ©Ê ""kill ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "kill ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ¦º ¬O patient ªº ÄÝ©Ê ""kill ¦s¦b ªº ®É¶¡" ¤§«á"a(¤§¤¤) "kill ¦s¦b ªº ®É¶¡" ¤§«á.
(=>
      (and
            (instance ?KILL Killing)
            (patient ?KILL ?PATIENT))
      (and
            (holdsDuring
                  (ImmediatePastFn
                        (WhenFn ?KILL))
                  (attribute ?PATIENT Living))
            (holdsDuring
                  (FutureFn
                        (WhenFn ?KILL))
                  (attribute ?PATIENT Dead))))

If poke ¬O ÂW ªº ¹ê¨Ò and poke ¬O agent ªº ¬I¨ÆªÌ and obj ¬O poke ªº ¨ü¨ÆªÌ and inst ¹ï poke ¬O ¤u¨ã, then inst ³sµ² agent ©M obj "poke ¦s¦b ªº ®É¶¡"a(¤§¤¤) poke ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?POKE Poking)
            (agent ?POKE ?AGENT)
            (patient ?POKE ?OBJ)
            (instrument ?POKE ?INST))
      (holdsDuring
            (WhenFn ?POKE)
            (connects ?INST ?AGENT ?OBJ)))

If attach ¬O ¶Kªþ ªº ¹ê¨Ò and obj1 ¬O attach ªº ¨ü¨ÆªÌ and obj2 ¬O attach ªº ¨ü¨ÆªÌ, then obj1 »P obj2 ¬Û³s ""attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj1 »P obj2 ¬Û³s ""attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "attach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ²æÂ÷ ªº ¹ê¨Ò and obj1 ¬O detach ªº ¨ü¨ÆªÌ and obj2 ¬O detach ªº ¨ü¨ÆªÌ, then obj1 »P obj2 ¬Û³s ""detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj1 »P obj2 ¬Û³s ""detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "detach ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O µ²¦X ªº ¹ê¨Ò and obj1 ¹ï combine ¬O ¸ê·½ and obj2 ¬O combine ªº µ²ªG if and only if obj1 ¬O obj2 ªº ³¡¤À) ""combine ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "combine ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and obj1 ¬O obj2 ªº ³¡¤À) ""combine ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "combine ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(<=>
      (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 ¬O ¤º¦b§ïÅÜ ªº ¹ê¨Ò and obj ¬O 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 ¬O ªí­±§ïÅÜ ªº ¹ê¨Ò and obj ¬O alt ªº ¨ü¨ÆªÌ, then there exist part,property so that part ¬O objªº ¥~ªí³¡¤À and property ¬O part ªº ÄÝ©Ê ""alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and property ¬O part ªº ÄÝ©Ê ""alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "alt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O §Îª¬§ïÅÜ ªº ¹ê¨Ò and obj ¬O alt ªº ¨ü¨ÆªÌ, then there exists §Îª¬ÄÝ©Ê 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 ¬O µÛ¦â ªº ¹ê¨Ò and obj ¬O coloring ªº ¨ü¨ÆªÌ, then there exists ÃC¦âÄÝ©Ê property so that property ¬O obj ªº ÄÝ©Ê ""coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and property ¬O obj ªº ÄÝ©Ê ""coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "coloring ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ¸Ñ½X ªº ¹ê¨Ò and doc1 ¬O decode ªº ¨ü¨ÆªÌ, then there exist encode,doc2,time so that doc2 (¤£) ¥]§ts) °T®§ %2 and doc1 (¤£) ¥]§ts) °T®§ %2 and time ¬O ""decode ¦s¦b ªº ®É¶¡" ¤§«e" ªº ³¡¤À and encode ¬O ½s½X ªº ¹ê¨Ò and doc2 ¬O encode ªº ¨ü¨ÆªÌ timea(¤§¤¤) 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 ¬O Àã¼í ªº ¹ê¨Ò and obj ¬O wet ªº ¨ü¨ÆªÌ, then À㪺 ¬O obj ªº ÄÝ©Ê or ¼éÀã ¬O obj ªº ÄÝ©Ê ""wet ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "wet ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?WET Wetting)
            (patient ?WET ?OBJ))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?WET))
            (or
                  (attribute ?OBJ Wet)
                  (attribute ?OBJ Damp))))

If dry ¬O °®Àê ªº ¹ê¨Ò and obj ¬O dry ªº ¨ü¨ÆªÌ, then °®ªº ¬O obj ªº ÄÝ©Ê ""dry ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "dry ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (and
            (instance ?DRY Drying)
            (patient ?DRY ?OBJ))
      (holdsDuring
            (ImmediateFutureFn
                  (WhenFn ?DRY))
            (attribute ?OBJ Dry)))

process ¬O ²£¥Í ªº ¹ê¨Ò if and only if there exists patient so that patient ¬O process ªº ¨ü¨ÆªÌ and patient (¤£) ¦s¦bs ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á" ´Á¶¡ and patient not(¤£) ¦s¦b ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e" ´Á¶¡.
(<=>
      (instance ?PROCESS Creation)
      (exists
            (?PATIENT)
            (and
                  (patient ?PROCESS ?PATIENT)
                  (time
                        ?PATIENT
                        (ImmediateFutureFn
                              (WhenFn ?PROCESS)))
                  (not
                        (time
                              ?PATIENT
                              (ImmediatePastFn
                                    (WhenFn ?PROCESS)))))))

If investigate ¬O ½Õ¬d ªº ¹ê¨Ò and investigate ¬O agent ªº ¬I¨ÆªÌ and prop ¬O investigate ªº ¨ü¨ÆªÌ, then agent not(¤£¡^ª¾¹D "investigate ¦s¦b ªº ®É¶¡"a(¤§¤¤) investigate ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?INVESTIGATE Investigating)
            (agent ?INVESTIGATE ?AGENT)
            (patient ?INVESTIGATE ?PROP))
      (holdsDuring
            (WhenFn ?INVESTIGATE)
            (not
                  (knows ?AGENT ?PROP))))

If state ¬O ±Ô­z ªº ¹ê¨Ò and state ¬O agent ªº ¬I¨ÆªÌ and formula ¬O state ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then agent (¤£)¬Û«H formula "state ¦s¦b ªº ®É¶¡"a(¤§¤¤) state ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?STATE Stating)
            (agent ?STATE ?AGENT)
            (patient ?STATE ?FORMULA)
            (instance ?FORMULA Formula))
      (holdsDuring
            (WhenFn ?STATE)
            (believes ?AGENT ?FORMULA)))

If question ¬O ¸ß°Ý ªº ¹ê¨Ò and question ¬O agent ªº ¬I¨ÆªÌ and formula ¬O question ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then agent not(¤£¡^ª¾¹D "question ¦s¦b ªº ®É¶¡"a(¤§¤¤) question ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?QUESTION Questioning)
            (agent ?QUESTION ?AGENT)
            (patient ?QUESTION ?FORMULA)
            (instance ?FORMULA Formula))
      (holdsDuring
            (WhenFn ?QUESTION)
            (not
                  (knows ?AGENT ?FORMULA))))

If meet ¬O ·|­± ªº ¹ê¨Ò and meet ¬O agent1 ªº ¬I¨ÆªÌ and meet ¬O agent2 ªº ¬I¨ÆªÌ, then agent1 ¹ï agent2 ¬O ±µªñ "meet ¦s¦b ªº ®É¶¡"a(¤§¤¤) meet ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?MEET Meeting)
            (agent ?MEET ?AGENT1)
            (agent ?MEET ?AGENT2))
      (holdsDuring
            (WhenFn ?MEET)
            (orientation ?AGENT1 ?AGENT2 Near)))

If process ¬O ª¬ºA§ïÅÜ ªº ¹ê¨Ò and obj ¬O process ªº ¨ü¨ÆªÌ, then there exist part,ª«²zª¬ºA state1,ª«²zª¬ºA state2 so that part ¬O obj ªº ³¡¤À) and state1 µ¥©ó state2 and state1 ¬O part ªº ÄÝ©Ê ""process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "process ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and state2 ¬O part ªº ÄÝ©Ê ""freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O º²¤Æ ªº ¹ê¨Ò and obj ¬O melt ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ©TÅ骺 ¬O part ªº ÄÝ©Ê ""melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "melt ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ªmÄË ªº ¹ê¨Ò and obj ¬O boil ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ®ðÅé ¬O part ªº ÄÝ©Ê ""boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "boil ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ¾®µ² ªº ¹ê¨Ò and obj ¬O cond ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ®ðÅé ¬O part ªº ÄÝ©Ê ""cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "cond ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O ¾®©T ªº ¹ê¨Ò and obj ¬O freeze ªº ¨ü¨ÆªÌ, then there exists part so that part ¬O obj ªº ³¡¤À) and ²GÅ骺 ¬O part ªº ÄÝ©Ê ""freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e"a(¤§¤¤) "freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«e and ©TÅ骺 ¬O part ªº ÄÝ©Ê ""freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á"a(¤§¤¤) "freeze ¦s¦b ªº ®É¶¡" ¤£¤[ ¤§«á.
(=>
      (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 ¬O child ªº Âù¿Ë, then ""parent ¦s¦b ªº ®É¶¡" ªº }©l" (¨S) µo¥Í?{s} ¦b ""child ¦s¦b ªº ®É¶¡" ªº }©l" ¤§«e.
(=>
      (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 ¬O ¥Íª«Åé ªº ¹ê¨Ò and process ¬O organism ªº ¬I¨ÆªÌ, then ¬¡ªº ¬O organism ªº ÄÝ©Ê "process ¦s¦b ªº ®É¶¡"a(¤§¤¤) process ¦s¦b ªº ®É¶¡.
(=>
      (and
            (instance ?ORGANISM Organism)
            (agent ?PROCESS ?ORGANISM))
      (holdsDuring
            (WhenFn ?PROCESS)
            (attribute ?ORGANISM Living)))

If §¹¥þ§Î¦¨ªº ¬O obj ªº ÄÝ©Ê, then there exists ¥Íªø growth so that obj (¨S) ÅéÅçnot(s) growth and ¥¼§¹¥þ§Î¦¨ªº ¬O obj ªº ÄÝ©Ê ""obj ¦s¦b ªº ®É¶¡" ªº }©l"a(¤§¤¤) "obj ¦s¦b ªº ®É¶¡" ªº }©l.
(=>
      (attribute ?OBJ FullyFormed)
      (exists
            (?GROWTH)
            (and
                  (instance ?GROWTH Growth)
                  (experiencer ?GROWTH ?OBJ)
                  (holdsDuring
                        (BeginFn
                              (WhenFn ?OBJ))
                        (attribute ?OBJ NonFullyFormed)))))